@oamm/textor 1.0.0 → 1.0.2

package/README.md

@@ -114,10 +114,21 @@ If you have manually edited a Textor-generated file and wish to remove or move i
 ## 🛠️ Commands
 
 ### add-section
-Create a route + feature binding.
+Create a route + feature binding, or a standalone feature.
 
 ```bash
-pnpm textor add-section <route> <featurePath> [options]
+pnpm textor add-section [route] <featurePath> [options]
+```
+
+If `route` is provided, Textor creates both a route adapter (e.g., in `src/pages`) and a feature module. If `route` is omitted, Textor scaffolds only the feature module. This is useful for features that are shared across multiple pages or used as sub-parts of other features.
+
+**Examples:**
+```bash
+# Create a section with a route
+pnpm textor add-section /users users/catalog
+
+# Create a standalone feature (no route file)
+pnpm textor add-section auth/login
 ```
 
 **Options:**
@@ -149,6 +160,14 @@ pnpm textor move-section /old /new
 ### remove-section / remove-component
 Safely remove Textor-managed modules.
 
+```bash
+# Remove by route
+pnpm textor remove-section /users
+
+# Remove a standalone feature by its name or path
+pnpm textor remove-section auth/login
+```
+
 ### list-sections
 List all Textor-managed modules, including their architectural capabilities (API, Hooks, etc.).
 

package/dist/bin/textor.js

@@ -415,6 +415,7 @@ function normalizeComponentName(name) {
 }
 
 function normalizeRoute(route) {
+  if (!route) return null;
   let normalized = route.trim();
   
   if (!normalized.startsWith('/')) {
@@ -1394,8 +1395,12 @@ 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);
 }
@@ -1535,6 +1540,14 @@ 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);
@@ -1549,7 +1562,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'
@@ -1560,11 +1573,11 @@ async function addSectionCommand(route, featurePath, options) {
       }
     }
 
-    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, {
@@ -1572,7 +1585,7 @@ async function addSectionCommand(route, featurePath, options) {
       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);
@@ -1612,10 +1625,10 @@ async function addSectionCommand(route, featurePath, options) {
     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('/');
@@ -1650,7 +1663,7 @@ 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) {
@@ -1695,7 +1708,7 @@ 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);
@@ -1711,7 +1724,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`;
       } else {
@@ -1720,16 +1733,22 @@ async function addSectionCommand(route, featurePath, options) {
       }
     }
 
-    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;
@@ -1740,35 +1759,40 @@ 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);
     
@@ -1992,7 +2016,7 @@ async function addSectionCommand(route, featurePath, options) {
     }
 
     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}`);
@@ -2358,11 +2382,12 @@ 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}'`
+            `import ${fromFeatureComponentName} from '${oldAliasPath}/${fromFeatureComponentName}${ext}'`, 
+            `import ${toFeatureComponentName} from '${newAliasPath}/${toFeatureComponentName}${ext}'`
           );
           
           // Fallback for prefix only replacement
@@ -2370,17 +2395,19 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
         } else if (fromFeatureComponentName !== toFeatureComponentName) {
           // Name changed but path didn't
           const aliasPath = `${config.importAliases.features}/${targetFeature}`;
+          const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
           await updateSignature(toRoutePath,
-            `import ${fromFeatureComponentName} from '${aliasPath}/${fromFeatureComponentName}'`,
-            `import ${toFeatureComponentName} from '${aliasPath}/${toFeatureComponentName}'`
+            `import ${fromFeatureComponentName} from '${aliasPath}/${fromFeatureComponentName}${ext}'`,
+            `import ${toFeatureComponentName} from '${aliasPath}/${toFeatureComponentName}${ext}'`
           );
         }
       } else {
         const oldRelativeDir = getRelativeImportPath(fromRoutePath, fromFeatureDirPath);
         const newRelativeDir = getRelativeImportPath(toRoutePath, toFeatureDirPath);
+        const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
         
-        const oldImportPath = `import ${fromFeatureComponentName} from '${oldRelativeDir}/${fromFeatureComponentName}'`;
-        const newImportPath = `import ${toFeatureComponentName} from '${newRelativeDir}/${toFeatureComponentName}'`;
+        const oldImportPath = `import ${fromFeatureComponentName} from '${oldRelativeDir}/${fromFeatureComponentName}${ext}'`;
+        const newImportPath = `import ${toFeatureComponentName} from '${newRelativeDir}/${toFeatureComponentName}${ext}'`;
         
         if (oldImportPath !== newImportPath) {
           await updateSignature(toRoutePath, oldImportPath, newImportPath);
@@ -2470,14 +2497,16 @@ async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
     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);
@@ -2495,8 +2524,8 @@ async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
       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);
@@ -3710,8 +3739,8 @@ program
   .action(initCommand);
 
 program
-  .command('add-section <route> <featurePath>')
-  .description('Create a route + feature binding')
+  .command('add-section [route] [featurePath]')
+  .description('Create a route + feature binding (route optional for standalone features)')
   .option('--preset <name>', 'Scaffolding preset (minimal, standard, senior)')
   .option('--layout <name>', 'Layout component name (use "none" for no layout)', 'Main')
   .option('--name <name>', 'Section name for state tracking')

package/dist/bin/textor.js.map

@@ -1 +1 @@
-{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.cjs

@@ -384,6 +384,8 @@ function normalizeComponentName(name) {
     return toPascalCase(name);
 }
 function normalizeRoute(route) {
+    if (!route)
+        return null;
     let normalized = route.trim();
     if (!normalized.startsWith('/')) {
         normalized = '/' + normalized;
@@ -1228,8 +1230,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);
 }
@@ -1351,6 +1358,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);
@@ -1361,7 +1374,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'
@@ -1371,17 +1384,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);
@@ -1404,9 +1417,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('/');
@@ -1437,7 +1450,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}`);
@@ -1485,7 +1499,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);
@@ -1510,7 +1525,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`;
             }
@@ -1519,17 +1534,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) {
@@ -1537,23 +1559,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);
@@ -1708,7 +1735,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}`);
@@ -2029,22 +2057,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);
                 }
@@ -2117,13 +2148,14 @@ async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
             continue;
         let content = await promises.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;
@@ -2140,8 +2172,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;