@oamm/textor 1.0.0 → 1.0.2

package/dist/index.js

@@ -382,6 +382,8 @@ function normalizeComponentName(name) {
     return toPascalCase(name);
 }
 function normalizeRoute(route) {
+    if (!route)
+        return null;
     let normalized = route.trim();
     if (!normalized.startsWith('/')) {
         normalized = '/' + normalized;
@@ -1226,8 +1228,13 @@ async function registerFile(filePath, { kind, template, hash, templateVersion =
 }
 async function addSectionToState(section) {
     const state = await loadState();
-    // Avoid duplicates by route
-    state.sections = state.sections.filter(s => s.route !== section.route);
+    // Avoid duplicates by route OR by featurePath if route is null
+    if (section.route) {
+        state.sections = state.sections.filter(s => s.route !== section.route);
+    }
+    else {
+        state.sections = state.sections.filter(s => s.featurePath !== section.featurePath || s.route);
+    }
     state.sections.push(section);
     await saveState(state);
 }
@@ -1349,6 +1356,12 @@ async function stageFiles(filePaths) {
 async function addSectionCommand(route, featurePath, options) {
     try {
         const config = await loadConfig();
+        // Handle optional route
+        if (typeof featurePath === 'object' || featurePath === undefined) {
+            options = featurePath || options || {};
+            featurePath = route;
+            route = null;
+        }
         const effectiveOptions = getEffectiveOptions(options, config, 'features');
         const normalizedRoute = normalizeRoute(route);
         const normalizedFeaturePath = featureToDirectoryPath(featurePath);
@@ -1359,7 +1372,7 @@ async function addSectionCommand(route, featurePath, options) {
         // Check if we should use nested mode even if config says flat
         // (because the directory already exists, suggesting it should be an index file)
         let effectiveRoutingMode = config.routing.mode;
-        if (effectiveRoutingMode === 'flat') {
+        if (normalizedRoute && effectiveRoutingMode === 'flat') {
             const routeDirName = routeToFilePath(normalizedRoute, {
                 extension: '',
                 mode: 'flat'
@@ -1369,17 +1382,17 @@ async function addSectionCommand(route, featurePath, options) {
                 effectiveRoutingMode = 'nested';
             }
         }
-        const routeFileName = routeToFilePath(normalizedRoute, {
+        const routeFileName = normalizedRoute ? routeToFilePath(normalizedRoute, {
             extension: routeExtension,
             mode: effectiveRoutingMode,
             indexFile: config.routing.indexFile
-        });
+        }) : null;
         const featureComponentName = getFeatureComponentName(normalizedFeaturePath);
         const featureFileName = getFeatureFileName(normalizedFeaturePath, {
             extension: config.naming.featureExtension,
             strategy: effectiveOptions.entry
         });
-        const routeFilePath = secureJoin(pagesRoot, routeFileName);
+        const routeFilePath = routeFileName ? secureJoin(pagesRoot, routeFileName) : null;
         const featureDirPath = secureJoin(featuresRoot, normalizedFeaturePath);
         const featureFilePath = secureJoin(featureDirPath, featureFileName);
         const scriptsIndexPath = secureJoin(featureDirPath, config.features.scriptsIndexFile);
@@ -1402,9 +1415,9 @@ async function addSectionCommand(route, featurePath, options) {
         const schemasFilePath = path.join(schemasDirInside, 'index.ts');
         const readmeFilePath = path.join(featureDirPath, 'README.md');
         const storiesFilePath = path.join(featureDirPath, `${featureComponentName}.stories.tsx`);
-        const routeParts = normalizedRoute.split('/').filter(Boolean);
+        const routeParts = normalizedRoute ? normalizedRoute.split('/').filter(Boolean) : [];
         const reorganizations = [];
-        if (routeParts.length > 1 && config.routing.mode === 'flat') {
+        if (normalizedRoute && routeParts.length > 1 && config.routing.mode === 'flat') {
             const possibleExtensions = ['.astro', '.ts', '.js', '.md', '.mdx', '.html'];
             for (let i = 1; i < routeParts.length; i++) {
                 const parentRoute = '/' + routeParts.slice(0, i).join('/');
@@ -1435,7 +1448,8 @@ async function addSectionCommand(route, featurePath, options) {
         }
         if (options.dryRun) {
             console.log('Dry run - would create:');
-            console.log(`  Route: ${routeFilePath}`);
+            if (routeFilePath)
+                console.log(`  Route: ${routeFilePath}`);
             console.log(`  Feature: ${featureFilePath}`);
             for (const reorg of reorganizations) {
                 console.log(`  Reorganize: ${reorg.from} -> ${reorg.to}`);
@@ -1483,7 +1497,8 @@ async function addSectionCommand(route, featurePath, options) {
             }
             await saveState(state);
         }
-        await ensureNotExists(routeFilePath, options.force);
+        if (routeFilePath)
+            await ensureNotExists(routeFilePath, options.force);
         await ensureNotExists(featureFilePath, options.force);
         if (shouldCreateIndex)
             await ensureNotExists(indexFilePath, options.force);
@@ -1508,7 +1523,7 @@ async function addSectionCommand(route, featurePath, options) {
         if (shouldCreateScriptsDir)
             await ensureNotExists(scriptsIndexPath, options.force);
         let layoutImportPath = null;
-        if (options.layout !== 'none') {
+        if (routeFilePath && options.layout !== 'none') {
             if (config.importAliases.layouts) {
                 layoutImportPath = `${config.importAliases.layouts}/${options.layout}.astro`;
             }
@@ -1517,17 +1532,24 @@ async function addSectionCommand(route, featurePath, options) {
                 layoutImportPath = getRelativeImportPath(routeFilePath, layoutFilePath);
             }
         }
-        let featureImportPath;
-        if (config.importAliases.features) {
-            const entryPart = effectiveOptions.entry === 'index' ? '' : `/${featureComponentName}`;
-            // In Astro, we can often omit the extension for .tsx files, but not for .astro files if using aliases sometimes.
-            // However, to be safe, we use the configured extension.
-            featureImportPath = `${config.importAliases.features}/${normalizedFeaturePath}${entryPart}${config.naming.featureExtension}`;
-        }
-        else {
-            const relativeFeatureFile = getRelativeImportPath(routeFilePath, featureFilePath);
-            // Remove extension for import
-            featureImportPath = relativeFeatureFile.replace(/\.[^/.]+$/, '');
+        let featureImportPath = null;
+        if (routeFilePath) {
+            if (config.importAliases.features) {
+                const entryPart = effectiveOptions.entry === 'index' ? '' : `/${featureComponentName}`;
+                // In Astro, we can often omit the extension for .tsx files, but not for .astro files if using aliases sometimes.
+                // However, to be safe, we use the configured extension.
+                featureImportPath = `${config.importAliases.features}/${normalizedFeaturePath}${entryPart}${config.naming.featureExtension}`;
+            }
+            else {
+                const relativeFeatureFile = getRelativeImportPath(routeFilePath, featureFilePath);
+                // Remove extension for import if it's not an .astro file
+                if (config.naming.featureExtension === '.astro') {
+                    featureImportPath = relativeFeatureFile;
+                }
+                else {
+                    featureImportPath = relativeFeatureFile.replace(/\.[^/.]+$/, '');
+                }
+            }
         }
         let scriptImportPath;
         if (shouldCreateScriptsDir) {
@@ -1535,23 +1557,28 @@ async function addSectionCommand(route, featurePath, options) {
         }
         let routeContent;
         let routeSignature;
-        if (options.endpoint) {
-            routeContent = generateEndpointTemplate(featureComponentName);
-            routeSignature = getSignature(config, 'typescript');
-        }
-        else {
-            routeContent = generateRouteTemplate(options.layout, layoutImportPath, featureImportPath, featureComponentName);
-            routeSignature = getSignature(config, 'astro');
+        if (routeFilePath) {
+            if (options.endpoint) {
+                routeContent = generateEndpointTemplate(featureComponentName);
+                routeSignature = getSignature(config, 'typescript');
+            }
+            else {
+                routeContent = generateRouteTemplate(options.layout, layoutImportPath, featureImportPath, featureComponentName);
+                routeSignature = getSignature(config, 'astro');
+            }
         }
         const featureContent = generateFeatureTemplate(featureComponentName, scriptImportPath, framework);
-        const routeHash = await writeFileWithSignature(routeFilePath, routeContent, routeSignature, config.hashing?.normalization);
-        await registerFile(routeFilePath, {
-            kind: 'route',
-            template: options.endpoint ? 'endpoint' : 'route',
-            hash: routeHash,
-            owner: normalizedRoute
-        });
-        const writtenFiles = [routeFilePath];
+        const writtenFiles = [];
+        if (routeFilePath) {
+            const routeHash = await writeFileWithSignature(routeFilePath, routeContent, routeSignature, config.hashing?.normalization);
+            await registerFile(routeFilePath, {
+                kind: 'route',
+                template: options.endpoint ? 'endpoint' : 'route',
+                hash: routeHash,
+                owner: normalizedRoute
+            });
+            writtenFiles.push(routeFilePath);
+        }
         await ensureDir(featureDirPath);
         if (shouldCreateSubComponentsDir)
             await ensureDir(subComponentsDir);
@@ -1706,7 +1733,8 @@ async function addSectionCommand(route, featurePath, options) {
             await formatFiles(writtenFiles, config.formatting.tool);
         }
         console.log('✓ Section created successfully:');
-        console.log(`  Route: ${routeFilePath}`);
+        if (routeFilePath)
+            console.log(`  Route: ${routeFilePath}`);
         console.log(`  Feature: ${featureFilePath}`);
         if (shouldCreateIndex)
             console.log(`  Index: ${indexFilePath}`);
@@ -2027,22 +2055,25 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
                 if (normalizedFromFeature !== targetFeature) {
                     const oldAliasPath = `${config.importAliases.features}/${normalizedFromFeature}`;
                     const newAliasPath = `${config.importAliases.features}/${targetFeature}`;
+                    const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
                     // Replace both the path and the component name if they are different
-                    await updateSignature(toRoutePath, `import ${fromFeatureComponentName} from '${oldAliasPath}/${fromFeatureComponentName}'`, `import ${toFeatureComponentName} from '${newAliasPath}/${toFeatureComponentName}'`);
+                    await updateSignature(toRoutePath, `import ${fromFeatureComponentName} from '${oldAliasPath}/${fromFeatureComponentName}${ext}'`, `import ${toFeatureComponentName} from '${newAliasPath}/${toFeatureComponentName}${ext}'`);
                     // Fallback for prefix only replacement
                     await updateSignature(toRoutePath, oldAliasPath, newAliasPath);
                 }
                 else if (fromFeatureComponentName !== toFeatureComponentName) {
                     // Name changed but path didn't
                     const aliasPath = `${config.importAliases.features}/${targetFeature}`;
-                    await updateSignature(toRoutePath, `import ${fromFeatureComponentName} from '${aliasPath}/${fromFeatureComponentName}'`, `import ${toFeatureComponentName} from '${aliasPath}/${toFeatureComponentName}'`);
+                    const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
+                    await updateSignature(toRoutePath, `import ${fromFeatureComponentName} from '${aliasPath}/${fromFeatureComponentName}${ext}'`, `import ${toFeatureComponentName} from '${aliasPath}/${toFeatureComponentName}${ext}'`);
                 }
             }
             else {
                 const oldRelativeDir = getRelativeImportPath(fromRoutePath, fromFeatureDirPath);
                 const newRelativeDir = getRelativeImportPath(toRoutePath, toFeatureDirPath);
-                const oldImportPath = `import ${fromFeatureComponentName} from '${oldRelativeDir}/${fromFeatureComponentName}'`;
-                const newImportPath = `import ${toFeatureComponentName} from '${newRelativeDir}/${toFeatureComponentName}'`;
+                const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
+                const oldImportPath = `import ${fromFeatureComponentName} from '${oldRelativeDir}/${fromFeatureComponentName}${ext}'`;
+                const newImportPath = `import ${toFeatureComponentName} from '${newRelativeDir}/${toFeatureComponentName}${ext}'`;
                 if (oldImportPath !== newImportPath) {
                     await updateSignature(toRoutePath, oldImportPath, newImportPath);
                 }
@@ -2115,13 +2146,14 @@ async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
             continue;
         let content = await readFile(fullPath, 'utf-8');
         let changed = false;
+        const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
         // Handle Aliases
         if (config.importAliases.features) {
             const oldAlias = `${config.importAliases.features}/${fromFeaturePath}`;
             const newAlias = `${config.importAliases.features}/${toFeaturePath}`;
             // Update component name and path if both changed
-            const oldFullImport = `from '${oldAlias}/${fromComponentName}'`;
-            const newFullImport = `from '${newAlias}/${toComponentName}'`;
+            const oldFullImport = `from '${oldAlias}/${fromComponentName}${ext}'`;
+            const newFullImport = `from '${newAlias}/${toComponentName}${ext}'`;
             if (content.includes(oldFullImport)) {
                 content = content.replace(new RegExp(oldFullImport.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newFullImport);
                 changed = true;
@@ -2138,8 +2170,8 @@ async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
             const toFeatureDir = secureJoin(featuresRoot, toFeaturePath);
             const oldRelPath = getRelativeImportPath(fullPath, fromFeatureDir);
             const newRelPath = getRelativeImportPath(fullPath, toFeatureDir);
-            const oldImport = `'${oldRelPath}/${fromComponentName}'`;
-            const newImport = `'${newRelPath}/${toComponentName}'`;
+            const oldImport = `'${oldRelPath}/${fromComponentName}${ext}'`;
+            const newImport = `'${newRelPath}/${toComponentName}${ext}'`;
             if (content.includes(oldImport)) {
                 content = content.replace(new RegExp(oldImport.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newImport);
                 changed = true;