@pitcher/js-api 1.26.0-beta.9 → 1.26.0

package/js-api.esm.js

@@ -33,7 +33,7 @@ var hasRequiredPostRobot$1;
 function requirePostRobot$1 () {
 	if (hasRequiredPostRobot$1) return postRobot$1.exports;
 	hasRequiredPostRobot$1 = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		!function(root, factory) {
 		    module.exports = factory() ;
 		}("undefined" != typeof self ? self : postRobot, (function() {
@@ -52,17 +52,17 @@ function requirePostRobot$1 () {
 		        }
 		        __webpack_require__.m = modules;
 		        __webpack_require__.c = installedModules;
-		        __webpack_require__.d = function(exports, name, getter) {
-		            __webpack_require__.o(exports, name) || Object.defineProperty(exports, name, {
+		        __webpack_require__.d = function(exports$1, name, getter) {
+		            __webpack_require__.o(exports$1, name) || Object.defineProperty(exports$1, name, {
 		                enumerable: true,
 		                get: getter
 		            });
 		        };
-		        __webpack_require__.r = function(exports) {
-		            "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
+		        __webpack_require__.r = function(exports$1) {
+		            "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports$1, Symbol.toStringTag, {
 		                value: "Module"
 		            });
-		            Object.defineProperty(exports, "__esModule", {
+		            Object.defineProperty(exports$1, "__esModule", {
 		                value: true
 		            });
 		        };
@@ -2401,19 +2401,6 @@ function getLanguages() {
   return this.API.request("get_languages");
 }
 
-function getEvents(payload) {
-  return highLevelApi.API.request("get_events", payload);
-}
-function createEvent(payload) {
-  return highLevelApi.API.request("create_event", payload);
-}
-function updateEvent(payload) {
-  return highLevelApi.API.request("update_event", payload);
-}
-function deleteEvent(payload) {
-  return highLevelApi.API.request("delete_event", payload);
-}
-
 function getCanvases$1(payload) {
   return this.API.request("get_canvases", payload);
 }
@@ -2531,18 +2518,609 @@ function toast$2(payload) {
   return this.API.request("toast", payload);
 }
 
+const SQL_KEYWORDS = /* @__PURE__ */ new Set([
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "LIKE",
+  "ORDER",
+  "BY",
+  "GROUP",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "ASC",
+  "DESC",
+  "NULLS",
+  "FIRST",
+  "LAST",
+  "NULL",
+  "TRUE",
+  "FALSE",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "COUNT_DISTINCT",
+  "CALENDAR_MONTH",
+  "CALENDAR_QUARTER",
+  "CALENDAR_YEAR",
+  "DAY_IN_MONTH",
+  "DAY_IN_WEEK",
+  "DAY_IN_YEAR",
+  "DAY_ONLY",
+  "FISCAL_MONTH",
+  "FISCAL_QUARTER",
+  "FISCAL_YEAR",
+  "HOUR_IN_DAY",
+  "WEEK_IN_MONTH",
+  "WEEK_IN_YEAR",
+  "INCLUDES",
+  "EXCLUDES",
+  "ABOVE",
+  "BELOW",
+  "ABOVE_OR_BELOW",
+  "AT",
+  "TYPEOF",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "USING",
+  "SCOPE",
+  "DATA",
+  "CATEGORY",
+  "ROLLUP",
+  "CUBE",
+  "FORMAT",
+  "CONVERTCURRENCY",
+  "TOLABEL",
+  "DISTANCE",
+  "GEOLOCATION"
+]);
+const AGGREGATE_FUNCTIONS = ["COUNT", "SUM", "AVG", "MIN", "MAX", "COUNT_DISTINCT"];
+function isSqlKeyword(word) {
+  return SQL_KEYWORDS.has(word.toUpperCase());
+}
+function isLiteralValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return true;
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return true;
+  }
+  if (/^(true|false)$/i.test(trimmed)) {
+    return true;
+  }
+  if (/^null$/i.test(trimmed)) {
+    return true;
+  }
+  if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/.test(trimmed)) {
+    return true;
+  }
+  if (/^(TODAY|YESTERDAY|TOMORROW|LAST_WEEK|THIS_WEEK|NEXT_WEEK|LAST_MONTH|THIS_MONTH|NEXT_MONTH|LAST_90_DAYS|NEXT_90_DAYS|LAST_N_DAYS:\d+|NEXT_N_DAYS:\d+|LAST_N_WEEKS:\d+|NEXT_N_WEEKS:\d+|LAST_N_MONTHS:\d+|NEXT_N_MONTHS:\d+|LAST_N_QUARTERS:\d+|NEXT_N_QUARTERS:\d+|LAST_N_YEARS:\d+|NEXT_N_YEARS:\d+|THIS_QUARTER|LAST_QUARTER|NEXT_QUARTER|THIS_YEAR|LAST_YEAR|NEXT_YEAR|THIS_FISCAL_QUARTER|LAST_FISCAL_QUARTER|NEXT_FISCAL_QUARTER|THIS_FISCAL_YEAR|LAST_FISCAL_YEAR|NEXT_FISCAL_YEAR)$/i.test(
+    trimmed
+  )) {
+    return true;
+  }
+  return false;
+}
+function isDateTimeLiteral(token) {
+  return /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/.test(token);
+}
+function convertFieldToSmartStore(field, primaryObject, objectAliases) {
+  const trimmed = field.trim();
+  if (isSqlKeyword(trimmed) || isLiteralValue(trimmed)) {
+    return trimmed;
+  }
+  if (trimmed === "__FIELDS_ALL_PLACEHOLDER__") {
+    return `{${primaryObject}:_soup}`;
+  }
+  if (trimmed === "*") {
+    return "*";
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    return trimmed;
+  }
+  if (trimmed.includes(".")) {
+    const parts = trimmed.split(".");
+    const alias = parts[0];
+    if (objectAliases.has(alias.toLowerCase()) && objectAliases.get(alias.toLowerCase()) === primaryObject) {
+      const fieldPath = parts.slice(1).join(".");
+      return `{${primaryObject}:${fieldPath}}`;
+    }
+    return `{${primaryObject}:${trimmed}}`;
+  }
+  return `{${primaryObject}:${trimmed}}`;
+}
+function convertAggregateFunction(expr, primaryObject, objectAliases) {
+  for (const func of AGGREGATE_FUNCTIONS) {
+    const regex = new RegExp(`\\b${func}\\s*\\(([^)]+)\\)`, "gi");
+    expr = expr.replace(regex, (_match, innerField) => {
+      const trimmedInner = innerField.trim();
+      if (trimmedInner === "*") {
+        return `${func}(*)`;
+      }
+      if (trimmedInner.toUpperCase().startsWith("DISTINCT ")) {
+        const fieldPart = trimmedInner.substring(9).trim();
+        const smartField2 = convertFieldToSmartStore(fieldPart, primaryObject, objectAliases);
+        return `${func}(DISTINCT ${smartField2})`;
+      }
+      const smartField = convertFieldToSmartStore(trimmedInner, primaryObject, objectAliases);
+      return `${func}(${smartField})`;
+    });
+  }
+  return expr;
+}
+function parseSelectFields(selectClause) {
+  const fields = [];
+  let depth = 0;
+  let currentField = "";
+  for (let i = 0; i < selectClause.length; i++) {
+    const char = selectClause[i];
+    if (char === "(") {
+      depth++;
+      currentField += char;
+    } else if (char === ")") {
+      depth--;
+      currentField += char;
+    } else if (char === "," && depth === 0) {
+      if (currentField.trim()) {
+        fields.push(currentField.trim());
+      }
+      currentField = "";
+    } else {
+      currentField += char;
+    }
+  }
+  if (currentField.trim()) {
+    fields.push(currentField.trim());
+  }
+  return fields;
+}
+function convertSelectFields(fields, primaryObject, objectAliases) {
+  return fields.map((field) => {
+    const aliasMatch = field.match(/^(.+?)\s+(?:AS\s+)?([A-Za-z_][A-Za-z0-9_]*)$/i);
+    let expression = field;
+    let alias = "";
+    if (aliasMatch) {
+      expression = aliasMatch[1].trim();
+      alias = aliasMatch[2];
+    }
+    const hasAggregate = AGGREGATE_FUNCTIONS.some((func) => new RegExp(`\\b${func}\\s*\\(`, "i").test(expression));
+    if (hasAggregate) {
+      const converted2 = convertAggregateFunction(expression, primaryObject, objectAliases);
+      return alias ? `${converted2} ${alias}` : converted2;
+    }
+    const converted = convertFieldToSmartStore(expression, primaryObject, objectAliases);
+    return alias ? `${converted} ${alias}` : converted;
+  });
+}
+function convertNullComparisons(clause) {
+  let result = clause.replace(/\s*!=\s*null\b/gi, " IS NOT NULL");
+  result = result.replace(/\s*<>\s*null\b/gi, " IS NOT NULL");
+  result = result.replace(/\s*=\s*null\b/gi, " IS NULL");
+  return result;
+}
+function convertWhereClause(whereClause, primaryObject, objectAliases) {
+  let result = "";
+  let i = 0;
+  const len = whereClause.length;
+  while (i < len) {
+    const char = whereClause[i];
+    if (/\s/.test(char)) {
+      result += char;
+      i++;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      const quote = char;
+      result += char;
+      i++;
+      while (i < len && whereClause[i] !== quote) {
+        if (whereClause[i] === "\\" && i + 1 < len) {
+          result += whereClause[i] + whereClause[i + 1];
+          i += 2;
+        } else {
+          result += whereClause[i];
+          i++;
+        }
+      }
+      if (i < len) {
+        result += whereClause[i];
+        i++;
+      }
+      continue;
+    }
+    if (/[()=<>!,]/.test(char)) {
+      result += char;
+      i++;
+      if ((char === "!" || char === "<" || char === ">") && i < len && whereClause[i] === "=") {
+        result += whereClause[i];
+        i++;
+      }
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(char)) {
+      let identifier = "";
+      while (i < len && /[a-zA-Z0-9_.]/.test(whereClause[i])) {
+        identifier += whereClause[i];
+        i++;
+      }
+      if (isSqlKeyword(identifier) || isLiteralValue(identifier)) {
+        result += identifier;
+      } else {
+        result += convertFieldToSmartStore(identifier, primaryObject, objectAliases);
+      }
+      continue;
+    }
+    if (/[0-9-]/.test(char)) {
+      let token = "";
+      if (char === "-") {
+        token += char;
+        i++;
+      }
+      while (i < len && /[0-9.:\-TZ+]/.test(whereClause[i])) {
+        token += whereClause[i];
+        i++;
+      }
+      if (isDateTimeLiteral(token)) {
+        result += `'${token}'`;
+      } else {
+        result += token;
+      }
+      continue;
+    }
+    result += char;
+    i++;
+  }
+  result = convertNullComparisons(result);
+  return result;
+}
+function parseOrderByClause(orderByClause) {
+  const result = [];
+  const parts = orderByClause.split(/,(?![^()]*\))/);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^(.+?)\s*(ASC|DESC)?\s*(NULLS\s+(?:FIRST|LAST))?$/i);
+    if (match) {
+      const field = match[1].trim();
+      let direction = match[2] ? match[2].toUpperCase() : "";
+      if (match[3]) {
+        direction += (direction ? " " : "") + match[3].toUpperCase();
+      }
+      result.push({ field, direction });
+    } else {
+      result.push({ field: trimmed, direction: "" });
+    }
+  }
+  return result;
+}
+function convertOrderByFields(orderByParts, primaryObject, objectAliases) {
+  return orderByParts.map(({ field, direction }) => {
+    const hasAggregate = AGGREGATE_FUNCTIONS.some((func) => new RegExp(`\\b${func}\\s*\\(`, "i").test(field));
+    let convertedField;
+    if (hasAggregate) {
+      convertedField = convertAggregateFunction(field, primaryObject, objectAliases);
+    } else {
+      convertedField = convertFieldToSmartStore(field, primaryObject, objectAliases);
+    }
+    return direction ? `${convertedField} ${direction}` : convertedField;
+  });
+}
+function parseGroupByClause(groupByClause) {
+  return groupByClause.split(/,(?![^()]*\))/).map((f) => f.trim()).filter(Boolean);
+}
+function convertGroupByFields(fields, primaryObject, objectAliases) {
+  return fields.map((field) => {
+    if (/^(ROLLUP|CUBE)\s*\(/i.test(field)) {
+      return field.replace(/\(([^)]+)\)/g, (_match, inner) => {
+        const innerFields = inner.split(",").map((f) => f.trim());
+        const converted = innerFields.map((f) => convertFieldToSmartStore(f, primaryObject, objectAliases));
+        return `(${converted.join(", ")})`;
+      });
+    }
+    return convertFieldToSmartStore(field, primaryObject, objectAliases);
+  });
+}
+function parseFromClause(fromClause) {
+  const joins = [];
+  const primaryMatch = fromClause.match(/^([A-Za-z0-9_]+)(?:\s+(?:AS\s+)?([A-Za-z_][A-Za-z0-9_]*))?/i);
+  if (!primaryMatch) {
+    return { primary: "", joins };
+  }
+  const primary = primaryMatch[1];
+  const alias = primaryMatch[2];
+  const joinRegex = /(LEFT\s+OUTER\s+JOIN|LEFT\s+JOIN|INNER\s+JOIN|JOIN)\s+([A-Za-z0-9_]+)(?:\s+(?:AS\s+)?([A-Za-z_][A-Za-z0-9_]*))?\s+ON\s+([^,]+?)(?=(?:LEFT|INNER|JOIN|$))/gi;
+  let joinMatch;
+  while ((joinMatch = joinRegex.exec(fromClause)) !== null) {
+    joins.push({
+      type: joinMatch[1].toUpperCase().replace(/\s+/g, " "),
+      object: joinMatch[2],
+      alias: joinMatch[3],
+      on: joinMatch[4]?.trim()
+    });
+  }
+  return { primary, alias, joins };
+}
+function removeSubqueries(query) {
+  const subqueries = [];
+  let cleanQuery = "";
+  let depth = 0;
+  let currentSubquery = "";
+  let inSubquery = false;
+  for (let i = 0; i < query.length; i++) {
+    const char = query[i];
+    if (char === "(") {
+      depth++;
+      if (depth === 1) {
+        const remaining = query.substring(i + 1).trimStart();
+        if (/^SELECT\s/i.test(remaining)) {
+          inSubquery = true;
+          currentSubquery = char;
+          continue;
+        }
+      }
+      if (inSubquery) {
+        currentSubquery += char;
+      } else {
+        cleanQuery += char;
+      }
+    } else if (char === ")") {
+      if (inSubquery) {
+        currentSubquery += char;
+        depth--;
+        if (depth === 0) {
+          subqueries.push(currentSubquery);
+          currentSubquery = "";
+          inSubquery = false;
+        }
+      } else {
+        depth--;
+        cleanQuery += char;
+      }
+    } else {
+      if (inSubquery) {
+        currentSubquery += char;
+      } else {
+        cleanQuery += char;
+      }
+    }
+  }
+  return { cleanQuery, subqueries };
+}
+function findMainFromClause(query) {
+  const { cleanQuery } = removeSubqueries(query);
+  const fromMatch = cleanQuery.match(
+    /FROM\s+([A-Za-z0-9_]+)(?:\s+(?:AS\s+)?[A-Za-z_][A-Za-z0-9_]*)?(?=\s+WHERE\s+|\s+ORDER\s+BY\s+|\s+GROUP\s+BY\s+|\s+HAVING\s+|\s+LIMIT\s+|\s+OFFSET\s+|\s*$)/i
+  );
+  const primaryObject = fromMatch ? fromMatch[1] : null;
+  return { primaryObject, cleanQuery };
+}
+function convertSoqlToSmartQuery(soqlQuery) {
+  if (!soqlQuery || typeof soqlQuery !== "string") {
+    return "";
+  }
+  let normalizedQuery = soqlQuery.replace(/\s+/g, " ").trim();
+  const { primaryObject, cleanQuery } = findMainFromClause(normalizedQuery);
+  if (!primaryObject) {
+    return soqlQuery;
+  }
+  normalizedQuery = cleanQuery;
+  normalizedQuery = normalizedQuery.replace(
+    /\bFIELDS\s*\(\s*(ALL|STANDARD|CUSTOM)\s*\)/gi,
+    "__FIELDS_ALL_PLACEHOLDER__"
+  );
+  const selectMatch = normalizedQuery.match(/SELECT\s+([\s\S]+?)\s+FROM\s+/i);
+  if (!selectMatch) {
+    return soqlQuery;
+  }
+  const fromMatch = normalizedQuery.match(
+    /FROM\s+([\s\S]+?)(?=\s+WHERE\s+|\s+ORDER\s+BY\s+|\s+GROUP\s+BY\s+|\s+HAVING\s+|\s+LIMIT\s+|\s+OFFSET\s+|\s*$)/i
+  );
+  const fromParsed = fromMatch ? parseFromClause(fromMatch[1].trim()) : { };
+  const whereMatch = normalizedQuery.match(
+    /WHERE\s+([\s\S]+?)(?=\s+ORDER\s+BY\s+|\s+GROUP\s+BY\s+|\s+HAVING\s+|\s+LIMIT\s+|\s+OFFSET\s+|\s*$)/i
+  );
+  const groupByMatch = normalizedQuery.match(
+    /GROUP\s+BY\s+([\s\S]+?)(?=\s+HAVING\s+|\s+ORDER\s+BY\s+|\s+LIMIT\s+|\s+OFFSET\s+|\s*$)/i
+  );
+  const havingMatch = normalizedQuery.match(/HAVING\s+([\s\S]+?)(?=\s+ORDER\s+BY\s+|\s+LIMIT\s+|\s+OFFSET\s+|\s*$)/i);
+  const orderByMatch = normalizedQuery.match(/ORDER\s+BY\s+([\s\S]+?)(?=\s+LIMIT\s+|\s+OFFSET\s+|\s*$)/i);
+  const limitMatch = normalizedQuery.match(/LIMIT\s+(\d+)/i);
+  const offsetMatch = normalizedQuery.match(/OFFSET\s+(\d+)/i);
+  const objectAliases = /* @__PURE__ */ new Map();
+  if (fromParsed.alias) {
+    objectAliases.set(fromParsed.alias.toLowerCase(), primaryObject);
+  }
+  objectAliases.set(primaryObject.toLowerCase(), primaryObject);
+  const parts = [];
+  const selectFields = parseSelectFields(selectMatch[1].trim());
+  const smartSelectFields = convertSelectFields(selectFields, primaryObject, objectAliases);
+  parts.push(`SELECT ${smartSelectFields.join(", ")}`);
+  parts.push(`FROM {${primaryObject}}`);
+  const whereConditions = [];
+  if (whereMatch) {
+    const smartWhere = convertWhereClause(whereMatch[1].trim(), primaryObject, objectAliases);
+    whereConditions.push(smartWhere);
+  }
+  if (whereConditions.length > 0) {
+    parts.push(`WHERE ${whereConditions.join(" AND ")}`);
+  }
+  if (groupByMatch) {
+    const groupByFields = parseGroupByClause(groupByMatch[1].trim());
+    const smartGroupBy = convertGroupByFields(groupByFields, primaryObject, objectAliases);
+    parts.push(`GROUP BY ${smartGroupBy.join(", ")}`);
+  }
+  if (havingMatch) {
+    const smartHaving = convertWhereClause(havingMatch[1].trim(), primaryObject, objectAliases);
+    parts.push(`HAVING ${smartHaving}`);
+  }
+  if (orderByMatch) {
+    const orderByParts = parseOrderByClause(orderByMatch[1].trim());
+    const smartOrderBy = convertOrderByFields(orderByParts, primaryObject, objectAliases);
+    parts.push(`ORDER BY ${smartOrderBy.join(", ")}`);
+  }
+  if (limitMatch) {
+    parts.push(`LIMIT ${limitMatch[1]}`);
+  }
+  if (offsetMatch) {
+    parts.push(`OFFSET ${offsetMatch[1]}`);
+  }
+  return parts.join(" ");
+}
+
 function query(payload) {
   return highLevelApi.API.request("query", payload);
 }
 function crmQuery(payload) {
   return highLevelApi.API.request("crm_query", payload);
 }
+function extractFieldsFromSoql(soqlQuery) {
+  const { cleanQuery } = findMainFromClause(soqlQuery.replace(/\s+/g, " ").trim());
+  const selectMatch = cleanQuery.match(/SELECT\s+([\s\S]+?)\s+FROM\s+/i);
+  if (!selectMatch) return [];
+  const selectClause = selectMatch[1];
+  const fields = [];
+  let depth = 0;
+  let currentField = "";
+  for (let i = 0; i < selectClause.length; i++) {
+    const char = selectClause[i];
+    if (char === "(") {
+      depth++;
+      currentField += char;
+    } else if (char === ")") {
+      depth--;
+      currentField += char;
+    } else if (char === "," && depth === 0) {
+      if (currentField.trim()) {
+        fields.push(currentField.trim());
+      }
+      currentField = "";
+    } else {
+      currentField += char;
+    }
+  }
+  if (currentField.trim()) {
+    fields.push(currentField.trim());
+  }
+  return fields.map((field) => {
+    const aliasMatch = field.match(/^(.+?)\s+(?:AS\s+)?([A-Za-z_][A-Za-z0-9_]*)$/i);
+    const fieldExpr = aliasMatch ? aliasMatch[1].trim() : field.trim();
+    return fieldExpr;
+  });
+}
+function extractObjectFromSoql(soqlQuery) {
+  const { primaryObject } = findMainFromClause(soqlQuery.replace(/\s+/g, " ").trim());
+  return primaryObject ?? "";
+}
+function setNestedProperty(obj, path, value) {
+  const parts = path.split(".");
+  if (parts.length === 1) {
+    obj[path] = value;
+    return;
+  }
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!current[part] || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function isAllFieldsSelector(field) {
+  const trimmed = field.trim();
+  return trimmed === "*" || /^FIELDS\s*\(\s*(ALL|STANDARD|CUSTOM)\s*\)$/i.test(trimmed);
+}
+function transformSmartStoreResults(smartStoreResults, fields, objectName) {
+  if (!smartStoreResults || !Array.isArray(smartStoreResults)) {
+    return [];
+  }
+  return smartStoreResults.map((row) => {
+    const record = {};
+    fields.forEach((field, index) => {
+      if (index < row.length) {
+        const value = row[index];
+        if (isAllFieldsSelector(field)) {
+          if (value && typeof value === "object" && !Array.isArray(value)) {
+            Object.assign(record, value);
+          }
+        } else {
+          setNestedProperty(record, field, value);
+        }
+      }
+    });
+    const recordId = record["Id"] || record["id"] || "";
+    record["attributes"] = {
+      type: objectName,
+      url: recordId ? `/services/data/v57.0/sobjects/${objectName}/${recordId}` : ""
+    };
+    return record;
+  });
+}
+async function crmQueryAdaptive(payload) {
+  const query2 = payload.query;
+  if (!query2 || typeof query2 !== "string") {
+    return Promise.reject(new Error("Query is required and must be a string"));
+  }
+  let useSmartStore = false;
+  try {
+    const env = await highLevelApi.API.request("get_env");
+    const isIos = env?.mode === "IOS";
+    const isSfdcSyncEnabled = env?.launch_darkly?.sfdc_offline_enabled === true;
+    useSmartStore = isIos && isSfdcSyncEnabled;
+  } catch {
+    useSmartStore = false;
+  }
+  console.log(`[crmQueryAdaptive] Called query: `, query2);
+  if (useSmartStore) {
+    const fields = extractFieldsFromSoql(query2);
+    const objectName = extractObjectFromSoql(query2);
+    let smartQuery = convertSoqlToSmartQuery(query2);
+    if (!smartQuery.includes("__locally_deleted__")) {
+      const fromMatch = smartQuery.match(/FROM\s+\{([A-Za-z0-9_]+)\}/);
+      const primaryObject = fromMatch?.[1];
+      if (primaryObject) {
+        const filter = `({${primaryObject}:__locally_deleted__} = 0 OR {${primaryObject}:__locally_deleted__} = 'false' OR {${primaryObject}:__locally_deleted__} IS NULL)`;
+        if (smartQuery.includes(" WHERE ")) {
+          smartQuery = smartQuery.replace(
+            /\s+WHERE\s+([\s\S]+?)(?=\s+ORDER\s+BY\s+|\s+GROUP\s+BY\s+|\s+HAVING\s+|\s+LIMIT\s+|\s+OFFSET\s+|\s*$)/i,
+            (_, conditions) => ` WHERE (${conditions}) AND ${filter}`
+          );
+        } else {
+          smartQuery = smartQuery.replace(
+            /(FROM\s+\{[A-Za-z0-9_]+\})((\s+(?:ORDER\s+BY|GROUP\s+BY|HAVING|LIMIT|OFFSET)[\s\S]*)?)$/i,
+            (_, fromClause, rest) => `${fromClause} WHERE ${filter}${rest}`
+          );
+        }
+      }
+    }
+    console.log(`[crmSmartQuery] Called query: `, smartQuery);
+    const smartStoreResults = await crmSmartQuery({ query: smartQuery });
+    const records = transformSmartStoreResults(smartStoreResults, fields, objectName);
+    console.log(`[SmartStore] Results: `, records);
+    return {
+      records,
+      totalSize: records.length
+    };
+  }
+  return crmQuery(payload);
+}
 function crmSmartQuery(payload) {
   const query2 = payload.query;
   if (!query2 || typeof query2 !== "string") {
     return Promise.reject(new Error("Query is required and must be a string"));
   }
-  const smartStorePattern = /\{[^}]+:[^}]+\}/;
+  const smartStorePattern = /\{[^}]+:[^}]+}/;
   if (!smartStorePattern.test(query2.trim())) {
     return Promise.reject(
       new Error(
@@ -2560,6 +3138,9 @@ function crmSmartObjectMetadata(payload) {
   if (!objectName || typeof objectName !== "string" || objectName.trim() === "") {
     return Promise.reject(new Error("Object name is required and must be a non-empty string"));
   }
+  if (payload.record_type_id !== void 0 && (typeof payload.record_type_id !== "string" || payload.record_type_id.trim() === "")) {
+    return Promise.reject(new Error("record_type_id must be a non-empty string if provided"));
+  }
   return highLevelApi.API.request("crm_smart_object_metadata", payload);
 }
 function crmSmartUpsertObjects(payload) {
@@ -2599,7 +3180,14 @@ function crmSmartUpsertObjects(payload) {
       }
     }
   }
-  return highLevelApi.API.request("crm_smart_upsert_objects", payload);
+  console.log("[crmSmartUpsertObjects] Request payload:", JSON.stringify(payload, null, 2));
+  return highLevelApi.API.request("crm_smart_upsert_objects", payload).then((result) => {
+    console.log("[crmSmartUpsertObjects] Success:", result);
+    return result;
+  }).catch((error) => {
+    console.error("[crmSmartUpsertObjects] Error:", error);
+    throw error;
+  });
 }
 function crmSmartObjectValidationRules(payload) {
   if (!payload) {
@@ -2611,6 +3199,16 @@ function crmSmartObjectValidationRules(payload) {
   }
   return highLevelApi.API.request("crm_smart_object_validation_rules", payload);
 }
+function crmSmartObjectLayout(payload) {
+  if (!payload) {
+    return Promise.reject(new Error("Payload is required"));
+  }
+  const objectName = payload.object;
+  if (!objectName || typeof objectName !== "string" || objectName.trim() === "") {
+    return Promise.reject(new Error("Object name is required and must be a non-empty string"));
+  }
+  return highLevelApi.API.request("crm_smart_object_layout", payload);
+}
 function crmSmartDeleteObjects(payload) {
   if (!payload || !payload.objects || !Array.isArray(payload.objects)) {
     return Promise.reject(new Error("Payload must contain an array of objects"));
@@ -2639,7 +3237,75 @@ function crmSmartDeleteObjects(payload) {
       }
     }
   }
-  return highLevelApi.API.request("crm_smart_delete_objects", payload);
+  console.log("[crmSmartDeleteObjects] Request payload:", JSON.stringify(payload, null, 2));
+  return highLevelApi.API.request("crm_smart_delete_objects", payload).then((result) => {
+    console.log("[crmSmartDeleteObjects] Success:", result);
+    return result;
+  }).catch((error) => {
+    console.error("[crmSmartDeleteObjects] Error:", error);
+    throw error;
+  });
+}
+function crmCreate(payload) {
+  if (!payload) {
+    return Promise.reject(new Error("Payload is required"));
+  }
+  if (!payload.sobject || typeof payload.sobject !== "string" || payload.sobject.trim() === "") {
+    return Promise.reject(new Error("sobject is required and must be a non-empty string"));
+  }
+  if (!payload.records || !Array.isArray(payload.records) || payload.records.length === 0) {
+    return Promise.reject(new Error("records is required and must be a non-empty array"));
+  }
+  for (let i = 0; i < payload.records.length; i++) {
+    const record = payload.records[i];
+    if (!record || typeof record !== "object" || Array.isArray(record)) {
+      return Promise.reject(
+        new Error(`records contains invalid element at index ${i}. All records must be valid objects.`)
+      );
+    }
+  }
+  return highLevelApi.API.request("crm_create", payload);
+}
+function crmUpsert(payload) {
+  if (!payload) {
+    return Promise.reject(new Error("Payload is required"));
+  }
+  if (!payload.sobject || typeof payload.sobject !== "string" || payload.sobject.trim() === "") {
+    return Promise.reject(new Error("sobject is required and must be a non-empty string"));
+  }
+  if (!payload.records || !Array.isArray(payload.records) || payload.records.length === 0) {
+    return Promise.reject(new Error("records is required and must be a non-empty array"));
+  }
+  if (!payload.external_id_field || typeof payload.external_id_field !== "string" || payload.external_id_field.trim() === "") {
+    return Promise.reject(new Error("external_id_field is required and must be a non-empty string"));
+  }
+  for (let i = 0; i < payload.records.length; i++) {
+    const record = payload.records[i];
+    if (!record || typeof record !== "object" || Array.isArray(record)) {
+      return Promise.reject(
+        new Error(`records contains invalid element at index ${i}. All records must be valid objects.`)
+      );
+    }
+  }
+  return highLevelApi.API.request("crm_upsert", payload);
+}
+function crmDescribe(payload) {
+  if (!payload) {
+    return Promise.reject(new Error("Payload is required"));
+  }
+  if (!payload.sobject || typeof payload.sobject !== "string" || payload.sobject.trim() === "") {
+    return Promise.reject(new Error("sobject is required and must be a non-empty string"));
+  }
+  return highLevelApi.API.request("crm_describe", payload);
+}
+function crmLayout(payload) {
+  if (!payload) {
+    return Promise.reject(new Error("Payload is required"));
+  }
+  if (!payload.sobject || typeof payload.sobject !== "string" || payload.sobject.trim() === "") {
+    return Promise.reject(new Error("sobject is required and must be a non-empty string"));
+  }
+  return highLevelApi.API.request("crm_layout", payload);
 }
 
 function getFolders(payload) {
@@ -2733,18 +3399,22 @@ const modules = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	assignCanvasTheme,
 	close: close$2,
 	createCanvas: createCanvas$1,
-	createEvent,
 	createFavorite,
 	createFile,
 	createFolder,
+	crmCreate,
+	crmDescribe,
+	crmLayout,
 	crmQuery,
+	crmQueryAdaptive,
 	crmSmartDeleteObjects,
+	crmSmartObjectLayout,
 	crmSmartObjectMetadata,
 	crmSmartObjectValidationRules,
 	crmSmartQuery,
 	crmSmartUpsertObjects,
+	crmUpsert,
 	deleteCanvas,
-	deleteEvent,
 	deleteFavorite,
 	deleteFile,
 	deleteFolder,
@@ -2758,7 +3428,6 @@ const modules = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	getCanvases: getCanvases$1,
 	getCoreFolders,
 	getEnv: getEnv$2,
-	getEvents,
 	getFavorites,
 	getFile: getFile$2,
 	getFileRevisionData,
@@ -2795,7 +3464,6 @@ const modules = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	unassignCanvasTheme,
 	updateCanvas: updateCanvas$2,
 	updateCanvasIndicators,
-	updateEvent,
 	updateFile,
 	updateFolder,
 	updateMyUser
@@ -2841,21 +3509,17 @@ function unsafeStringify(arr, offset = 0) {
         byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-let getRandomValues;
 const rnds8 = new Uint8Array(16);
 function rng() {
-    if (!getRandomValues) {
-        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
-            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-        }
-        getRandomValues = crypto.getRandomValues.bind(crypto);
-    }
-    return getRandomValues(rnds8);
+    return crypto.getRandomValues(rnds8);
 }
 
-const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-const native = { randomUUID };
-
+function v4(options, buf, offset) {
+    if (crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return _v4(options);
+}
 function _v4(options, buf, offset) {
     options = options || {};
     const rnds = options.random ?? options.rng?.() ?? rng();
@@ -2866,12 +3530,6 @@ function _v4(options, buf, offset) {
     rnds[8] = (rnds[8] & 0x3f) | 0x80;
     return unsafeStringify(rnds);
 }
-function v4(options, buf, offset) {
-    if (native.randomUUID && true && !options) {
-        return native.randomUUID();
-    }
-    return _v4(options);
-}
 
 const PITCHER_EVENT = "PITCHER_EVENT";
 var PitcherMessageType = /* @__PURE__ */ ((PitcherMessageType2) => {
@@ -2916,6 +3574,7 @@ var PitcherEventName = /* @__PURE__ */ ((PitcherEventName2) => {
   PitcherEventName2["ITEM_SHAREBOX_ADD_REQUESTED"] = "item_sharebox_add_requested";
   PitcherEventName2["ITEM_SHAREBOX_ADD_COMPLETED"] = "item_sharebox_add_completed";
   PitcherEventName2["SYNC_BADGE_VALUE_REPORTED"] = "sync_badge_value_reported";
+  PitcherEventName2["SYNC_BOX_RESOLVE_ERROR_TAPPED"] = "sync_box_resolve_error_tapped";
   PitcherEventName2["PEER_CONNECTIVITY_EVENT"] = "peer_connectivity_event";
   return PitcherEventName2;
 })(PitcherEventName || {});
@@ -2950,6 +3609,8 @@ const defaultSkipKeys = [
   "id__in",
   "tags__in",
   "tags__not_in",
+  "template__id",
+  "template__id__in",
   "modified_at__gtr",
   "created_at__gtr",
   "end_at__lt",
@@ -3191,6 +3852,17 @@ function createHttpClient(origin, token) {
         body: JSON.stringify(body)
       });
       return data;
+    },
+    /** PATCH with a full absolute URL (bypasses /api/v1 prefix). */
+    patchUrl: async (absoluteUrl, body, options = {}) => {
+      const data = await fetchWithRetry(absoluteUrl, {
+        ...baseCommon,
+        ...options,
+        method: "PATCH",
+        headers,
+        body: JSON.stringify(body)
+      });
+      return data;
     }
   };
 }
@@ -3259,8 +3931,16 @@ const onlineRestApiHandlers = {
   },
   update_canvas: async (params) => {
     check();
-    const { id, ...restParams } = params;
-    const res = await http.patch(`/canvases/${params.id}`, restParams);
+    const { id, fields, ...canvasData } = params;
+    const useCoreEndpoint = env?.launch_darkly?.enable_canvas_core_patch === true;
+    if (useCoreEndpoint) {
+      const origin = env.pitcher.token_claims["https://pitcher.com/claims/urls"].custom_domain;
+      const fieldsQs = fields ? `?fields=${encodeURIComponent(fields)}` : "";
+      const url = `${origin}/core/api/protected/v1/canvases/${id}${fieldsQs}`;
+      const res2 = await http.patchUrl(url, canvasData);
+      return res2;
+    }
+    const res = await http.patch(`/canvases/${id}`, { fields, ...canvasData });
     return res;
   },
   delete_canvas: async (params) => {
@@ -3332,6 +4012,18 @@ function getTopPitcherWindow(current = window) {
 }
 
 const TRUNCATE_LENGTH_TRIGGER = 10;
+const RAW_PAYLOAD_METHODS = [
+  "crm_create",
+  "crm_upsert",
+  "crm_describe",
+  "crm_layout",
+  "crm_smart_query",
+  "crm_smart_object_metadata",
+  "crm_smart_object_validation_rules",
+  "crm_smart_object_layout",
+  "crm_smart_upsert_objects",
+  "crm_smart_delete_objects"
+];
 function updateOnlineHandlersEnv(env) {
   env && setEnv(env);
 }
@@ -3397,7 +4089,8 @@ class LowLevelApi extends EventEmitter {
           throw new Error("unsupported response status");
         }
       };
-      const payload = cloneDeep(snakeCaseKeys(body));
+      const shouldSkipSnakeCase = RAW_PAYLOAD_METHODS.includes(type);
+      const payload = shouldSkipSnakeCase ? cloneDeep(body) : cloneDeep(snakeCaseKeys(body));
       this.callbacks[id] = {
         dispatched_at: Date.now(),
         type,
@@ -3610,7 +4303,10 @@ const UI_API_METHOD_TYPES = {
   UI_APP_LOADED: "ui_app_loaded",
   UI_APP_RESIZE: "ui_app_resize",
   UI_CLOSE_CANVAS_SECTION_EXECUTION: "ui_close_canvas_section_execution",
-  UI_CLOSE_CANVAS_DRAWER: "ui_close_canvas_drawer"
+  UI_CLOSE_CANVAS_DRAWER: "ui_close_canvas_drawer",
+  UI_OPEN_GLOBAL_POPUP: "ui_open_global_popup",
+  UI_CLOSE_GLOBAL_POPUP: "ui_close_global_popup",
+  UI_OPEN_SHARING_SETTINGS: "ui_open_sharing_settings"
 };
 const UI_MESSAGE_TYPES = {
   UI_MEETING_CANCELED: "ui_meeting_canceled",
@@ -3662,10 +4358,25 @@ async function selectAgendaContent$1(payload = {}) {
   const response = await pr.send(window.parent, UI_API_METHOD_TYPES.UI_SELECT_AGENDA_CONTENT, payload);
   return response.data;
 }
+async function openGlobalPopup(appName, extraContext) {
+  const pr = await usePostRobot();
+  const payload = {
+    app_name: appName,
+    extra_context: extraContext
+  };
+  const response = await pr.send(window.parent, UI_API_METHOD_TYPES.UI_OPEN_GLOBAL_POPUP, payload);
+  return response.data;
+}
+async function closeGlobalPopup() {
+  const pr = await usePostRobot();
+  await pr.send(window.parent, UI_API_METHOD_TYPES.UI_CLOSE_GLOBAL_POPUP, {});
+}
 
 const contentUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	__proto__: null,
+	closeGlobalPopup,
 	open: open$1,
+	openGlobalPopup,
 	preselectSfdcMeetingId,
 	selectAgendaContent: selectAgendaContent$1,
 	selectCollectionContent: selectCollectionContent$1,
@@ -3817,6 +4528,21 @@ const piaUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	promptPia
 }, Symbol.toStringTag, { value: 'Module' }));
 
+async function openSharingSettings(payload) {
+  const pr = await usePostRobot();
+  const response = await pr.send(
+    window.parent,
+    UI_API_METHOD_TYPES.UI_OPEN_SHARING_SETTINGS,
+    payload
+  );
+  return response.data;
+}
+
+const sharingUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	openSharingSettings
+}, Symbol.toStringTag, { value: 'Module' }));
+
 async function onNative(type, handler) {
   const messageListener = (event) => {
     if (event.data.type === type) {
@@ -3870,7 +4596,8 @@ const ui = {
   ...appErrorsUi,
   ...canvasUi,
   ...postCallUi,
-  ...piaUi
+  ...piaUi,
+  ...sharingUi
 };
 
 const ADMIN_MESSAGE = "ADMIN_MESSAGE";