@membranehq/react 0.1.0

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+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));
+}
+
+export { CUSTOM_ARRAY_VALUE, CUSTOM_ARRAY_VALUE_LABEL, CUSTOM_OBJECT_VALUE, CUSTOM_OBJECT_VALUE_LABEL, isCustomFieldValue };

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+import { SvgIconType } from '../../SvgIcon/svg-icon-type.mjs';
+import { filterOptionsByLabel } from './utils.mjs';
+
+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.ListOption
+          });
+        } else {
+          options.push({
+            label: enumValue,
+            value: enumValue,
+            iconType: SvgIconType.ListOption
+          });
+        }
+      });
+    }
+    const filteredOptions = filterOptionsByLabel(options, input);
+    if (filteredOptions.length > 0) {
+      return [
+        {
+          label: "Possible Values",
+          iconUri: this.params.iconUri,
+          isSection: true
+        },
+        ...filteredOptions
+      ];
+    } else {
+      return [];
+    }
+  }
+}
+
+export { EnumOptionFactory };

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

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

package/dist/esm/components/ComboBox/options-factories/formula/index.mjs

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

package/dist/esm/components/ComboBox/options-factories/generate-schema-options.mjs

@@ -0,0 +1,202 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { Fragment as Fragment$1 } from 'react';
+import { isValidLocator, locatorToSteps, getSchemaByLocator, getNameComponentsForLocator, locatorToField, stepsToLocator, getIconUriForLocator, DataLocatorStepObjectProperty, DataLocatorStepArrayItem } from '@membranehq/sdk';
+import { toHeaderCase } from 'js-convert-case';
+import { SvgIconType } from '../../SvgIcon/svg-icon-type.mjs';
+import { DropdownCategoryType } from '../shared.mjs';
+import { doesSchemaMatchValueType } from '../value-spec.mjs';
+import { ConstantOptionFactory } from './constant.mjs';
+import { ObjectFieldsOptionFactory } from './object-fields.mjs';
+import { ValueNestingIcon } from '../Badges/EditorTagBadge/NestedBadgeValue.mjs';
+
+function getOptionsForSchema({
+  schema,
+  locator,
+  valueSpec,
+  showIcons = true,
+  skipNameComponentsPrefix = [],
+  ignorePrefix = false,
+  nameComponentsByLocator = null,
+  schemaByLocator = null,
+  exampleVariables = null,
+  expandObject = true,
+  editableSchemaLocators = []
+}) {
+  if (!isValidLocator(locator)) {
+    return [];
+  }
+  const locatorSteps = locatorToSteps(locator);
+  const options = [];
+  const optionsSchema = schemaByLocator ?? getSchemaByLocator(schema, locator);
+  if (!optionsSchema) {
+    return [];
+  }
+  let nameComponents = nameComponentsByLocator ?? getNameComponentsForLocator(schema, locator);
+  nameComponents = ignorePrefix ? nameComponents : nameComponents.filter(
+    // If skipNameComponentsPrefix is set, filter out its items from name components
+    (component, idx) => !(skipNameComponentsPrefix?.[idx] === component)
+  );
+  const isSchemaEditable = editableSchemaLocators.some(
+    (l) => locatorToField(stepsToLocator(locatorSteps)).startsWith(locatorToField(l))
+  );
+  const label = getLabelNodeFromNameComponents(nameComponents);
+  const textLabel = nameComponents?.length > 0 ? nameComponents.join(" ") : optionsSchema.title;
+  const searchLabel = nameComponents.join(" ");
+  const iconUri = showIcons ? getIconUriForLocator(schema, locator) : null;
+  const iconType = !iconUri ? SvgIconType.ListOption : void 0;
+  if (optionsSchema.type == "object") {
+    const isInvisibleObject = optionsSchema.title === "";
+    if (expandObject || isInvisibleObject) {
+      const hideWholeObject = !optionsSchema.title && locator?.length === 0;
+      if (doesSchemaMatchValueType(optionsSchema, valueSpec) && !hideWholeObject) {
+        options.push({
+          label: label ?? textLabel,
+          searchLabel,
+          value: {
+            $var: stepsToLocator(locatorToSteps(locator))
+          },
+          /* FIXME: strictNullCheck temporary fix */
+          // @ts-expect-error TS(2322): Type 'string | null' is not assignable to type 'st... Remove this comment to see the full error message
+          iconUri,
+          iconType
+        });
+      }
+      for (const key of Object.keys(optionsSchema.properties ?? {})) {
+        const propertySchema = optionsSchema.properties[key];
+        if (!propertySchema) {
+          continue;
+        }
+        const propertyLocator = [...locatorSteps, new DataLocatorStepObjectProperty(key)];
+        const newNameComponents = [...nameComponents];
+        const newNameComponent = propertySchema.title ?? toHeaderCase(key);
+        if (newNameComponent) {
+          newNameComponents.push(newNameComponent);
+        }
+        options.push(
+          ...getOptionsForSchema({
+            schema,
+            locator: propertyLocator,
+            valueSpec,
+            showIcons,
+            skipNameComponentsPrefix,
+            ignorePrefix,
+            nameComponentsByLocator: newNameComponents,
+            schemaByLocator: propertySchema,
+            exampleVariables,
+            expandObject: false,
+            editableSchemaLocators
+          })
+        );
+      }
+      if (isSchemaEditable) {
+        options.push({
+          label: `Add${textLabel ? ` "${textLabel}"` : ""} Property`,
+          searchLabel: "",
+          iconType: SvgIconType.Add,
+          addVariable: `${stepsToLocator(locatorSteps)}`
+        });
+      }
+    } else {
+      if (doesSchemaMatchValueType(optionsSchema, valueSpec, true) || isSchemaEditable) {
+        const propCount = Object.keys(optionsSchema.properties ?? {}).length;
+        options.push({
+          label,
+          searchLabel,
+          childrenCount: propCount > 0 ? propCount : void 0,
+          /* FIXME: strictNullCheck temporary fix */
+          // @ts-expect-error TS(2322): Type 'string | null' is not assignable to type 'st... Remove this comment to see the full error message
+          iconUri,
+          iconType,
+          drillDownOptionFactory: new ObjectFieldsOptionFactory({
+            name: textLabel,
+            schema,
+            locator,
+            exampleVariables,
+            isSection: true,
+            editableSchemaLocators
+          }),
+          childCategory: DropdownCategoryType.VARIABLE
+        });
+      }
+    }
+  } else if (optionsSchema.type == "array") {
+    if (doesSchemaMatchValueType(optionsSchema, valueSpec, true) || doesSchemaMatchValueType(optionsSchema.items, valueSpec, true)) {
+      const listOptions = [];
+      if (doesSchemaMatchValueType(optionsSchema, valueSpec)) {
+        listOptions.push({
+          label,
+          searchLabel,
+          value: {
+            $var: stepsToLocator(locatorToSteps(locator))
+          },
+          iconType,
+          iconUri: iconUri || void 0
+        });
+      }
+      if (optionsSchema.items && doesSchemaMatchValueType(optionsSchema.items, valueSpec, true)) {
+        const firstArrayItemLocator = [...locatorSteps, new DataLocatorStepArrayItem(0)];
+        listOptions.push(
+          ...getOptionsForSchema({
+            schema,
+            locator: firstArrayItemLocator,
+            valueSpec,
+            showIcons,
+            skipNameComponentsPrefix,
+            ignorePrefix,
+            nameComponentsByLocator: ["Item #1"],
+            schemaByLocator: optionsSchema.items,
+            exampleVariables,
+            expandObject,
+            editableSchemaLocators
+          })
+        );
+      }
+      options.push({
+        label,
+        searchLabel,
+        /* FIXME: strictNullCheck temporary fix */
+        // @ts-expect-error TS(2322): Type 'string | null' is not assignable to type 'st... Remove this comment to see the full error message
+        iconUri,
+        iconType,
+        drillDownOptionFactory: new ConstantOptionFactory(listOptions)
+      });
+    }
+  } else {
+    if (doesSchemaMatchValueType(optionsSchema, valueSpec)) {
+      options.push({
+        label,
+        searchLabel,
+        value: {
+          $var: stepsToLocator(locatorToSteps(locator))
+        },
+        /* FIXME: strictNullCheck temporary fix */
+        // @ts-expect-error TS(2322): Type 'string | null' is not assignable to type 'st... Remove this comment to see the full error message
+        iconUri,
+        iconType
+      });
+    }
+  }
+  return options;
+}
+function getLabelNodeFromNameComponents(nameComponents) {
+  if (!nameComponents?.length) {
+    return null;
+  }
+  if (nameComponents.length === 1) {
+    return nameComponents[0];
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: nameComponents.map((name, idx) => /* @__PURE__ */ jsxs(Fragment$1, { children: [
+    idx ? /* @__PURE__ */ jsx(ValueNestingIcon, {}) : null,
+    name
+  ] }, idx)) });
+}
+
+export { getOptionsForSchema };