@synergenius/flow-weaver 0.2.0

package/dist/jsdoc-port-sync/rename.js

@@ -0,0 +1,256 @@
+/**
+ * @module jsdoc-port-sync/rename
+ *
+ * Port renaming and code rename synchronization.
+ */
+import { isReservedPortName } from "../constants.js";
+import { parsePortsFromFunctionText, hasOrphanPortLines, } from "./port-parser.js";
+import { parseFunctionSignature, parseReturnTypeFields, } from "./signature-parser.js";
+// =============================================================================
+// Port Renaming
+// =============================================================================
+/**
+ * Rename a port in both JSDoc and function signature.
+ * For input ports: renames @input tag and function parameter
+ * For output ports: renames @output tag and return type field
+ * For scoped ports: also updates callback parameter/return names
+ */
+export function renamePortInCode(code, oldPortName, newPortName, portType) {
+    const reservedNames = ["execute", "onSuccess", "onFailure"];
+    if (reservedNames.includes(oldPortName) || reservedNames.includes(newPortName)) {
+        return code;
+    }
+    const { inputs, outputs } = parsePortsFromFunctionText(code);
+    const allPorts = { ...inputs, ...outputs };
+    const ports = portType === "input" ? inputs : outputs;
+    if (!ports[oldPortName]) {
+        return code;
+    }
+    if (allPorts[newPortName]) {
+        return code;
+    }
+    let result = code;
+    const portDef = ports[oldPortName];
+    const isScoped = !!portDef.scope;
+    // 1. Rename in JSDoc
+    const tagType = portType === "input" ? "@input" : "@output";
+    const jsDocPattern = new RegExp(`(${tagType}\\s+)(\\[?)${oldPortName}(\\]?)`, "g");
+    result = result.replace(jsDocPattern, `$1$2${newPortName}$3`);
+    // 2. Rename in function signature
+    if (portType === "input") {
+        if (isScoped) {
+            result = renameFieldInReturnType(result, oldPortName, newPortName, true);
+        }
+        else {
+            result = renameParameterInSignature(result, oldPortName, newPortName);
+        }
+    }
+    else {
+        if (isScoped) {
+            result = renameCallbackParameter(result, oldPortName, newPortName);
+        }
+        else {
+            result = renameFieldInReturnType(result, oldPortName, newPortName, false);
+        }
+    }
+    return result;
+}
+/**
+ * Rename a parameter in the function signature
+ */
+function renameParameterInSignature(code, oldName, newName) {
+    const paramPattern = new RegExp(`([(,]\\s*)${oldName}(\\s*[?:]|\\s*=)`, "g");
+    return code.replace(paramPattern, `$1${newName}$2`);
+}
+/**
+ * Remove a parameter from the function signature
+ */
+function removeParameterFromSignature(code, paramName) {
+    const middleOrLastPattern = new RegExp(`,\\s*${paramName}\\s*[?]?\\s*:\\s*[^,)]+`, "g");
+    let result = code.replace(middleOrLastPattern, "");
+    const firstWithCommaPattern = new RegExp(`([(])\\s*${paramName}\\s*[?]?\\s*:\\s*[^,)]+,\\s*`, "g");
+    result = result.replace(firstWithCommaPattern, "$1");
+    const onlyParamPattern = new RegExp(`([(])\\s*${paramName}\\s*[?]?\\s*:\\s*[^,)]+\\s*([)])`, "g");
+    result = result.replace(onlyParamPattern, "$1$2");
+    return result;
+}
+/**
+ * Remove a field from the return type annotation
+ */
+function removeFieldFromReturnType(code, fieldName) {
+    const middleOrLastPattern = new RegExp(`[;,]\\s*${fieldName}\\s*:\\s*[^;,}]+`, "g");
+    let result = code.replace(middleOrLastPattern, "");
+    const firstWithSemiPattern = new RegExp(`(\\{\\s*)${fieldName}\\s*:\\s*[^;,}]+[;,]\\s*`, "g");
+    result = result.replace(firstWithSemiPattern, "$1");
+    const onlyFieldPattern = new RegExp(`(\\{\\s*)${fieldName}\\s*:\\s*[^;,}]+\\s*(\\})`, "g");
+    result = result.replace(onlyFieldPattern, "$1$2");
+    return result;
+}
+/**
+ * Rename a field in return type: { fieldName: type }
+ */
+function renameFieldInReturnType(code, oldName, newName, isCallback) {
+    if (isCallback) {
+        const callbackPattern = new RegExp(`(=>\\s*\\{[^}]*?)\\b${oldName}(\\s*:)`, "g");
+        return code.replace(callbackPattern, `$1${newName}$2`);
+    }
+    else {
+        const returnPattern = new RegExp(`(\\)\\s*:\\s*\\{[^}]*?)\\b${oldName}(\\s*:)`, "g");
+        return code.replace(returnPattern, `$1${newName}$2`);
+    }
+}
+/**
+ * Rename a parameter in a callback signature
+ */
+function renameCallbackParameter(code, oldName, newName) {
+    const callbackParamPattern = new RegExp(`(:\\s*\\([^)]*?)\\b${oldName}(\\s*:)`, "g");
+    return code.replace(callbackParamPattern, `$1${newName}$2`);
+}
+// =============================================================================
+// Helpers for Code Rename Sync
+// =============================================================================
+function getSyncableInputNames(code) {
+    const { inputs } = parsePortsFromFunctionText(code);
+    return Object.entries(inputs)
+        .filter(([name, port]) => !port.scope && !isReservedPortName(name))
+        .map(([name]) => name);
+}
+function getSyncableOutputNames(code) {
+    const { outputs } = parsePortsFromFunctionText(code);
+    return Object.entries(outputs)
+        .filter(([name, port]) => !port.scope && !isReservedPortName(name))
+        .map(([name]) => name);
+}
+function getSyncableParamNames(code) {
+    const { params } = parseFunctionSignature(code);
+    return params
+        .filter(p => !isReservedPortName(p.name) && !p.tsType?.includes("=>"))
+        .map(p => p.name);
+}
+function getSyncableReturnFieldNames(code) {
+    const returnTypeFields = parseReturnTypeFields(code);
+    return returnTypeFields.filter(f => !isReservedPortName(f));
+}
+/**
+ * Rename a port in JSDoc
+ */
+function renamePortInJSDoc(code, oldName, newName, type) {
+    const tag = type === "input" ? "@input" : "@output";
+    const pattern = new RegExp(`(${tag}\\s+)${oldName}(\\b)`, "g");
+    return code.replace(pattern, `$1${newName}$2`);
+}
+// =============================================================================
+// Code Rename Sync
+// =============================================================================
+/**
+ * Sync renames between JSDoc ports and function signature using before/after diff.
+ *
+ * @param previousCode - The code before the edit
+ * @param currentCode - The code after the edit
+ * @returns The synchronized code
+ */
+export function syncCodeRenames(previousCode, currentCode) {
+    if (!previousCode.trim()) {
+        return currentCode;
+    }
+    const prevOrphanLines = hasOrphanPortLines(previousCode);
+    const currOrphanLines = hasOrphanPortLines(currentCode);
+    let result = currentCode;
+    // === INPUT PORTS ===
+    if (currOrphanLines.inputs) {
+        const prevJSDocInputs = getSyncableInputNames(previousCode);
+        const currJSDocInputs = getSyncableInputNames(currentCode);
+        const currSigParams = getSyncableParamNames(currentCode);
+        for (const prevName of prevJSDocInputs) {
+            if (!currJSDocInputs.includes(prevName) && currSigParams.includes(prevName)) {
+                result = removeParameterFromSignature(result, prevName);
+            }
+        }
+    }
+    else if (prevOrphanLines.inputs) {
+        // Skip rename detection
+    }
+    else {
+        const prevJSDocInputs = getSyncableInputNames(previousCode);
+        const currJSDocInputs = getSyncableInputNames(currentCode);
+        const prevSigParams = getSyncableParamNames(previousCode);
+        const currSigParams = getSyncableParamNames(currentCode);
+        const prevJSDocSet = new Set(prevJSDocInputs);
+        const currJSDocSet = new Set(currJSDocInputs);
+        const prevSigSet = new Set(prevSigParams);
+        const currSigSet = new Set(currSigParams);
+        const sigMatch = currentCode.match(/function\s+\w+\s*\(([^)]*)/s) ||
+            currentCode.match(/=\s*\(([^)]*)\)\s*(?:=>|:)/s);
+        const rawSigText = sigMatch?.[1] || "";
+        const jsDocPortsInRawButNotParsed = currJSDocInputs.some(name => new RegExp(`\\b${name}\\b`).test(rawSigText) && !currSigSet.has(name));
+        if (!jsDocPortsInRawButNotParsed) {
+            for (let i = 0; i < Math.min(currJSDocInputs.length, currSigParams.length); i++) {
+                const currJSDoc = currJSDocInputs[i];
+                const currSig = currSigParams[i];
+                if (currJSDoc === currSig)
+                    continue;
+                const jsDocChanged = prevJSDocInputs[i] !== currJSDoc;
+                const sigChanged = prevSigParams[i] !== currSig;
+                if (jsDocChanged && !sigChanged) {
+                    const oldJSDoc = prevJSDocInputs[i];
+                    if (oldJSDoc && !currJSDocSet.has(oldJSDoc) && !prevJSDocSet.has(currJSDoc)) {
+                        result = renameParameterInSignature(result, currSig, currJSDoc);
+                    }
+                }
+                else if (sigChanged && !jsDocChanged) {
+                    const oldSig = prevSigParams[i];
+                    const oldNameInRawSig = new RegExp(`\\b${oldSig}\\b`).test(rawSigText);
+                    if (oldSig && !currSigSet.has(oldSig) && !prevSigSet.has(currSig) && !oldNameInRawSig) {
+                        result = renamePortInJSDoc(result, currJSDoc, currSig, "input");
+                    }
+                }
+            }
+        }
+    }
+    // === OUTPUT PORTS ===
+    if (currOrphanLines.outputs) {
+        const prevJSDocOutputs = getSyncableOutputNames(previousCode);
+        const currJSDocOutputs = getSyncableOutputNames(currentCode);
+        const currReturnFields = getSyncableReturnFieldNames(currentCode);
+        for (const prevName of prevJSDocOutputs) {
+            if (!currJSDocOutputs.includes(prevName) && currReturnFields.includes(prevName)) {
+                result = removeFieldFromReturnType(result, prevName);
+            }
+        }
+    }
+    else if (prevOrphanLines.outputs) {
+        // Skip rename detection
+    }
+    else {
+        const prevJSDocOutputs = getSyncableOutputNames(previousCode);
+        const currJSDocOutputs = getSyncableOutputNames(currentCode);
+        const prevReturnFields = getSyncableReturnFieldNames(previousCode);
+        const currReturnFields = getSyncableReturnFieldNames(currentCode);
+        const prevJSDocSet = new Set(prevJSDocOutputs);
+        const currJSDocSet = new Set(currJSDocOutputs);
+        const prevReturnSet = new Set(prevReturnFields);
+        const currReturnSet = new Set(currReturnFields);
+        for (let i = 0; i < Math.min(currJSDocOutputs.length, currReturnFields.length); i++) {
+            const currJSDoc = currJSDocOutputs[i];
+            const currReturn = currReturnFields[i];
+            if (currJSDoc === currReturn)
+                continue;
+            const jsDocChanged = prevJSDocOutputs[i] !== currJSDoc;
+            const returnChanged = prevReturnFields[i] !== currReturn;
+            if (jsDocChanged && !returnChanged) {
+                const oldJSDoc = prevJSDocOutputs[i];
+                if (oldJSDoc && !currJSDocSet.has(oldJSDoc) && !prevJSDocSet.has(currJSDoc)) {
+                    result = renameFieldInReturnType(result, currReturn, currJSDoc, false);
+                }
+            }
+            else if (returnChanged && !jsDocChanged) {
+                const oldReturn = prevReturnFields[i];
+                if (oldReturn && !currReturnSet.has(oldReturn) && !prevReturnSet.has(currReturn)) {
+                    result = renamePortInJSDoc(result, currJSDoc, currReturn, "output");
+                }
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=rename.js.map

package/dist/jsdoc-port-sync/signature-parser.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @module jsdoc-port-sync/signature-parser
+ *
+ * Parse TypeScript function signatures to extract parameters and return types.
+ * Browser-compatible (regex-based, no ts-morph).
+ */
+import type { TDataType } from "../ast/types.js";
+/** Parsed function parameter */
+export interface ParsedParam {
+    name: string;
+    tsType?: string;
+    optional: boolean;
+    defaultValue?: string;
+    position: number;
+}
+/**
+ * Parse function signature to extract parameters.
+ * Supports both function declarations and arrow functions.
+ * Uses balanced paren matching to handle nested callback types.
+ */
+export declare function parseFunctionSignature(functionText: string): {
+    params: ParsedParam[];
+    functionType: "declaration" | "arrow" | "expression";
+};
+/**
+ * Parse return statement to extract object field names.
+ * Returns unique field names from all return statements.
+ */
+export declare function parseReturnFields(functionText: string): string[];
+/**
+ * Parse return body fields WITH inferred types.
+ * Analyzes `return { field: value }` statements to infer types from values.
+ *
+ * @returns Map of field name → inferred TypeScript type
+ */
+export declare function parseReturnBodyFieldsWithTypes(functionText: string): Map<string, string>;
+/**
+ * Parse return type annotation fields from function signature.
+ * Matches:
+ * - function foo(): { fieldName: type, ... }
+ * - const foo: TFlowWeaverNodeType<{...}, { fieldName: type, ... }> = ...
+ */
+export declare function parseReturnTypeFields(functionText: string): string[];
+/**
+ * Parse return type fields WITH their TypeScript types.
+ * Returns array of { name, tsType } for each field in the return type.
+ */
+export declare function parseReturnTypeFieldsWithTypes(functionText: string): Array<{
+    name: string;
+    tsType: string;
+}>;
+/**
+ * Parse input type fields from TFlowWeaverNodeType<{inputs}, {outputs}> syntax.
+ * Returns field names and their types from the first type parameter (input type).
+ */
+export declare function parseInputTypeFields(functionText: string): Array<{
+    name: string;
+    tsType: string;
+}>;
+/**
+ * Map TypeScript type to port type.
+ */
+export declare function tsTypeToPortType(tsType: string | undefined): TDataType;
+/**
+ * Map port type to TypeScript type string.
+ */
+export declare function portTypeToTsType(portType: TDataType): string;
+/**
+ * Parse callback type string to extract params and return type.
+ * E.g., "(execute: boolean, item: string) => { result: number }"
+ */
+export declare function parseCallbackType(callbackType: string): {
+    params: Array<{
+        name: string;
+        typeStr: string;
+    }>;
+    returnType: string;
+    returnFields: Array<{
+        name: string;
+        typeStr: string;
+    }>;
+};
+/**
+ * Build callback type string from scoped ports, preserving existing non-scoped params.
+ * Scoped OUTPUT ports → callback parameters
+ * Scoped INPUT ports → callback return type
+ */
+export declare function buildCallbackType(callbackParams: Array<[string, {
+    dataType: TDataType;
+    metadata?: {
+        order?: number;
+    };
+}]>, callbackReturns: Array<[string, {
+    dataType: TDataType;
+    metadata?: {
+        order?: number;
+    };
+}]>, existingCallbackType?: string): string;
+/**
+ * Check if callback signature already has all required ports.
+ * Returns true if no update needed.
+ */
+export declare function callbackHasAllPorts(callbackType: string, callbackParams: Array<[string, unknown]>, callbackReturns: Array<[string, unknown]>): boolean;
+//# sourceMappingURL=signature-parser.d.ts.map