@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-NQNLUAPO.js

@@ -0,0 +1,505 @@
+import {
+  isExecutePort,
+  isFailurePort,
+  isScopedMandatoryPort,
+  isSuccessPort
+} from "./chunk-R4QGNK34.js";
+
+// src/jsdoc-port-sync/constants.ts
+var JSDOC_BLOCK_REGEX = /\/\*\*[\s\S]*?\*\//;
+var PORT_TAG_REGEX = /^\s*\*\s*@(input|output|step)\b/;
+var ORPHAN_PORT_LINE_REGEX = /^\s*\*\s*@(input|output|step)\s*$/;
+var SCOPE_TAG_REGEX = /@scope\s+(\w+)/g;
+var FUNC_DECL_START = /(?:async\s+)?function\s+\w+\s*\(/;
+var ARROW_START = /(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\(/;
+var RETURN_OBJECT_REGEX = /return\s*\{([^}]+)\}/g;
+var RESERVED_PARAMS = ["execute"];
+var RESERVED_RETURN_FIELDS = ["onSuccess", "onFailure"];
+function isReservedStepPort(name) {
+  return isExecutePort(name) || isSuccessPort(name) || isFailurePort(name) || isScopedMandatoryPort(name);
+}
+function findBalancedClose(text, startIndex) {
+  const openChar = text[startIndex];
+  const closeChar = openChar === "(" ? ")" : openChar === "{" ? "}" : "]";
+  let depth = 1;
+  for (let i = startIndex + 1; i < text.length; i++) {
+    if (text[i] === openChar) depth++;
+    else if (text[i] === closeChar) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitParams(paramsStr) {
+  const result = [];
+  let current = "";
+  let braceDepth = 0;
+  let angleDepth = 0;
+  let parenDepth = 0;
+  for (const char of paramsStr) {
+    if (char === "{") braceDepth++;
+    else if (char === "}") braceDepth--;
+    else if (char === "<") angleDepth++;
+    else if (char === ">" && angleDepth > 0) angleDepth--;
+    else if (char === "(") parenDepth++;
+    else if (char === ")") parenDepth--;
+    else if (char === "," && braceDepth === 0 && angleDepth === 0 && parenDepth === 0) {
+      result.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) {
+    result.push(current);
+  }
+  return result;
+}
+
+// src/jsdoc-port-sync/signature-parser.ts
+function parseFunctionSignature(functionText) {
+  const params = [];
+  let functionType = "expression";
+  let paramsStr = "";
+  const funcDeclMatch = functionText.match(FUNC_DECL_START);
+  if (funcDeclMatch && funcDeclMatch.index !== void 0) {
+    functionType = "declaration";
+    const openParenIndex = funcDeclMatch.index + funcDeclMatch[0].length - 1;
+    const closeParenIndex = findBalancedClose(functionText, openParenIndex);
+    if (closeParenIndex !== -1) {
+      paramsStr = functionText.substring(openParenIndex + 1, closeParenIndex);
+    }
+  } else {
+    const arrowMatch = functionText.match(ARROW_START);
+    if (arrowMatch && arrowMatch.index !== void 0) {
+      functionType = "arrow";
+      const openParenIndex = arrowMatch.index + arrowMatch[0].length - 1;
+      const closeParenIndex = findBalancedClose(functionText, openParenIndex);
+      if (closeParenIndex !== -1) {
+        paramsStr = functionText.substring(openParenIndex + 1, closeParenIndex);
+      }
+    }
+  }
+  if (!paramsStr.trim()) {
+    return { params, functionType };
+  }
+  const paramTokens = splitParams(paramsStr);
+  paramTokens.forEach((paramStr, index) => {
+    const param = parseParam(paramStr.trim(), index);
+    if (param) {
+      params.push(param);
+    }
+  });
+  return { params, functionType };
+}
+function rawParamListText(functionText) {
+  const sigMatch = functionText.match(/function\s+\w+\s*\(([^)]*)/s) || functionText.match(/=\s*\(([^)]*)\)\s*(?:=>|:)/s);
+  return sigMatch?.[1] || "";
+}
+function parseParam(paramStr, position) {
+  if (!paramStr) return null;
+  const trimmed = paramStr.trim();
+  if (!trimmed) return null;
+  const nameMatch = trimmed.match(/^(\w+)(\?)?/);
+  if (!nameMatch) return null;
+  const name = nameMatch[1];
+  const questionMark = nameMatch[2];
+  let rest = trimmed.substring(nameMatch[0].length).trim();
+  let tsType;
+  let defaultValue;
+  if (rest.startsWith(":")) {
+    rest = rest.substring(1).trim();
+    let depth = 0;
+    let typeEnd = rest.length;
+    for (let i = 0; i < rest.length; i++) {
+      const ch = rest[i];
+      if (ch === "(" || ch === "{" || ch === "[" || ch === "<") {
+        depth++;
+      } else if (ch === ")" || ch === "}" || ch === "]" || ch === ">") {
+        depth--;
+      } else if (ch === "=" && depth === 0) {
+        if (rest[i + 1] === ">") {
+          i++;
+          continue;
+        }
+        typeEnd = i;
+        break;
+      }
+    }
+    tsType = rest.substring(0, typeEnd).trim();
+    rest = rest.substring(typeEnd).trim();
+  }
+  if (rest.startsWith("=")) {
+    defaultValue = rest.substring(1).trim();
+  }
+  const hasDefault = defaultValue !== void 0;
+  const optional = !!questionMark || hasDefault;
+  return {
+    name,
+    tsType: tsType || void 0,
+    optional,
+    defaultValue,
+    position
+  };
+}
+function parseReturnFields(functionText) {
+  const fields = /* @__PURE__ */ new Set();
+  RETURN_OBJECT_REGEX.lastIndex = 0;
+  let match;
+  while ((match = RETURN_OBJECT_REGEX.exec(functionText)) != null) {
+    const objectContent = match[1];
+    const fieldParts = objectContent.split(",");
+    for (const part of fieldParts) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      const colonMatch = trimmed.match(/^(\w+)\s*:/);
+      if (colonMatch) {
+        const fieldName = colonMatch[1];
+        if (!RESERVED_RETURN_FIELDS.includes(fieldName)) {
+          fields.add(fieldName);
+        }
+      } else {
+        const shorthandMatch = trimmed.match(/^(\w+)$/);
+        if (shorthandMatch) {
+          const fieldName = shorthandMatch[1];
+          if (!RESERVED_RETURN_FIELDS.includes(fieldName)) {
+            fields.add(fieldName);
+          }
+        }
+      }
+    }
+  }
+  return Array.from(fields);
+}
+function parseReturnBodyFieldsWithTypes(functionText) {
+  const fields = /* @__PURE__ */ new Map();
+  RETURN_OBJECT_REGEX.lastIndex = 0;
+  let match;
+  while ((match = RETURN_OBJECT_REGEX.exec(functionText)) != null) {
+    const objectContent = match[1];
+    const fieldParts = objectContent.split(",");
+    for (const part of fieldParts) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      const colonMatch = trimmed.match(/^(\w+)\s*:\s*(.+)$/);
+      if (colonMatch) {
+        const fieldName = colonMatch[1];
+        const value = colonMatch[2].trim();
+        if (!RESERVED_RETURN_FIELDS.includes(fieldName)) {
+          const inferredType = inferTypeFromValue(value);
+          if (!fields.has(fieldName) || fields.get(fieldName) === "any") {
+            fields.set(fieldName, inferredType);
+          }
+        }
+      } else {
+        const shorthandMatch = trimmed.match(/^(\w+)$/);
+        if (shorthandMatch) {
+          const fieldName = shorthandMatch[1];
+          if (!RESERVED_RETURN_FIELDS.includes(fieldName) && !fields.has(fieldName)) {
+            fields.set(fieldName, "any");
+          }
+        }
+      }
+    }
+  }
+  return fields;
+}
+function inferTypeFromValue(value) {
+  value = value.trim();
+  if (value.startsWith("[")) return "any[]";
+  if (value.startsWith("{")) return "any";
+  if (/^["'`]/.test(value)) return "string";
+  if (/^-?\d+(\.\d+)?$/.test(value)) return "number";
+  if (value === "true" || value === "false") return "boolean";
+  if (value === "null" || value === "undefined") return "any";
+  return "any";
+}
+function parseReturnTypeFields(functionText) {
+  let returnTypeMatch = functionText.match(/\)\s*:\s*\{([^}]+)\}\s*(?:\{|=>)/);
+  if (!returnTypeMatch) {
+    const genericStart = functionText.indexOf("TFlowWeaverNodeType<");
+    if (genericStart !== -1) {
+      let braceCount = 0;
+      let inFirstParam = false;
+      let firstParamEnd = -1;
+      let secondParamStart = -1;
+      let secondParamEnd = -1;
+      for (let i = genericStart + "TFlowWeaverNodeType<".length; i < functionText.length; i++) {
+        const char = functionText[i];
+        if (char === "{") {
+          if (!inFirstParam && braceCount === 0) {
+            inFirstParam = true;
+          } else if (firstParamEnd !== -1 && secondParamStart === -1) {
+            secondParamStart = i + 1;
+          }
+          braceCount++;
+        } else if (char === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            if (inFirstParam && firstParamEnd === -1) {
+              firstParamEnd = i;
+              inFirstParam = false;
+            } else if (secondParamStart !== -1) {
+              secondParamEnd = i;
+              break;
+            }
+          }
+        }
+      }
+      if (secondParamStart !== -1 && secondParamEnd !== -1) {
+        const objectContent2 = functionText.substring(secondParamStart, secondParamEnd);
+        returnTypeMatch = [functionText, objectContent2];
+      }
+    }
+  }
+  if (!returnTypeMatch) return [];
+  const fields = [];
+  const objectContent = returnTypeMatch[1];
+  const fieldParts = objectContent.split(/[,;]/);
+  for (const part of fieldParts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const colonMatch = trimmed.match(/^(\w+)\s*:/);
+    if (colonMatch) {
+      const fieldName = colonMatch[1];
+      if (!RESERVED_RETURN_FIELDS.includes(fieldName)) {
+        fields.push(fieldName);
+      }
+    }
+  }
+  return fields;
+}
+function parseReturnTypeFieldsWithTypes(functionText) {
+  const fields = [];
+  const returnTypeMatch = functionText.match(/\)\s*:\s*(?:Promise\s*<\s*)?\{([^}]+)\}/);
+  if (!returnTypeMatch) return fields;
+  const returnTypeContent = returnTypeMatch[1];
+  const fieldRegex = /(\w+)\s*\??\s*:\s*([^;,}]+)/g;
+  let match;
+  while ((match = fieldRegex.exec(returnTypeContent)) != null) {
+    const [, name, tsType] = match;
+    fields.push({ name, tsType: tsType.trim() });
+  }
+  return fields;
+}
+function splitObjectFields(content) {
+  const result = [];
+  let current = "";
+  let angleDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let parenDepth = 0;
+  for (const char of content) {
+    if (char === "<") angleDepth++;
+    else if (char === ">" && angleDepth > 0) angleDepth--;
+    else if (char === "[") bracketDepth++;
+    else if (char === "]" && bracketDepth > 0) bracketDepth--;
+    else if (char === "{") braceDepth++;
+    else if (char === "}" && braceDepth > 0) braceDepth--;
+    else if (char === "(") parenDepth++;
+    else if (char === ")" && parenDepth > 0) parenDepth--;
+    else if ((char === "," || char === ";") && angleDepth === 0 && bracketDepth === 0 && braceDepth === 0 && parenDepth === 0) {
+      result.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) {
+    result.push(current);
+  }
+  return result;
+}
+function parseInputTypeFields(functionText) {
+  const genericStart = functionText.indexOf("TFlowWeaverNodeType<");
+  if (genericStart === -1) return [];
+  let braceCount = 0;
+  let firstParamStart = -1;
+  let firstParamEnd = -1;
+  for (let i = genericStart + "TFlowWeaverNodeType<".length; i < functionText.length; i++) {
+    const char = functionText[i];
+    if (char === "{") {
+      if (braceCount === 0) {
+        firstParamStart = i + 1;
+      }
+      braceCount++;
+    } else if (char === "}") {
+      braceCount--;
+      if (braceCount === 0) {
+        firstParamEnd = i;
+        break;
+      }
+    }
+  }
+  if (firstParamStart === -1 || firstParamEnd === -1) return [];
+  const objectContent = functionText.substring(firstParamStart, firstParamEnd);
+  const fields = [];
+  const fieldParts = splitObjectFields(objectContent);
+  for (const part of fieldParts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const colonMatch = trimmed.match(/^(\w+)\s*:\s*(.+)$/);
+    if (colonMatch) {
+      fields.push({ name: colonMatch[1], tsType: colonMatch[2].trim() });
+    }
+  }
+  return fields;
+}
+function tsTypeToPortType(tsType) {
+  if (!tsType) return "ANY";
+  const normalized = tsType.trim().toLowerCase();
+  switch (normalized) {
+    case "number":
+      return "NUMBER";
+    case "string":
+      return "STRING";
+    case "boolean":
+      return "BOOLEAN";
+    case "any[]":
+    case "array":
+      return "ARRAY";
+    case "object":
+      return "OBJECT";
+    case "function":
+      return "FUNCTION";
+    default:
+      return "ANY";
+  }
+}
+function portTypeToTsType(portType) {
+  switch (portType) {
+    case "NUMBER":
+      return "number";
+    case "STRING":
+      return "string";
+    case "BOOLEAN":
+      return "boolean";
+    case "ARRAY":
+      return "any[]";
+    case "OBJECT":
+      return "any";
+    case "FUNCTION":
+      return "(...args: any[]) => any";
+    case "STEP":
+      return "boolean";
+    case "ANY":
+    default:
+      return "any";
+  }
+}
+function parseCallbackType(callbackType) {
+  const params = [];
+  const returnFields = [];
+  let returnType = "";
+  const arrowIdx = callbackType.indexOf("=>");
+  if (arrowIdx === -1) return { params, returnType, returnFields };
+  const beforeArrow = callbackType.substring(0, arrowIdx).trim();
+  const openParen = beforeArrow.indexOf("(");
+  const closeParen = beforeArrow.lastIndexOf(")");
+  if (openParen === -1 || closeParen === -1) return { params, returnType, returnFields };
+  const paramsStr = beforeArrow.substring(openParen + 1, closeParen);
+  const paramTokens = splitParams(paramsStr);
+  for (const token of paramTokens) {
+    const trimmed = token.trim();
+    if (!trimmed) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx !== -1) {
+      const name = trimmed.substring(0, colonIdx).trim().replace(/\?$/, "");
+      const typeStr = trimmed.substring(colonIdx + 1).trim();
+      params.push({ name, typeStr });
+    }
+  }
+  returnType = callbackType.substring(arrowIdx + 2).trim();
+  const returnMatch = returnType.match(/^\{\s*([\s\S]*?)\s*\}$/);
+  if (returnMatch) {
+    const fieldsStr = returnMatch[1];
+    const fieldParts = fieldsStr.split(/[;\n]/).filter((s) => s.trim());
+    for (const part of fieldParts) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx !== -1) {
+        const name = trimmed.substring(0, colonIdx).trim();
+        const typeStr = trimmed.substring(colonIdx + 1).trim();
+        returnFields.push({ name, typeStr });
+      }
+    }
+  }
+  return { params, returnType, returnFields };
+}
+function buildCallbackType(callbackParams, callbackReturns, existingCallbackType) {
+  const scopedParamNames = new Set(callbackParams.map(([name]) => name));
+  const scopedReturnNames = new Set(callbackReturns.map(([name]) => name));
+  const isParamsMultiline = existingCallbackType?.includes("(\n") || false;
+  const isReturnMultiline = existingCallbackType?.match(/=>\s*\{\n/) != null;
+  const scopedParamsList = callbackParams.sort((a, b) => (a[1].metadata?.order ?? Infinity) - (b[1].metadata?.order ?? Infinity)).map(([name, port]) => `${name}: ${portTypeToTsType(port.dataType)}`);
+  let preservedParams = [];
+  let preservedReturns = [];
+  if (existingCallbackType) {
+    const parsed = parseCallbackType(existingCallbackType);
+    preservedParams = parsed.params.filter(({ name }) => !scopedParamNames.has(name)).map(({ name, typeStr }) => `${name}: ${typeStr}`);
+    preservedReturns = parsed.returnFields.filter(({ name }) => !scopedReturnNames.has(name)).map(({ name, typeStr }) => `${name}: ${typeStr}`);
+  }
+  const allParamsList = [...preservedParams, ...scopedParamsList].filter(Boolean);
+  const scopedReturnFields = callbackReturns.sort((a, b) => (a[1].metadata?.order ?? Infinity) - (b[1].metadata?.order ?? Infinity)).map(([name, port]) => `${name}: ${portTypeToTsType(port.dataType)}`);
+  const allReturnFields = [...preservedReturns, ...scopedReturnFields];
+  let paramsStr;
+  if (isParamsMultiline && allParamsList.length > 0) {
+    paramsStr = `
+    ${allParamsList.join(",\n    ")},
+  `;
+  } else {
+    paramsStr = allParamsList.join(", ");
+  }
+  if (isReturnMultiline && allReturnFields.length > 0) {
+    const returnFieldsStr = allReturnFields.map((f) => `    ${f};`).join("\n");
+    return `(${paramsStr}) => {
+${returnFieldsStr}
+  }`;
+  } else {
+    const returnFieldsStr = allReturnFields.join("; ");
+    return `(${paramsStr}) => { ${returnFieldsStr} }`;
+  }
+}
+function callbackHasAllPorts(callbackType, callbackParams, callbackReturns) {
+  for (const [name] of callbackParams) {
+    const paramRegex = new RegExp(`\\b${name}\\s*:`);
+    if (!paramRegex.test(callbackType)) return false;
+  }
+  for (const [name] of callbackReturns) {
+    const arrowIdx = callbackType.indexOf("=>");
+    if (arrowIdx === -1) return false;
+    const returnPart = callbackType.substring(arrowIdx);
+    const returnRegex = new RegExp(`\\b${name}\\s*:`);
+    if (!returnRegex.test(returnPart)) return false;
+  }
+  return true;
+}
+
+export {
+  JSDOC_BLOCK_REGEX,
+  PORT_TAG_REGEX,
+  ORPHAN_PORT_LINE_REGEX,
+  SCOPE_TAG_REGEX,
+  FUNC_DECL_START,
+  ARROW_START,
+  RETURN_OBJECT_REGEX,
+  RESERVED_PARAMS,
+  RESERVED_RETURN_FIELDS,
+  isReservedStepPort,
+  findBalancedClose,
+  splitParams,
+  parseFunctionSignature,
+  rawParamListText,
+  parseReturnFields,
+  parseReturnBodyFieldsWithTypes,
+  parseReturnTypeFields,
+  parseReturnTypeFieldsWithTypes,
+  parseInputTypeFields,
+  tsTypeToPortType,
+  portTypeToTsType,
+  parseCallbackType,
+  buildCallbackType,
+  callbackHasAllPorts
+};