@integry/sdk 4.5.2 → 4.5.4

package/src/utils/ActivityOutputUtils.ts

@@ -0,0 +1,163 @@
+import { StoreType } from '@/types/store';
+
+function makeHumanReadable(str: string) {
+  // Step 1: Add space before capital letters not preceded by a dot
+  const formattedStr = str.replace(/(?<!\.)[A-Z]/g, (match) => `${match}`);
+
+  // Step 2: Capitalize the first letter after a dot or the first character
+  const capitalizedStr = formattedStr.replace(/(?:^|\.)\s*\w/g, (match) =>
+    match.toUpperCase(),
+  );
+
+  // Step 3: Return the updated string
+  return capitalizedStr;
+}
+export function JSONToActivityOutputData(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  obj: any,
+  parentKey = '',
+  sourceStepKey = '',
+): StoreType['activityOutputData'] {
+  const options: StoreType['activityOutputData'] = [];
+  Object.keys(obj).forEach((key) => {
+    if (key in obj) {
+      const value = obj[key];
+      const currentKey = parentKey ? `${parentKey}.${key}` : key;
+      if (value && typeof value === 'object') {
+        const nestedOptions = JSONToActivityOutputData(
+          value,
+          currentKey,
+          sourceStepKey,
+        );
+        if (nestedOptions) {
+          options.push({
+            value: sourceStepKey
+              ? `${sourceStepKey}${currentKey}`
+              : `${currentKey}`,
+            text: makeHumanReadable(currentKey),
+          });
+          options.push(...nestedOptions);
+        }
+      } else {
+        options.push({
+          value: sourceStepKey
+            ? `${sourceStepKey}${currentKey}`
+            : `${currentKey}`,
+          text: makeHumanReadable(currentKey),
+        });
+      }
+    }
+  });
+
+  return options;
+}
+
+export function JSONToDynamicFieldData(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  obj: any,
+  parentKey = '',
+  sourceStepKey = '',
+): StoreType['dynamicFieldData'] {
+  let result: StoreType['dynamicFieldData'] = {};
+  Object.keys(obj).forEach((key) => {
+    if (key in obj) {
+      let currentKey = sourceStepKey ? `${sourceStepKey}` : '';
+      currentKey += parentKey ? `${parentKey}.${key}` : key;
+      if (
+        obj[key] &&
+        typeof obj[key] === 'object' &&
+        !Array.isArray(obj[key])
+      ) {
+        const flattened = JSONToDynamicFieldData(obj[key], currentKey);
+        if (result) {
+          try {
+            result[currentKey] = [JSON.stringify(obj[key])];
+          } catch (e) {
+            result[currentKey] = [''];
+          }
+        }
+        result = { ...result, ...flattened };
+      } else if (result) {
+        result[currentKey] = [obj[key]];
+      }
+    }
+  });
+  return result;
+}
+
+export function removeCurlyBraces(value: string): string {
+  value.replace(/^{(.*)}$/, '$1');
+  return value;
+}
+
+export function isNotJSON(obj: any): boolean {
+  try {
+    if (Array.isArray(obj) && obj.length > 0 && typeof obj[0] === 'object') {
+      return false;
+    }
+    JSON.parse(obj);
+    if (Number(obj)) {
+      return true;
+    }
+    return false;
+  } catch (e) {
+    return true;
+  }
+}
+
+export function arrayToNestedJSONWithFirstValue(
+  array: any,
+  valueObj: any,
+): any {
+  let tempValueObj: any = {};
+  let arrayUpdated = [];
+  if (array && Array.isArray(array)) {
+    arrayUpdated = array;
+  }
+  Object.keys(valueObj || {}).forEach((i) => {
+    const key = removeCurlyBraces(i);
+    tempValueObj = {
+      ...tempValueObj,
+      [key]: valueObj[i] || '',
+    };
+  });
+  let flatForm = {};
+  (arrayUpdated || []).forEach((arr: any) => {
+    flatForm = {
+      ...flatForm,
+      [arr.text]: valueObj[arr.value] || '',
+    };
+  });
+
+  const result = {};
+  (arrayUpdated || []).forEach((item: any) => {
+    if (!item.text || !item.value) {
+      return;
+    }
+    const keys = item.text.split('.');
+    let currentLevel: any = result;
+    keys.forEach((key: any, index: any) => {
+      if (!currentLevel[key]) {
+        if (index === keys.length - 1) {
+          if (tempValueObj[item.value]) {
+            if (
+              tempValueObj[item.value][0] &&
+              isNotJSON(tempValueObj[item.value][0])
+            ) {
+              // eslint-disable-next-line prefer-destructuring
+              currentLevel[key] = tempValueObj[item.value][0] || '';
+            } else {
+              currentLevel[key] = '';
+            }
+          } else {
+            currentLevel[key] = '';
+          }
+        } else {
+          currentLevel[key] = {};
+        }
+      }
+      currentLevel = currentLevel[key];
+    });
+  });
+  return result;
+}

package/src/utils/common.ts

@@ -0,0 +1,20 @@
+export const isScrolledIntoView = (
+  el: HTMLElement,
+  scrollableDivId: string,
+): boolean => {
+  const rect = el.getBoundingClientRect();
+  //   const elemTop = rect.top;
+  const elemBottom = rect.bottom;
+
+  const scrollableContainer = document.getElementById(scrollableDivId);
+
+  const containerRect = scrollableContainer?.getBoundingClientRect();
+  const docViewTop = containerRect?.top;
+  const docViewBottom = containerRect?.bottom;
+
+  if (docViewTop && docViewBottom) {
+    return elemBottom <= docViewBottom && elemBottom >= docViewTop;
+  }
+
+  return true;
+};

package/src/utils/copyToClipboard.ts

@@ -0,0 +1,24 @@
+export const copyStringToClipboard = (str: string) => {
+  if (!navigator.clipboard) {
+    // Create new element
+    const el = document.createElement('textarea');
+    // Set value (string to be copied)
+    el.value = str;
+    // Set non-editable to avoid focus and move outside of view
+    el.setAttribute('readonly', '');
+
+    el.style.position = 'absolute';
+    el.style.left = '-9999px';
+    document.body.appendChild(el);
+    // Select text inside element
+    el.select();
+    // Copy text to clipboard
+    document.execCommand('copy');
+    // Remove temporary element
+    document.body.removeChild(el);
+  } else {
+    navigator.clipboard.writeText(str).catch(() => {
+      console.error('Could not copy to clipboard'); // error
+    });
+  }
+};

package/src/utils/datetime.ts

@@ -0,0 +1,101 @@
+/* eslint-disable no-console */
+/**
+ *
+ * @param length Array length to generate
+ * @returns String array like ['00', '01', '02' ...]
+ */
+function generateDoubleDigitStringArr(length: number): string[] {
+  return Array.from({ length }, (_, i) => {
+    if (i < 10) return `0${i}`;
+    return `${i + 1}`;
+  });
+}
+
+/**
+ *
+ * @param date Input date
+ * @returns {string} Date string formatted as YYYY-MM-DD
+ */
+function getDateFormat(date: Date): string {
+  return new Date(date.getTime() - date.getTimezoneOffset() * 60000)
+    .toISOString()
+    .split('T')[0];
+}
+
+const timeAgo = (date: Date) => {
+  const intervals = [
+    { label: 'year', seconds: 31536000 },
+    { label: 'month', seconds: 2592000 },
+    { label: 'day', seconds: 86400 },
+    { label: 'hour', seconds: 3600 },
+    { label: 'minute', seconds: 60 },
+    { label: 'A few second', seconds: 0 },
+  ];
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+  let interval = intervals.find((i) => i.seconds <= seconds);
+  if (seconds && interval === undefined) {
+    interval = intervals.find((i) => i.seconds === 0)
+  }
+  if (interval !== undefined) { // interval can be 0 seconds, need to explicitly check undefined
+    let count = Math.floor(seconds / interval.seconds);
+    if (!Number.isInteger(count)) count = 0;
+    return `${count > 0 ? count : ''} ${interval.label}${
+      count !== 1 ? 's' : ''
+    } ago`;
+  }
+  return `Cannot be formatted with interval ${interval}`;
+};
+
+const convertDateToStandard = (datetime: string) => {
+  const dateString = datetime;
+  try {
+    const dateObj = new Date(datetime);
+    return dateObj.toLocaleString('en-US', {
+      month: 'short',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit'
+    });
+  } catch (err) {
+    console.error(err);
+  }
+  return dateString;
+};
+
+const calculateDatetimeDifference = (datetimeString1: string | undefined, datetimeString2: string): {
+  days: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+} => {
+  // Parse the datetime strings into Date objects
+  const date1 = new Date(datetimeString1 || new Date().toISOString());
+  const date2 = new Date(datetimeString2);
+
+  // Calculate the time difference in milliseconds
+  const timeDifference = Math.abs(date1.getTime() - date2.getTime());
+
+  // Convert the time difference to a more human-readable format
+  const millisecondsPerSecond = 1000;
+  const millisecondsPerMinute = 60 * millisecondsPerSecond;
+  const millisecondsPerHour = 60 * millisecondsPerMinute;
+  const millisecondsPerDay = 24 * millisecondsPerHour;
+
+  const days = Math.floor(timeDifference / millisecondsPerDay);
+  const hours = Math.floor((timeDifference % millisecondsPerDay) / millisecondsPerHour);
+  const minutes = Math.floor((timeDifference % millisecondsPerHour) / millisecondsPerMinute);
+  const seconds = Math.floor((timeDifference % millisecondsPerMinute) / millisecondsPerSecond);
+
+  return {
+    days,
+    hours,
+    minutes,
+    seconds,
+    milliseconds: timeDifference % millisecondsPerSecond,
+  };
+};
+
+
+
+export { generateDoubleDigitStringArr, getDateFormat, timeAgo, convertDateToStandard, calculateDatetimeDifference };

package/src/utils/getUrlParam.ts

@@ -0,0 +1,11 @@
+import isBrowser from './isBrowser';
+
+/**
+ *
+ * @param args
+ */
+export const getUrlParam = (param: string) => {
+  if (!isBrowser) return null;
+  const params = new URLSearchParams(window.location.search);
+  return params.get(param);
+};

package/src/utils/isAuthMessage.ts

@@ -0,0 +1,16 @@
+interface AuthData {
+  activity_name: string;
+  already_exists: boolean;
+  authorization_id: number;
+  user_identity: string;
+  external_id?: string;
+  app_id: number;
+}
+
+function isAuthMessage(
+  msg: MessageEvent<AuthData>,
+): msg is MessageEvent<AuthData> {
+  return (msg as MessageEvent<AuthData>) !== undefined;
+}
+
+export { isAuthMessage, AuthData };

package/src/utils/isBrowser.ts

@@ -0,0 +1 @@
+export default () => ![typeof window, typeof document].includes('undefined');

package/src/utils/jsonEncodeDecode.ts

@@ -0,0 +1,15 @@
+export const decodeJSON = (jsonString: string) => {
+  try {
+    return JSON.parse(jsonString);
+  } catch (e) {
+    return null;
+  }
+};
+
+export const encodeJSON = (json: never): string => {
+  try {
+    return JSON.stringify(json);
+  } catch (e) {
+    return '';
+  }
+};

package/src/utils/objectUtils.ts

@@ -0,0 +1,116 @@
+const get = (obj: any, path: string, defaultValue = undefined) => {
+  const travel = (regexp: any) =>
+    String.prototype.split
+      .call(path, regexp)
+      .filter(Boolean)
+      .reduce(
+        (res, key) => (res !== null && res !== undefined ? res[key] : res),
+        obj,
+      );
+  const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/);
+  return result === undefined || result === obj ? defaultValue : result;
+};
+
+export const extractTags = (input: string): string[] => {
+  const regex = /\{([^}]+)\}/g;
+  const matches = input.match(regex);
+
+  if (matches) {
+    return matches.map((match) => match.slice(1, -1));
+  }
+  return [];
+};
+
+export const extractTagsFromStepDataMapping = (
+  stepDataMapping: any,
+): string[] => {
+  const tags: string[] = [];
+  Object.keys(stepDataMapping).forEach((stepId) => {
+    let skipStep = false;
+    Object.keys(stepDataMapping[stepId]).forEach((fieldId) => {
+      const field = stepDataMapping[stepId][fieldId];
+      if (field.machineName === 'integry_webhook_object') {
+        skipStep = true;
+      }
+    });
+    if (!skipStep) {
+      Object.keys(stepDataMapping[stepId]).forEach((fieldId) => {
+        const field = stepDataMapping[stepId][fieldId];
+        if (
+          typeof field.value === 'string' &&
+          field.value.includes('{') &&
+          field.value.includes('}')
+        ) {
+          tags.push(...extractTags(field.value));
+        } else if (
+          (field.value === null || field.value === '') &&
+          field.objectValue !== null
+        ) {
+          Object.keys(field.objectValue).forEach((objectKey) => {
+            const objectFieldVal = field.objectValue[objectKey];
+            if (
+              objectFieldVal &&
+              objectFieldVal.includes('{') &&
+              objectFieldVal.includes('}')
+            ) {
+              tags.push(...extractTags(objectFieldVal));
+            }
+          });
+        }
+      });
+    }
+  });
+  return tags;
+};
+
+export const createMappedObject = (object: any, tags: string[]) => {
+  const result = {} as any;
+
+  tags.forEach((tag) => {
+    let currentObj = result;
+    const keyArray = tag.split('.');
+    const value = get(object, tag);
+    for (let i = 0; i < keyArray.length; i += 1) {
+      const key = keyArray[i];
+      if (i === keyArray.length - 1) {
+        // If it's the last key, assign the value
+        currentObj[key] = value;
+      } else if (currentObj[key]) {
+        currentObj = currentObj[key];
+      } else {
+        // Create an empty object or array if the next key is a number
+        currentObj[key] = Number.isNaN(Number(keyArray[i + 1])) ? {} : [];
+        currentObj = currentObj[key];
+      }
+    }
+  });
+
+  return result;
+};
+
+export const getIntegryObject = (triggerStep: any, userConfig: any): any => {
+  let objectPayload = {};
+  let objectName = '';
+  let integryObject = triggerStep?.template_fields.find(
+    (el: any) => el.activity_field?.machine_name === 'integry_webhook_object',
+  )?.default_value;
+
+  if (integryObject) {
+    try {
+      integryObject = integryObject.replaceAll('\\n', '');
+      const parsedIntegryObject = JSON.parse(integryObject);
+      objectName = parsedIntegryObject.name;
+
+      if (userConfig?.objects?.[parsedIntegryObject.name]) {
+        objectPayload = userConfig?.objects?.[parsedIntegryObject.name];
+      } else {
+        objectPayload = JSON.parse(parsedIntegryObject.payload);
+      }
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log('error parsing object.');
+    }
+  }
+
+  return { name: objectName, payload: objectPayload };
+};

package/src/utils/popup.ts

@@ -0,0 +1,30 @@
+/**
+ *
+ * @param url Url to open in this popup window
+ * @param windowName Given name
+ * @param win Original window reference
+ * @param w Width in px
+ * @param h Height in px
+ * @returns Reference to the newly created popup window
+ */
+function openPopupWindow(
+  url: string,
+  windowName: string,
+  win: Window,
+  w: number,
+  h: number,
+): Window | null {
+  if (win.top) {
+    const y = win.top.outerHeight / 2 + win.top.screenY - h / 2;
+    const x = win.top.outerWidth / 2 + win.top.screenX - w / 2;
+    (window as any).top.MyAltWindow = win.open(
+      url,
+      windowName,
+      `toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width=${w}, height=${h}, top=${y}, left=${x}`,
+    );
+     return (window as any).top.MyAltWindow
+  }
+  return null;
+}
+
+export { openPopupWindow };

package/src/utils/searchJson.ts

@@ -0,0 +1,51 @@
+const  removeTextBetweenBraces = (str: string) => {
+  const braceIndex = str.indexOf('{');
+  if (braceIndex !== -1) {
+    return str.slice(braceIndex).replace(/\{[^}]*\}\s*/g, '');
+  }
+  return str.replace(/\{[^}]*\}\s*/g, '')
+}
+
+const removeBraces = (str: string) => {
+  let tempStr = str;
+  // Remove starting "{"
+  tempStr = tempStr.replace(/^{\s*/, '');
+
+  // Remove ending "}"
+  tempStr = tempStr.replace(/\s*}$/, '');
+
+  return tempStr;
+}
+
+export const searchJSON = (obj: any, searchTerm: any): any => {
+  let tempSearchTerm = searchTerm;
+  if (tempSearchTerm === '') {
+    return obj;
+  }
+  if (tempSearchTerm.includes('{') || tempSearchTerm.includes('}')) {
+    tempSearchTerm = removeBraces(tempSearchTerm);
+  }
+  let tempObj = {};
+  try {
+    Object.keys(obj).forEach((key) => {
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        const tempNestedObj = searchJSON(obj[key], tempSearchTerm);
+        if (Object.keys(tempNestedObj).length > 0) {
+          tempObj = {
+            ...tempObj,
+            [key]: tempNestedObj,
+          }
+        }
+      } else if (typeof obj[key] !== 'object' && key.toLowerCase().includes(tempSearchTerm.toLowerCase())) {
+          tempObj = {
+            ...tempObj,
+            [key]: obj[key],
+          }
+      }
+    });
+  } catch (error) {
+    console.error(error);
+    return obj;
+  }
+  return tempObj;
+};

package/src/utils/stepUtils.ts

@@ -0,0 +1,45 @@
+/* eslint-disable import/no-cycle */
+import { StoreType } from '@/types/store';
+import { TemplateField } from '@/interfaces';
+import { TagProps } from '@/components/Tag';
+
+export const areParentValuesValid = (
+  stepId: number,
+  fieldConditions: {
+    value: string;
+    parentMachineName: string;
+    parentFieldId: number;
+  }[],
+  stepDataMapping: StoreType['stepDataMapping'],
+) => {
+  let valid = false;
+  // check if all parent fields have values required to show the field
+  for (let index = 0; index < fieldConditions.length; index += 1) {
+    const { parentFieldId, value } = fieldConditions[index];
+    const parentField =
+      stepDataMapping[stepId] && stepDataMapping[stepId][parentFieldId];
+    if (parentField && parentField.value === value) {
+      valid = true;
+      break;
+    }
+  }
+  return valid;
+};
+
+export const getFieldLabelTags = (
+  field: TemplateField,
+  isConfigMode = false,
+) => {
+  const { is_hidden, is_default_value_auto_mapped } = field;
+  const tags: TagProps[] = [];
+  if (!isConfigMode) {
+    return [];
+  }
+  if (is_hidden) {
+    tags.push({ label: 'Hidden', type: 'grey' });
+  }
+  if (is_default_value_auto_mapped) {
+    tags.push({ label: 'AI mapped', type: 'grey' });
+  }
+  return tags;
+};

package/src/utils/truncate.ts

@@ -0,0 +1,6 @@
+export const truncate = (input: string, length?: number) =>
+  input.length > (length || 18)
+    ? `${input.substring(0, length || 18)}...`
+    : input;
+export const isTruncatable = (input: string, length?: number) =>
+  input.length > (length || 18);

package/test/setup.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    reporters: 'default',
+    // setupFiles: './test/setup.ts', // Optional: Use if you need global setup
+  },
+});