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

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

@@ -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';
+
+'use strict';
+
+var index = require('../../SvgIcon/index.cjs');
+var valueSpec = require('../value-spec.cjs');
+var base = require('./base.cjs');
+
+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 === valueSpec.ValueType.ANY || spec.type === valueSpec.ValueType.OBJECT) {
+      options.push({
+        label: CUSTOM_OBJECT_VALUE_LABEL,
+        value: CUSTOM_OBJECT_VALUE,
+        iconType: index.SvgIconType.SchemaType_object
+      });
+    }
+    if (spec.type === valueSpec.ValueType.ANY || spec.type === valueSpec.ValueType.ARRAY) {
+      options.push({
+        label: CUSTOM_ARRAY_VALUE_LABEL,
+        value: CUSTOM_ARRAY_VALUE,
+        iconType: index.SvgIconType.SchemaType_array
+      });
+    }
+    return base.filterOptionsByLabel(options, input);
+  }
+}
+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.CustomFieldOptionsFactory = CustomFieldOptionsFactory;
+exports.isCustomFieldValue = isCustomFieldValue;

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

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+'use strict';
+
+var base = require('./base.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
+          });
+        } else {
+          options.push({
+            label: enumValue,
+            value: enumValue
+          });
+        }
+      });
+    }
+    const filteredOptions = base.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/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+'use strict';
+
+require('fuse');
+require('../../SvgIcon/index.cjs');
+require('@integration-app/sdk');
+require('js-convert-case');
+require('react/jsx-runtime');
+require('react');
+require('../../Tag/styles.module.css.cjs');
+
+function getSchemaHint(schema) {
+  function formatExample(example) {
+    const exampleStr = example.toString();
+    return exampleStr.length > 30 ? exampleStr.substr(0, 30) + "\u2026" : exampleStr;
+  }
+  if (schema.examples) {
+    return schema.examples.map(formatExample).join(", ");
+  } else if (schema.type == "object") {
+    const propertiesNum = Object.keys(schema.properties ?? {}).length;
+    if (propertiesNum > 0) {
+      return `Object with ${propertiesNum} propert${propertiesNum == 1 ? "y" : "ies"}`;
+    } else {
+      return "Object";
+    }
+  } else {
+    return schema.type;
+  }
+}
+
+exports.getSchemaHint = getSchemaHint;

package/dist/cjs/components/ComboBox/options-factories/object-fields.cjs

@@ -0,0 +1,108 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+'use strict';
+
+var jsConvertCase = require('js-convert-case');
+var sdk = require('@integration-app/sdk');
+var base = require('./base.cjs');
+var schema = require('./schema.cjs');
+var valueSpec = require('../value-spec.cjs');
+var index = require('../../SvgIcon/index.cjs');
+
+class ObjectFieldsOptionFactory {
+  constructor(parameters) {
+    this.parameters = parameters;
+  }
+  async getOptions({ input, spec }) {
+    return this.getOptionsSync({ input, spec });
+  }
+  getOptionsSync({ input, spec }) {
+    const locator = this.parameters.locator ?? "$";
+    if (!sdk.isValidLocator(locator)) {
+      return [];
+    }
+    const locatorSteps = sdk.locatorToSteps(locator);
+    const objectSchema = sdk.getSchemaByLocator(this.parameters.schema, locator);
+    if (objectSchema?.type !== "object") {
+      return [];
+    }
+    const isSchemaEditable = this.parameters.editableSchemaLocators?.some(
+      (l) => sdk.locatorToField(sdk.stepsToLocator(locatorSteps)).startsWith(
+        sdk.locatorToField(l)
+      )
+    );
+    const showFullName = !!input;
+    const options = [];
+    if (valueSpec.doesSchemaMatchValueType(objectSchema, spec) && locator && locator !== "$") {
+      options.push({
+        label: "Whole Object",
+        value: {
+          $var: sdk.stepsToLocator(sdk.locatorToSteps(locator))
+        },
+        iconType: index.SvgIconType.SchemaType_object
+      });
+    }
+    for (const [fieldKey, fieldSchema] of Object.entries(
+      objectSchema.properties || {}
+    )) {
+      const propertyLocator = [
+        ...locatorSteps,
+        new sdk.DataLocatorStepObjectProperty(fieldKey)
+      ];
+      const objectNameComponents = sdk.getNameComponentsForLocator(
+        this.parameters.schema,
+        locator
+      );
+      options.push(
+        ...schema.getOptionsForSchema({
+          schema: this.parameters.schema,
+          locator: propertyLocator,
+          valueSpec: spec,
+          showIcons: !this.parameters.isSection,
+          schemaByLocator: fieldSchema,
+          exampleVariables: this.parameters.exampleVariables,
+          skipNameComponentsPrefix: objectNameComponents,
+          nameComponentsByLocator: [
+            /* FIXME: strictNullCheck temporary fix */
+            // @ts-expect-error TS(2488): Type 'string[] | undefined' must have a '[Symbol.iterator]()' m... Remove this comment to see the full error message
+            ...objectNameComponents,
+            fieldSchema?.title ?? jsConvertCase.toHeaderCase(fieldKey)
+          ],
+          expandObject: false
+        })
+      );
+    }
+    if (isSchemaEditable) {
+      options.push({
+        label: `New${this.parameters?.name ? ` "${this.parameters.name}"` : ""} property`,
+        searchLabel: "",
+        hint: `Add property to this object`,
+        iconType: index.SvgIconType.Add,
+        addVariable: `${sdk.stepsToLocator(locatorSteps)}`,
+        isHighlighted: true
+      });
+    }
+    const filteredOptions = base.filterOptionsByLabel(options, input);
+    if (filteredOptions.length > 0) {
+      const result = filteredOptions;
+      if (this.parameters.isSection) {
+        result.unshift({
+          label: showFullName ? sdk.getFullNameForLocator(this.parameters.schema, locator) : sdk.getNameForLocator(this.parameters.schema, locator),
+          isSection: true,
+          iconUri: sdk.getIconUriForLocator(this.parameters.schema, locator)
+        });
+      }
+      return result;
+    } else {
+      return [];
+    }
+  }
+}
+
+exports.ObjectFieldsOptionFactory = ObjectFieldsOptionFactory;

package/dist/cjs/components/ComboBox/options-factories/reference-records.cjs

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+'use strict';
+
+var base = require('./base.cjs');
+
+class ReferenceRecordsOptionsFactory {
+  constructor(params) {
+    this.params = params;
+  }
+  async getOptions({ input }) {
+    return this.getOptionsSync({ input });
+  }
+  getOptionsSync({ input }) {
+    const options = [];
+    if (this.params.schema.referenceRecords && Array.isArray(this.params.schema.referenceRecords)) {
+      this.params.schema.referenceRecords.map((record) => {
+        if (typeof record == "object" && record.id !== void 0) {
+          options.push({
+            label: record.name ?? record.id,
+            value: record.id
+          });
+        }
+      });
+    }
+    const filteredOptions = base.filterOptionsByLabel(options, input);
+    if (filteredOptions.length > 0) {
+      return [
+        {
+          label: "Possible Values",
+          isSection: true,
+          iconUri: this.params.iconUri
+        },
+        ...filteredOptions
+      ];
+    } else {
+      return [];
+    }
+  }
+}
+
+exports.ReferenceRecordsOptionsFactory = ReferenceRecordsOptionsFactory;

package/dist/cjs/components/ComboBox/options-factories/reference-udm.cjs

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+'use strict';
+
+var sdk = require('@integration-app/sdk');
+var index = require('../../SvgIcon/index.cjs');
+var base = require('./base.cjs');
+
+class ReferenceUdmOptionFactory {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  async getOptions({ input }) {
+    const options = [];
+    const udm = this.schema?.referenceUdm;
+    const udmSpec = sdk.UNIFIED_DATA_MODELS[udm];
+    if (udmSpec) {
+      options.push({
+        label: "Select Dynamically Using Variables",
+        iconType: index.SvgIconType.Search,
+        value: {
+          $lookup: {}
+        }
+      });
+    }
+    return base.filterOptionsByLabel(options, input);
+  }
+}
+
+exports.ReferenceUdmOptionFactory = ReferenceUdmOptionFactory;

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

@@ -0,0 +1,254 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var jsConvertCase = require('js-convert-case');
+var sdk = require('@integration-app/sdk');
+var React = require('react');
+var SegmentSeparator = require('../../Tag/SegmentSeparator.cjs');
+var valueSpec = require('../value-spec.cjs');
+var index$1 = require('./index.cjs');
+var objectFields = require('./object-fields.cjs');
+var constant = require('./constant.cjs');
+var index = require('../../SvgIcon/index.cjs');
+
+class SchemaOptionFactory {
+  constructor(parameters) {
+    this.parameters = parameters;
+  }
+  async getOptions({ input, spec }) {
+    return this.getOptionsSync({ input, spec });
+  }
+  getOptionsSync({ input, spec }) {
+    const locator = this.parameters.locator ?? "$";
+    const showFullPath = !!input;
+    const options = getOptionsForSchema({
+      schema: this.parameters.schema,
+      locator: this.parameters.locator ?? [],
+      valueSpec: spec,
+      showIcons: !this.parameters.isSection,
+      skipNameComponentsPrefix: sdk.getNameComponentsForLocator(
+        this.parameters.schema,
+        locator
+      ),
+      ignorePrefix: !showFullPath,
+      nameComponentsByLocator: this.parameters.isSection ? sdk.getNameComponentsForLocator(this.parameters.schema, locator) : [],
+      exampleVariables: this.parameters.exampleVariables,
+      editableSchemaLocators: this.parameters.editableSchemaLocators
+    });
+    const filteredOptions = options.filter(
+      (o) => !input || (o.searchLabel ?? o.label?.toString())?.toLowerCase()?.includes(input.toLowerCase())
+    );
+    if (filteredOptions.length > 0) {
+      const result = filteredOptions;
+      if (this.parameters.isSection) {
+        result.unshift({
+          label: showFullPath ? sdk.getFullNameForLocator(this.parameters.schema, locator) : sdk.getNameForLocator(this.parameters.schema, locator),
+          isSection: true,
+          iconUri: sdk.getIconUriForLocator(this.parameters.schema, locator)
+        });
+      }
+      return result;
+    } else {
+      return [];
+    }
+  }
+}
+function getOptionsForSchema({
+  schema,
+  locator,
+  valueSpec: valueSpec$1,
+  showIcons = true,
+  skipNameComponentsPrefix = [],
+  ignorePrefix = false,
+  nameComponentsByLocator = null,
+  schemaByLocator = null,
+  exampleVariables = null,
+  expandObject = true,
+  editableSchemaLocators = []
+}) {
+  if (!sdk.isValidLocator(locator)) {
+    return [];
+  }
+  const locatorSteps = sdk.locatorToSteps(locator);
+  const options = [];
+  const optionsSchema = schemaByLocator ?? sdk.getSchemaByLocator(schema, locator);
+  if (!optionsSchema) {
+    return [];
+  }
+  let nameComponents = nameComponentsByLocator ?? sdk.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) => sdk.locatorToField(sdk.stepsToLocator(locatorSteps)).startsWith(sdk.locatorToField(l))
+  );
+  const label = getLabelNodeFromNameComponents(nameComponents);
+  const textLabel = nameComponents?.length > 0 ? nameComponents.join(" ") : optionsSchema.title;
+  const searchLabel = nameComponents.join(" ");
+  const iconUri = showIcons ? sdk.getIconUriForLocator(schema, locator) : null;
+  if (optionsSchema.type == "object") {
+    const isInvisibleObject = optionsSchema.title === "";
+    if (expandObject || isInvisibleObject) {
+      const hideWholeObject = !optionsSchema.title && locator?.length === 0;
+      if (valueSpec.doesSchemaMatchValueType(optionsSchema, valueSpec$1) && !hideWholeObject) {
+        options.push({
+          label: label ?? textLabel,
+          searchLabel,
+          hint: "Whole Object",
+          value: {
+            $var: sdk.stepsToLocator(sdk.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
+        });
+      }
+      for (const key of Object.keys(optionsSchema.properties ?? {})) {
+        const propertySchema = optionsSchema.properties[key];
+        if (!propertySchema) {
+          continue;
+        }
+        const propertyLocator = [
+          ...locatorSteps,
+          new sdk.DataLocatorStepObjectProperty(key)
+        ];
+        const newNameComponents = [...nameComponents];
+        const newNameComponent = propertySchema.title ?? jsConvertCase.toHeaderCase(key);
+        if (newNameComponent) {
+          newNameComponents.push(newNameComponent);
+        }
+        options.push(
+          ...getOptionsForSchema({
+            schema,
+            locator: propertyLocator,
+            valueSpec: valueSpec$1,
+            showIcons,
+            skipNameComponentsPrefix,
+            ignorePrefix,
+            nameComponentsByLocator: newNameComponents,
+            schemaByLocator: propertySchema,
+            exampleVariables,
+            expandObject: false,
+            editableSchemaLocators
+          })
+        );
+      }
+      if (isSchemaEditable) {
+        options.push({
+          label: `Add${textLabel ? ` "${textLabel}"` : ""} Property`,
+          searchLabel: "",
+          hint: `Add property to this object`,
+          iconType: index.SvgIconType.Add,
+          addVariable: `${sdk.stepsToLocator(locatorSteps)}`,
+          isHighlighted: true
+        });
+      }
+    } else {
+      if (valueSpec.doesSchemaMatchValueType(optionsSchema, valueSpec$1, true) || isSchemaEditable) {
+        const propCount = Object.keys(optionsSchema.properties ?? {}).length;
+        options.push({
+          label,
+          searchLabel,
+          hint: propCount === 0 ? "Object" : `Object with ${propCount} ${propCount === 1 ? "property" : "properties"}`,
+          /* 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,
+          drilldownOptionFactories: [
+            new objectFields.ObjectFieldsOptionFactory({
+              name: textLabel,
+              schema,
+              locator,
+              exampleVariables,
+              isSection: true,
+              editableSchemaLocators
+            })
+          ]
+        });
+      }
+    }
+  } else if (optionsSchema.type == "array") {
+    if (valueSpec.doesSchemaMatchValueType(optionsSchema, valueSpec$1, true) || valueSpec.doesSchemaMatchValueType(optionsSchema.items, valueSpec$1, true)) {
+      const listOptions = [];
+      if (valueSpec.doesSchemaMatchValueType(optionsSchema, valueSpec$1)) {
+        listOptions.push({
+          label,
+          searchLabel,
+          hint: "Whole List",
+          value: {
+            $var: sdk.stepsToLocator(sdk.locatorToSteps(locator))
+          },
+          iconUri: iconUri || void 0
+        });
+      }
+      if (optionsSchema.items && valueSpec.doesSchemaMatchValueType(optionsSchema.items, valueSpec$1, true)) {
+        const firstArrayItemLocator = [
+          ...locatorSteps,
+          new sdk.DataLocatorStepArrayItem(0)
+        ];
+        listOptions.push(
+          ...getOptionsForSchema({
+            schema,
+            locator: firstArrayItemLocator,
+            valueSpec: valueSpec$1,
+            showIcons,
+            skipNameComponentsPrefix,
+            ignorePrefix,
+            nameComponentsByLocator: ["Item #1"],
+            schemaByLocator: optionsSchema.items,
+            exampleVariables,
+            expandObject,
+            editableSchemaLocators
+          })
+        );
+      }
+      options.push({
+        label,
+        searchLabel,
+        hint: "List",
+        /* 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,
+        drilldownOptionFactories: [new constant.ConstantOptionFactory(listOptions)]
+      });
+    }
+  } else {
+    if (valueSpec.doesSchemaMatchValueType(optionsSchema, valueSpec$1)) {
+      options.push({
+        label,
+        searchLabel,
+        hint: sdk.getValueAtLocator(exampleVariables, locator) ?? index$1.getSchemaHint(optionsSchema),
+        value: {
+          $var: sdk.stepsToLocator(sdk.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
+      });
+    }
+  }
+  return options;
+}
+function getLabelNodeFromNameComponents(nameComponents) {
+  if (!nameComponents?.length) {
+    return null;
+  }
+  if (nameComponents.length === 1) {
+    return nameComponents[0];
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: nameComponents.map((name, idx) => /* @__PURE__ */ jsxRuntime.jsxs(React.Fragment, { children: [
+    idx ? /* @__PURE__ */ jsxRuntime.jsx(SegmentSeparator.SegmentSeparator, {}) : null,
+    name
+  ] }, idx)) });
+}
+
+exports.SchemaOptionFactory = SchemaOptionFactory;
+exports.getOptionsForSchema = getOptionsForSchema;

package/dist/cjs/components/ComboBox/types.cjs

@@ -0,0 +1,22 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+'use strict';
+
+var ComboBoxTabType = /* @__PURE__ */ ((ComboBoxTabType2) => {
+  ComboBoxTabType2["VARIABLE"] = "variable";
+  ComboBoxTabType2["OPTIONS"] = "options";
+  ComboBoxTabType2["FORMULA"] = "formula";
+  ComboBoxTabType2["CUSTOM"] = "custom";
+  ComboBoxTabType2["LOOKUP_OPTIONS"] = "lookup_options";
+  ComboBoxTabType2["SELECT_FROM_COLLECTION_DYNAMICALLY"] = "select_from_collection_dynamically";
+  ComboBoxTabType2["SELECT_FROM_UDM_DYNAMICALLY"] = "select_from_udm_dynamically";
+  return ComboBoxTabType2;
+})(ComboBoxTabType || {});
+
+exports.ComboBoxTabType = ComboBoxTabType;