@postxl/generator 1.4.0 → 1.4.1

package/dist/utils/custom-blocks.d.ts

@@ -65,6 +65,8 @@ export type CustomBlock = {
     anchorBefore: string[];
     /** Anchor context: non-empty lines after the block for positioning */
     anchorAfter: string[];
+    /** Name of the enclosing class member/method where this block was extracted */
+    enclosingMemberName?: string;
 };
 /**
  * Result of extracting custom blocks from source code

package/dist/utils/custom-blocks.js

@@ -119,14 +119,17 @@ function processEndMarker(line, lineIndex, endMatch, currentBlock, lines, blocks
     // Capture anchor context
     const anchorBefore = captureAnchorContext(lines, currentBlock.startLineIndex, 'before');
     const anchorAfter = captureAnchorContext(lines, lineIndex, 'after');
-    blocks.push({
+    const enclosingMemberName = findEnclosingMemberName(lines, currentBlock.startLineIndex);
+    const block = {
         name: currentBlock.name,
         lines: currentBlock.lines,
         startLineIndex: currentBlock.startLineIndex,
         endLineIndex: lineIndex,
         anchorBefore,
         anchorAfter,
-    });
+        ...(enclosingMemberName ? { enclosingMemberName } : {}),
+    };
+    blocks.push(block);
     return null;
 }
 /**
@@ -246,6 +249,147 @@ function isSignificantLine(line) {
 function normalizeAnchorLine(line) {
     return line.trim();
 }
+const METHOD_SIGNATURE_PATTERN = /^\s*(?:public|private|protected|static|readonly|async|\s)*([A-Za-z_$][\w$]*)\s*(?:<[^>{}]*>)?\s*\(/;
+const NON_MEMBER_KEYWORDS = new Set([
+    'if',
+    'for',
+    'while',
+    'switch',
+    'do',
+    'return',
+    'const',
+    'let',
+    'var',
+    'new',
+    'class',
+    'function',
+    'typeof',
+    'instanceof',
+]);
+function findMemberNameInLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) {
+        return undefined;
+    }
+    const signatureMatch = METHOD_SIGNATURE_PATTERN.exec(line);
+    if (!signatureMatch) {
+        return undefined;
+    }
+    const memberName = signatureMatch[1];
+    if (!memberName || NON_MEMBER_KEYWORDS.has(memberName)) {
+        return undefined;
+    }
+    return memberName;
+}
+function findEnclosingMemberName(lines, blockStartLineIndex) {
+    for (let i = blockStartLineIndex - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (line === undefined) {
+            continue;
+        }
+        const memberName = findMemberNameInLine(line);
+        if (memberName) {
+            return memberName;
+        }
+    }
+    return undefined;
+}
+function inferMemberNameFromBlockName(blockName) {
+    if (!blockName) {
+        return undefined;
+    }
+    const separatorMatch = /[_-]([A-Za-z_$][\w$]*)$/.exec(blockName);
+    if (!separatorMatch) {
+        return undefined;
+    }
+    return separatorMatch[1];
+}
+function countChar(line, char) {
+    let count = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let inTemplate = false;
+    let isEscaped = false;
+    for (const lineChar of line) {
+        if (isEscaped) {
+            isEscaped = false;
+            continue;
+        }
+        if (lineChar === '\\') {
+            isEscaped = true;
+            continue;
+        }
+        if (!inDoubleQuote && !inTemplate && lineChar === "'") {
+            inSingleQuote = !inSingleQuote;
+            continue;
+        }
+        if (!inSingleQuote && !inTemplate && lineChar === '"') {
+            inDoubleQuote = !inDoubleQuote;
+            continue;
+        }
+        if (!inSingleQuote && !inDoubleQuote && lineChar === '`') {
+            inTemplate = !inTemplate;
+            continue;
+        }
+        if (inSingleQuote || inDoubleQuote || inTemplate) {
+            continue;
+        }
+        if (lineChar === char) {
+            count++;
+        }
+    }
+    return count;
+}
+function findMemberRange(targetLines, memberName) {
+    for (let i = 0; i < targetLines.length; i++) {
+        const line = targetLines[i];
+        if (line === undefined) {
+            continue;
+        }
+        if (findMemberNameInLine(line) !== memberName) {
+            continue;
+        }
+        let j = i;
+        let foundOpeningBrace = line.includes('{');
+        while (!foundOpeningBrace && j + 1 < targetLines.length) {
+            j++;
+            const continuationLine = targetLines[j];
+            if (continuationLine?.includes('{')) {
+                foundOpeningBrace = true;
+            }
+            if (continuationLine?.trim().endsWith(';')) {
+                break;
+            }
+        }
+        if (!foundOpeningBrace) {
+            continue;
+        }
+        let braceDepth = 0;
+        for (let k = i; k < targetLines.length; k++) {
+            const memberLine = targetLines[k];
+            if (memberLine === undefined) {
+                continue;
+            }
+            braceDepth += countChar(memberLine, '{');
+            braceDepth -= countChar(memberLine, '}');
+            if (braceDepth === 0 && k > i) {
+                return { start: i, end: k + 1 };
+            }
+        }
+    }
+    return null;
+}
+function findInsertionPositionByAnchors(block, targetLines) {
+    const beforePosition = findAnchorSequence(block.anchorBefore, targetLines, 'before');
+    if (beforePosition !== null) {
+        return beforePosition + 1;
+    }
+    const afterPosition = findAnchorSequence(block.anchorAfter, targetLines, 'after');
+    if (afterPosition !== null) {
+        return afterPosition;
+    }
+    return findSingleAnchorMatch(block, targetLines);
+}
 /**
  * Finds the best position to insert a custom block in the target content
  * based on anchor context matching.
@@ -255,24 +399,21 @@ function normalizeAnchorLine(line) {
  * @returns The line index where the block should be inserted, or null if no good position found
  */
 function findInsertionPosition(block, targetLines) {
-    // Strategy 1: Try to find a match using "before" anchors
-    // We look for the anchor sequence and insert after the last matched anchor
-    const beforePosition = findAnchorSequence(block.anchorBefore, targetLines, 'before');
-    if (beforePosition !== null) {
-        return beforePosition + 1; // Insert after the anchor
-    }
-    // Strategy 2: Try to find a match using "after" anchors
-    // We look for the anchor sequence and insert before the first matched anchor
-    const afterPosition = findAnchorSequence(block.anchorAfter, targetLines, 'after');
-    if (afterPosition !== null) {
-        return afterPosition; // Insert before the anchor
-    }
-    // Strategy 3: Try to find any single anchor match
-    const singleAnchor = findSingleAnchorMatch(block, targetLines);
-    if (singleAnchor !== null) {
-        return singleAnchor;
+    const candidateMemberNames = [
+        ...new Set([block.enclosingMemberName, inferMemberNameFromBlockName(block.name)].filter((name) => Boolean(name))),
+    ];
+    for (const memberName of candidateMemberNames) {
+        const range = findMemberRange(targetLines, memberName);
+        if (!range) {
+            continue;
+        }
+        const scopedLines = targetLines.slice(range.start, range.end);
+        const scopedPosition = findInsertionPositionByAnchors(block, scopedLines);
+        if (scopedPosition !== null) {
+            return range.start + scopedPosition;
+        }
     }
-    return null;
+    return findInsertionPositionByAnchors(block, targetLines);
 }
 /**
  * Finds a sequence of anchor lines in the target content

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Core package that orchestrates the code generation of a PXL project",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -46,7 +46,7 @@
     "jszip": "3.10.1",
     "minimatch": "^10.2.2",
     "p-limit": "3.1.0",
-    "@postxl/schema": "^1.9.0",
+    "@postxl/schema": "^1.10.1",
     "@postxl/utils": "^1.4.0"
   },
   "devDependencies": {