@oamm/textor 1.0.8 → 1.0.10

package/dist/index.cjs

@@ -981,6 +981,66 @@ ${layoutOpening}
 </${layoutName}>
 `;
 }
+function mergeRouteTemplate(existingContent, featureImportPath, featureComponentName, layoutName) {
+    let content = existingContent;
+    // 1. Add import
+    const importLine = `import ${featureComponentName} from '${featureImportPath}';`;
+    if (!content.includes(importLine)) {
+        // Find the second --- which marks the end of frontmatter
+        const lines = content.split('\n');
+        let frontMatterEndLine = -1;
+        let dashCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trim() === '---') {
+                dashCount++;
+                if (dashCount === 2) {
+                    frontMatterEndLine = i;
+                    break;
+                }
+            }
+        }
+        if (frontMatterEndLine !== -1) {
+            lines.splice(frontMatterEndLine, 0, importLine);
+            content = lines.join('\n');
+        }
+        else if (content.includes('---')) {
+            // If only one --- found, maybe it's just the start? 
+            // But standard Astro has two. 
+            // Fallback: insert at the beginning if no frontmatter end found
+            content = importLine + '\n' + content;
+        }
+    }
+    // 2. Add component usage
+    const componentTag = `<${featureComponentName} />`;
+    if (!content.includes(componentTag)) {
+        if (layoutName && layoutName !== 'none') {
+            const layoutEndTag = `</${layoutName}>`;
+            if (content.includes(layoutEndTag)) {
+                const lines = content.split('\n');
+                let layoutEndLine = -1;
+                for (let i = lines.length - 1; i >= 0; i--) {
+                    if (lines[i].includes(layoutEndTag)) {
+                        layoutEndLine = i;
+                        break;
+                    }
+                }
+                if (layoutEndLine !== -1) {
+                    lines.splice(layoutEndLine, 0, `  ${componentTag}`);
+                    content = lines.join('\n');
+                }
+            }
+            else {
+                // Layout might be self-closing or missing end tag? 
+                // If it's Textor generated it should have it.
+                content += `\n${componentTag}\n`;
+            }
+        }
+        else {
+            content += `\n${componentTag}\n`;
+        }
+    }
+    return content;
+}
 /**
  * Feature Template Variables:
  * - componentName: Name of the feature component
@@ -1376,9 +1436,9 @@ async function addSectionToState(section) {
     if (normalizedSection.featurePath) {
         normalizedSection.featurePath = normalizeStatePath(normalizedSection.featurePath);
     }
-    // Avoid duplicates by route OR by featurePath if route is null
+    // Avoid duplicates by route AND by featurePath
     if (normalizedSection.route) {
-        state.sections = state.sections.filter(s => s.route !== normalizedSection.route);
+        state.sections = state.sections.filter(s => s.route !== normalizedSection.route || s.featurePath !== normalizedSection.featurePath);
     }
     else {
         state.sections = state.sections.filter(s => s.featurePath !== normalizedSection.featurePath || s.route);
@@ -1458,6 +1518,10 @@ function reconstructComponents(files, config) {
                         path: componentPath
                     });
                 }
+                // Attribute ownership
+                if (!files[filePath].owner) {
+                    files[filePath].owner = componentName;
+                }
             }
         }
     }
@@ -1491,25 +1555,34 @@ function reconstructSections(state, config) {
             const finalRoute = route === '' ? '/' : route;
             if (!sections.has(finalRoute)) {
                 // Try to find a matching feature by name
-                const routeName = path.basename(finalRoute === '/' ? 'index' : finalRoute);
+                const routeName = path.basename(finalRoute === '/' ? 'index' : finalRoute).toLowerCase();
                 // Look for a directory in features with same name or similar
                 const possibleFeaturePath = Object.keys(files).find(f => {
                     const nf = f.replace(/\\/g, '/');
-                    return nf.startsWith(featuresRoot + '/') && nf.includes('/' + routeName + '/');
+                    if (!nf.startsWith(featuresRoot + '/'))
+                        return false;
+                    const relToFeatures = nf.slice(featuresRoot.length + 1);
+                    const segments = relToFeatures.toLowerCase().split('/');
+                    return segments.includes(routeName);
                 });
                 if (possibleFeaturePath) {
-                    const featurePathParts = possibleFeaturePath.replace(/\\/g, '/').split('/');
-                    const featuresBase = path.basename(featuresRoot);
-                    const featureIndex = featurePathParts.indexOf(featuresBase) + 1;
-                    if (featureIndex > 0 && featureIndex < featurePathParts.length) {
-                        const featureName = featurePathParts[featureIndex];
-                        const featurePath = `${featuresRoot}/${featureName}`;
-                        sections.set(finalRoute, {
-                            name: featureName,
-                            route: finalRoute,
-                            featurePath: featurePath,
-                            extension: path.extname(filePath)
-                        });
+                    const relToFeatures = path.dirname(path.relative(featuresRoot, possibleFeaturePath)).replace(/\\/g, '/');
+                    const featurePath = relToFeatures === '.' ? featuresRoot : `${featuresRoot}/${relToFeatures}`;
+                    const featureName = path.basename(featurePath);
+                    sections.set(finalRoute, {
+                        name: featureName,
+                        route: finalRoute,
+                        featurePath: featurePath,
+                        extension: path.extname(filePath)
+                    });
+                    // Attribute ownership to discovered files
+                    if (!files[filePath].owner)
+                        files[filePath].owner = finalRoute;
+                    for (const f in files) {
+                        if (f.startsWith(featurePath + '/') || f === featurePath) {
+                            if (!files[f].owner)
+                                files[f].owner = finalRoute;
+                        }
                     }
                 }
             }
@@ -1699,8 +1772,14 @@ async function addSectionCommand(route, featurePath, options) {
             }
             await saveState(state);
         }
-        if (routeFilePath)
-            await ensureNotExists(routeFilePath, options.force);
+        if (routeFilePath) {
+            if (fs.existsSync(routeFilePath)) {
+                const isGenerated = await isTextorGenerated(routeFilePath);
+                if (!isGenerated && !options.force) {
+                    throw new Error(`File already exists: ${routeFilePath}\nUse --force to overwrite.`);
+                }
+            }
+        }
         await ensureNotExists(featureFilePath, options.force);
         if (shouldCreateIndex)
             await ensureNotExists(indexFilePath, options.force);
@@ -1789,8 +1868,30 @@ async function addSectionCommand(route, featurePath, options) {
                 routeSignature = getSignature(config, 'typescript');
             }
             else {
-                routeContent = generateRouteTemplate(layout, layoutImportPath, featureImportPath, featureComponentName, routeExtension, layoutProps);
                 routeSignature = getSignature(config, 'astro');
+                if (fs.existsSync(routeFilePath)) {
+                    const existingContent = await promises.readFile(routeFilePath, 'utf-8');
+                    // Strip existing signature if present
+                    let contentToMerge = existingContent;
+                    if (existingContent.startsWith(routeSignature)) {
+                        contentToMerge = existingContent.slice(routeSignature.length).trimStart();
+                    }
+                    else {
+                        // Check for generic signature if specific one doesn't match
+                        const genericSignature = '@generated by Textor';
+                        if (existingContent.includes(genericSignature)) {
+                            const lines = existingContent.split('\n');
+                            if (lines[0].includes(genericSignature)) {
+                                lines.shift();
+                                contentToMerge = lines.join('\n').trimStart();
+                            }
+                        }
+                    }
+                    routeContent = mergeRouteTemplate(contentToMerge, featureImportPath, featureComponentName, layout);
+                }
+                else {
+                    routeContent = generateRouteTemplate(layout, layoutImportPath, featureImportPath, featureComponentName, routeExtension, layoutProps);
+                }
             }
         }
         const featureContent = generateFeatureTemplate(featureComponentName, scriptImportPath, framework, config.naming.featureExtension);
@@ -3208,58 +3309,77 @@ async function validateStateCommand(options) {
     }
 }
 
+/**
+ * Computes the drift between the state and the actual files on disk.
+ *
+ * @param {import('./config.js').TextorConfig} config
+ * @param {Object} state
+ * @returns {Promise<{
+ *   missing: string[],
+ *   modified: string[],
+ *   untracked: string[],
+ *   orphaned: string[],
+ *   synced: number
+ * }>}
+ */
+async function getProjectStatus(config, state) {
+    const results = {
+        missing: [],
+        modified: [],
+        untracked: [], // Has signature, not in state
+        orphaned: [], // No signature, not in state
+        synced: 0
+    };
+    const roots = [
+        resolvePath(config, 'pages'),
+        resolvePath(config, 'features'),
+        resolvePath(config, 'components')
+    ].map(p => path.resolve(p));
+    const diskFiles = new Set();
+    const configSignatures = Object.values(config.signatures || {});
+    for (const root of roots) {
+        if (fs.existsSync(root)) {
+            await scanDirectory(root, diskFiles);
+        }
+    }
+    // 1. Check state files against disk
+    for (const relativePath in state.files) {
+        const fullPath = path.join(process.cwd(), relativePath);
+        if (!fs.existsSync(fullPath)) {
+            results.missing.push(relativePath);
+            continue;
+        }
+        // It exists on disk, so it's not untracked/orphaned
+        diskFiles.delete(relativePath);
+        const content = await promises.readFile(fullPath, 'utf-8');
+        const currentHash = calculateHash(content, config.hashing?.normalization);
+        const fileData = state.files[relativePath];
+        if (currentHash !== fileData.hash) {
+            results.modified.push(relativePath);
+        }
+        else {
+            results.synced++;
+        }
+    }
+    // 2. Check remaining disk files
+    for (const relativePath of diskFiles) {
+        const fullPath = path.join(process.cwd(), relativePath);
+        const isGenerated = await isTextorGenerated(fullPath, configSignatures);
+        if (isGenerated) {
+            results.untracked.push(relativePath);
+        }
+        else {
+            results.orphaned.push(relativePath);
+        }
+    }
+    return results;
+}
+
 async function statusCommand() {
     try {
         const config = await loadConfig();
         const state = await loadState();
-        const results = {
-            missing: [],
-            modified: [],
-            untracked: [], // Has signature, not in state
-            orphaned: [], // No signature, not in state
-            synced: 0
-        };
-        const roots = [
-            resolvePath(config, 'pages'),
-            resolvePath(config, 'features'),
-            resolvePath(config, 'components')
-        ].map(p => path.resolve(p));
-        const diskFiles = new Set();
-        const configSignatures = Object.values(config.signatures || {});
-        for (const root of roots) {
-            if (fs.existsSync(root)) {
-                await scanDirectory(root, diskFiles);
-            }
-        }
-        // 1. Check state files against disk
-        for (const relativePath in state.files) {
-            const fullPath = path.join(process.cwd(), relativePath);
-            if (!fs.existsSync(fullPath)) {
-                results.missing.push(relativePath);
-                continue;
-            }
-            diskFiles.delete(relativePath);
-            const content = await promises.readFile(fullPath, 'utf-8');
-            const currentHash = calculateHash(content, config.hashing?.normalization);
-            const fileData = state.files[relativePath];
-            if (currentHash !== fileData.hash) {
-                results.modified.push(relativePath);
-            }
-            else {
-                results.synced++;
-            }
-        }
-        // 2. Check remaining disk files
-        for (const relativePath of diskFiles) {
-            const fullPath = path.join(process.cwd(), relativePath);
-            const isGenerated = await isTextorGenerated(fullPath, configSignatures);
-            if (isGenerated) {
-                results.untracked.push(relativePath);
-            }
-            else {
-                results.orphaned.push(relativePath);
-            }
-        }
+        const results = await getProjectStatus(config, state);
         // Reporting
         console.log('Textor Status Report:');
         console.log(`  Synced files: ${results.synced}`);