@oamm/textor 1.0.5 → 1.0.8

package/README.md

@@ -341,6 +341,8 @@ The .textor/config.json file allows full control over the tool's behavior.
     "indexFile": "index.astro"
   },
   "importAliases": {
+    "layouts": "@/layouts",
+    "features": "@/features"
   },
   "naming": {
     "routeExtension": ".astro",
@@ -370,7 +372,8 @@ The .textor/config.json file allows full control over the tool's behavior.
     "createTypes": false,
     "createReadme": false,
     "createStories": false,
-    "createIndex": false
+    "createIndex": false,
+    "layout": "Main"
   },
   "components": {
     "framework": "react",
@@ -458,6 +461,31 @@ The .textor/config.json file allows full control over the tool's behavior.
 ```
 *Supported formatting tools: prettier, biome, none.*
 
+### 7. Layout Parameters
+
+You can pass parameters to your layout component by defining `layoutProps` in `.textor/config.json`. These props support variable substitution.
+
+```json
+{
+  "features": {
+    "layout": "AppLayout",
+    "layoutProps": {
+      "title": "{{componentName}}",
+      "description": "Description for {{componentName}}"
+    }
+  }
+}
+```
+
+You can also override these props via the CLI using the `--prop` flag:
+```bash
+pnpm textor add-section /users users/roles --prop title="Custom Title" --prop breadcrumbs='{[{ label: "Users" }]}'
+```
+
+Properties that start and end with curly braces `{}` are passed as JavaScript expressions, others as strings.
+
+---
+
 ## 📝 Template Overrides
 
 You can customize the code generated by Textor by providing your own templates. Textor looks for override files in the `.textor/templates/` directory at your project root.
@@ -472,7 +500,7 @@ You can customize the code generated by Textor by providing your own templates.
 
 | Template Name | File to create in `.textor/templates/` | Available Variables |
 | :--- | :--- | :--- |
-| **Route** | `route.astro` | `{{layoutName}}`, `{{layoutImportPath}}`, `{{featureImportPath}}`, `{{featureComponentName}}` |
+| **Route** | `route.astro` | `{{layoutName}}`, `{{layoutImportPath}}`, `{{featureImportPath}}`, `{{featureComponentName}}`, plus any `layoutProps` |
 | **Feature** | `feature.astro` or `feature.tsx` | `{{componentName}}`, `{{scriptImportPath}}` |
 | **Component** | `component.astro` or `component.tsx` | `{{componentName}}` |
 | **Hook** | `hook.ts` | `{{componentName}}`, `{{hookName}}` |

package/dist/bin/textor.js

@@ -36,10 +36,13 @@ const CURRENT_CONFIG_VERSION = 2;
  * @property {string} signatures.typescript
  * @property {string} signatures.javascript
  * @property {Object} features
+ * @property {string} features.framework
  * @property {string} features.entry
  * @property {boolean} features.createSubComponentsDir
  * @property {boolean} features.createScriptsDir
  * @property {string} features.scriptsIndexFile
+ * @property {string} features.layout
+ * @property {Object} features.layoutProps
  * @property {Object} components
  * @property {boolean} components.createSubComponentsDir
  * @property {boolean} components.createContext
@@ -105,7 +108,9 @@ const DEFAULT_CONFIG = {
     createTypes: false,
     createReadme: false,
     createStories: false,
-    createIndex: false
+    createIndex: false,
+    layout: 'Main',
+    layoutProps: {}
   },
   components: {
     framework: 'react',
@@ -1017,27 +1022,6 @@ async function formatFiles(filePaths, tool) {
     }
 }
 
-var filesystem = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  calculateHash: calculateHash,
-  cleanupEmptyDirs: cleanupEmptyDirs,
-  ensureDir: ensureDir,
-  ensureNotExists: ensureNotExists,
-  formatFiles: formatFiles,
-  getSignature: getSignature,
-  inferKind: inferKind,
-  isEmptyDir: isEmptyDir,
-  isTextorGenerated: isTextorGenerated,
-  safeDelete: safeDelete,
-  safeDeleteDir: safeDeleteDir,
-  safeMove: safeMove,
-  scanDirectory: scanDirectory,
-  secureJoin: secureJoin,
-  updateSignature: updateSignature,
-  verifyFileIntegrity: verifyFileIntegrity,
-  writeFileWithSignature: writeFileWithSignature
-});
-
 function renderNamePattern(pattern, data = {}, label = 'pattern') {
   if (typeof pattern !== 'string') return null;
   const trimmed = pattern.trim();
@@ -1105,13 +1089,15 @@ function getTemplateOverride(templateName, extension, data = {}) {
  * - layoutImportPath: Path to import the layout
  * - featureImportPath: Path to import the feature component
  * - featureComponentName: Name of the feature component
+ * - layoutProps: Optional properties for the layout
  */
-function generateRouteTemplate(layoutName, layoutImportPath, featureImportPath, featureComponentName, extension = '.astro') {
+function generateRouteTemplate(layoutName, layoutImportPath, featureImportPath, featureComponentName, extension = '.astro', layoutProps = {}) {
   const override = getTemplateOverride('route', extension, {
     layoutName,
     layoutImportPath,
     featureImportPath,
-    featureComponentName
+    featureComponentName,
+    ...layoutProps
   });
   if (override) return override;
 
@@ -1124,12 +1110,26 @@ import ${featureComponentName} from '${featureImportPath}';
 `;
   }
 
+  const propsStr = Object.entries(layoutProps)
+    .map(([key, value]) => {
+      if (typeof value === 'string' && value.startsWith('{') && value.endsWith('}')) {
+        return `${key}=${value}`;
+      }
+      if (typeof value === 'string') {
+        return `${key}="${value}"`;
+      }
+      return `${key}={${JSON.stringify(value)}}`;
+    })
+    .join(' ');
+
+  const layoutOpening = propsStr ? `<${layoutName} ${propsStr}>` : `<${layoutName}>`;
+
   return `---
 import ${layoutName} from '${layoutImportPath}';
 import ${featureComponentName} from '${featureImportPath}';
 ---
 
-<${layoutName}>
+${layoutOpening}
   <${featureComponentName} />
 </${layoutName}>
 `;
@@ -1340,6 +1340,11 @@ function generateIndexTemplate(componentName, componentExtension) {
   const override = getTemplateOverride('index', '.ts', { componentName, componentExtension });
   if (override) return override;
 
+  if (componentExtension === '.astro') {
+    return `export * from './types';
+`;
+  }
+
   return `export { default as ${componentName} } from './${componentName}${componentExtension}';
 export * from './types';
 `;
@@ -1794,6 +1799,8 @@ async function addSectionCommand(route, featurePath, options) {
     
     const {
       framework,
+      layout,
+      layoutProps: configLayoutProps,
       createSubComponentsDir: shouldCreateSubComponentsDir,
       createScriptsDir: shouldCreateScriptsDir,
       createApi: shouldCreateApi,
@@ -1965,7 +1972,13 @@ async function addSectionCommand(route, featurePath, options) {
         }
 
         // Update imports in the moved file
-        await updateImportsInFile(reorg.to, reorg.from, reorg.to);
+        await updateImportsInFile$2(reorg.to, reorg.from, reorg.to);
+        
+        // Update hash in state after import updates
+        if (state.files[newRelative]) {
+          const content = await readFile(reorg.to, 'utf-8');
+          state.files[newRelative].hash = calculateHash(content, config.hashing?.normalization);
+        }
         
         console.log(`✓ Reorganized ${oldRelative} to ${newRelative}`);
       }
@@ -1988,11 +2001,37 @@ async function addSectionCommand(route, featurePath, options) {
     if (shouldCreateScriptsDir) await ensureNotExists(scriptsIndexPath, options.force);
     
     let layoutImportPath = null;
-    if (routeFilePath && options.layout !== 'none') {
+    const cliProps = options.prop || {};
+    const rawLayoutProps = { ...configLayoutProps, ...cliProps };
+    const layoutProps = {};
+    
+    // Resolve variables in layoutProps
+    const substitutionData = enrichData({
+        componentName: featureComponentName,
+        layoutName: layout,
+        featureComponentName: featureComponentName
+    });
+
+    for (const [key, value] of Object.entries(rawLayoutProps)) {
+        if (typeof value === 'string') {
+            let resolvedValue = value;
+            for (const [varKey, varValue] of Object.entries(substitutionData)) {
+                const regex = new RegExp(`{{${varKey}}}`, 'g');
+                resolvedValue = resolvedValue.replace(regex, varValue);
+                const underscoreRegex = new RegExp(`__${varKey}__`, 'g');
+                resolvedValue = resolvedValue.replace(underscoreRegex, varValue);
+            }
+            layoutProps[key] = resolvedValue;
+        } else {
+            layoutProps[key] = value;
+        }
+    }
+
+    if (routeFilePath && layout !== 'none') {
       if (config.importAliases.layouts) {
-        layoutImportPath = `${config.importAliases.layouts}/${options.layout}.astro`;
+        layoutImportPath = `${config.importAliases.layouts}/${layout}.astro`;
       } else {
-        const layoutFilePath = secureJoin(layoutsRoot, `${options.layout}.astro`);
+        const layoutFilePath = secureJoin(layoutsRoot, `${layout}.astro`);
         layoutImportPath = getRelativeImportPath(routeFilePath, layoutFilePath);
       }
     }
@@ -2000,7 +2039,7 @@ async function addSectionCommand(route, featurePath, options) {
     let featureImportPath = null;
     if (routeFilePath) {
       if (config.importAliases.features) {
-        const entryPart = effectiveOptions.entry === 'index' ? '' : `/${featureComponentName}`;
+        const entryPart = effectiveOptions.entry === 'index' ? '/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}`;
@@ -2029,11 +2068,12 @@ async function addSectionCommand(route, featurePath, options) {
         routeSignature = getSignature(config, 'typescript');
       } else {
         routeContent = generateRouteTemplate(
-          options.layout,
+          layout,
           layoutImportPath,
           featureImportPath,
           featureComponentName,
-          routeExtension
+          routeExtension,
+          layoutProps
         );
         routeSignature = getSignature(config, 'astro');
       }
@@ -2301,7 +2341,7 @@ async function addSectionCommand(route, featurePath, options) {
       name: options.name || featureComponentName,
       route: normalizedRoute,
       featurePath: normalizedFeaturePath,
-      layout: options.layout,
+      layout: layout,
       extension: routeExtension
     });
 
@@ -2318,7 +2358,7 @@ async function addSectionCommand(route, featurePath, options) {
   }
 }
 
-async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+async function updateImportsInFile$2(filePath, oldFilePath, newFilePath) {
   if (!existsSync(filePath)) return;
   
   let content = await readFile(filePath, 'utf-8');
@@ -2361,33 +2401,43 @@ async function removeSectionCommand(route, featurePath, options) {
 
     const state = await loadState();
     
-    let targetRoute = route;
-    let targetFeaturePath = featurePath;
     let section = findSection(state, route);
+    if (!section && featurePath) {
+      section = findSection(state, featurePath);
+    }
+
+    const targetRoute = section ? section.route : route;
+    const targetFeaturePath = section ? section.featurePath : featurePath;
 
     if (!targetFeaturePath) {
-      if (section) {
-        targetRoute = section.route;
-        targetFeaturePath = section.featurePath;
-      } else {
-        throw new Error(`Section not found for identifier: ${route}. Please provide both route and featurePath.`);
-      }
+      throw new Error(`Section not found for identifier: ${route}. Please provide both route and featurePath.`);
     }
     
     const normalizedRoute = normalizeRoute(targetRoute);
     const normalizedFeaturePath = featureToDirectoryPath(targetFeaturePath);
     
-    const routeExtension = (section && section.extension) || config.naming.routeExtension;
-    const routeFileName = routeToFilePath(normalizedRoute, {
-      extension: routeExtension,
-      mode: config.routing.mode,
-      indexFile: config.routing.indexFile
-    });
-    
     const pagesRoot = resolvePath(config, 'pages');
     const featuresRoot = resolvePath(config, 'features');
+
+    // Find route file in state if possible
+    let routeFilePath = null;
+    const routeRelPath = Object.keys(state.files).find(f => {
+      const data = state.files[f];
+      return data.kind === 'route' && data.owner === normalizedRoute;
+    });
+
+    if (routeRelPath) {
+      routeFilePath = path.resolve(process.cwd(), routeRelPath);
+    } else {
+      const routeExtension = (section && section.extension) || config.naming.routeExtension;
+      const routeFileName = routeToFilePath(normalizedRoute, {
+        extension: routeExtension,
+        mode: config.routing.mode,
+        indexFile: config.routing.indexFile
+      });
+      routeFilePath = secureJoin(pagesRoot, routeFileName);
+    }
     
-    const routeFilePath = secureJoin(pagesRoot, routeFileName);
     const featureDirPath = secureJoin(featuresRoot, normalizedFeaturePath);
     
     const deletedFiles = [];
@@ -2474,8 +2524,67 @@ async function removeSectionCommand(route, featurePath, options) {
     }
     
     if (deletedFiles.length === 0 && deletedDirs.length === 0 && skippedFiles.length === 0) {
-      console.log('No files to delete.');
+      if (section) {
+        console.log(`✓ Section ${normalizedRoute} removed from state (files were already missing on disk).`);
+        state.sections = state.sections.filter(s => s.route !== normalizedRoute);
+        await saveState(state);
+      } else {
+        console.log('No files to delete.');
+      }
     } else {
+      // Reorganization (Flattening)
+      if (!options.keepRoute && deletedFiles.length > 0 && config.routing.mode === 'flat') {
+        const routeParts = normalizedRoute.split('/').filter(Boolean);
+        if (routeParts.length > 1) {
+          for (let i = routeParts.length - 1; i >= 1; i--) {
+            const parentRoute = '/' + routeParts.slice(0, i).join('/');
+            const parentDirName = routeParts.slice(0, i).join('/');
+            const parentDirPath = secureJoin(pagesRoot, parentDirName);
+            
+            if (existsSync(parentDirPath)) {
+              const filesInDir = await readdir(parentDirPath);
+              
+              if (filesInDir.length === 1) {
+                const loneFile = filesInDir[0];
+                const ext = path.extname(loneFile);
+                const indexFile = ext === '.astro' ? config.routing.indexFile : `index${ext}`;
+                
+                if (loneFile === indexFile) {
+                  const loneFilePath = path.join(parentDirPath, loneFile);
+                  const oldRelative = path.relative(process.cwd(), loneFilePath).replace(/\\/g, '/');
+
+                  if (state.files[oldRelative] && state.files[oldRelative].kind === 'route') {
+                    const flatFileName = routeToFilePath(parentRoute, {
+                      extension: ext,
+                      mode: 'flat'
+                    });
+                    const flatFilePath = secureJoin(pagesRoot, flatFileName);
+                      
+                    if (!existsSync(flatFilePath)) {
+                      await rename(loneFilePath, flatFilePath);
+                        
+                      const newRelative = path.relative(process.cwd(), flatFilePath).replace(/\\/g, '/');
+                        
+                      state.files[newRelative] = { ...state.files[oldRelative] };
+                      delete state.files[oldRelative];
+                        
+                      await updateImportsInFile$1(flatFilePath, loneFilePath, flatFilePath);
+
+                      // Update hash in state after import updates
+                      const content = await readFile(flatFilePath, 'utf-8');
+                      state.files[newRelative].hash = calculateHash(content, config.hashing?.normalization);
+
+                      console.log(`✓ Reorganized ${oldRelative} to ${newRelative} (flattened)`);
+                      await cleanupEmptyDirs(parentDirPath, pagesRoot);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
       state.sections = state.sections.filter(s => s.route !== normalizedRoute);
       await saveState(state);
     }
@@ -2489,6 +2598,39 @@ async function removeSectionCommand(route, featurePath, options) {
   }
 }
 
+async function updateImportsInFile$1(filePath, oldFilePath, newFilePath) {
+  if (!existsSync(filePath)) return;
+  
+  let content = await readFile(filePath, 'utf-8');
+  const oldDir = path.dirname(oldFilePath);
+  const newDir = path.dirname(newFilePath);
+  
+  if (oldDir === newDir) return;
+  
+  // Find all relative imports
+  const relativeImportRegex = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
+  let match;
+  const replacements = [];
+  
+  while ((match = relativeImportRegex.exec(content)) !== null) {
+    const relativePath = match[1];
+    const absoluteTarget = path.resolve(oldDir, relativePath);
+    const newRelativePath = getRelativeImportPath(newFilePath, absoluteTarget);
+    
+    replacements.push({
+      full: match[0],
+      oldRel: relativePath,
+      newRel: newRelativePath
+    });
+  }
+  
+  for (const repl of replacements) {
+    content = content.replace(repl.full, `from '${repl.newRel}'`);
+  }
+  
+  await writeFile(filePath, content, 'utf-8');
+}
+
 /**
  * Move a section (route + feature).
  * 
@@ -2629,9 +2771,14 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
       const fromFeatureComponentName = getFeatureComponentName(normalizedFromFeature);
       const toFeatureComponentName = getFeatureComponentName(targetFeature);
 
-      // Update component name in JSX
+      // First, update all relative imports in the file because it moved
+      await updateImportsInFile(toRoutePath, fromRoutePath, toRoutePath);
+
+      let content = await readFile(toRoutePath, 'utf-8');
+      let changed = false;
+
+      // Update component name in JSX tags
       if (fromFeatureComponentName !== toFeatureComponentName) {
-        let content = await readFile(toRoutePath, 'utf-8');
         content = content.replace(
           new RegExp(`<${fromFeatureComponentName}`, 'g'),
           `<${toFeatureComponentName}`
@@ -2640,44 +2787,54 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
           new RegExp(`</${fromFeatureComponentName}`, 'g'),
           `</${toFeatureComponentName}`
         );
-        await writeFile(toRoutePath, content, 'utf-8');
+        changed = true;
       }
 
       if (config.importAliases.features) {
-        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}${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}`;
-          const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
-          await updateSignature(toRoutePath,
-            `import ${fromFeatureComponentName} from '${aliasPath}/${fromFeatureComponentName}${ext}'`,
-            `import ${toFeatureComponentName} from '${aliasPath}/${toFeatureComponentName}${ext}'`
-          );
+        const oldAliasPath = `${config.importAliases.features}/${normalizedFromFeature}`;
+        const newAliasPath = `${config.importAliases.features}/${targetFeature}`;
+        
+        // Flexible regex to match import identifier and path with alias
+        const importRegex = new RegExp(`(import\\s+)(${fromFeatureComponentName})(\\s+from\\s+['"])${oldAliasPath}(/[^'"]+)?(['"])`, 'g');
+        
+        if (importRegex.test(content)) {
+          content = content.replace(importRegex, (match, p1, p2, p3, subPath, p5) => {
+            let newSubPath = subPath || '';
+            if (subPath && subPath.includes(fromFeatureComponentName)) {
+              newSubPath = subPath.replace(fromFeatureComponentName, toFeatureComponentName);
+            }
+            return `${p1}${toFeatureComponentName}${p3}${newAliasPath}${newSubPath}${p5}`;
+          });
+          changed = true;
+        } else if (content.includes(oldAliasPath)) {
+          // Fallback for path only replacement
+          content = content.replace(new RegExp(oldAliasPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newAliasPath);
+          changed = true;
         }
       } else {
-        const oldRelativeDir = getRelativeImportPath(fromRoutePath, fromFeatureDirPath);
+        const oldRelativeDir = getRelativeImportPath(toRoutePath, fromFeatureDirPath);
         const newRelativeDir = getRelativeImportPath(toRoutePath, toFeatureDirPath);
-        const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
         
-        const oldImportPath = `import ${fromFeatureComponentName} from '${oldRelativeDir}/${fromFeatureComponentName}${ext}'`;
-        const newImportPath = `import ${toFeatureComponentName} from '${newRelativeDir}/${toFeatureComponentName}${ext}'`;
+        // Flexible regex for relative imports
+        const relImportRegex = new RegExp(`(import\\s+)(${fromFeatureComponentName})(\\s+from\\s+['"])${oldRelativeDir}(/[^'"]+)?(['"])`, 'g');
         
-        if (oldImportPath !== newImportPath) {
-          await updateSignature(toRoutePath, oldImportPath, newImportPath);
+        if (relImportRegex.test(content)) {
+          content = content.replace(relImportRegex, (match, p1, p2, p3, subPath, p5) => {
+            let newSubPath = subPath || '';
+            if (subPath && subPath.includes(fromFeatureComponentName)) {
+              newSubPath = subPath.replace(fromFeatureComponentName, toFeatureComponentName);
+            }
+            return `${p1}${toFeatureComponentName}${p3}${newRelativeDir}${newSubPath}${p5}`;
+          });
+          changed = true;
         }
       }
+
+      if (changed) {
+        await writeFile(toRoutePath, content, 'utf-8');
+        // Update hash in state after changes
+        state.files[normalizedToRouteRelative].hash = calculateHash(content, config.hashing?.normalization);
+      }
     }
     
     if (!isRouteOnly && normalizedFromFeature && normalizedToFeature && normalizedFromFeature !== normalizedToFeature) {
@@ -2748,7 +2905,6 @@ async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
   const { toFeaturePath, toComponentName } = toInfo;
   
   const allFiles = new Set();
-  const { scanDirectory, calculateHash } = await Promise.resolve().then(function () { return filesystem; });
   await scanDirectory(process.cwd(), allFiles);
   
   const featuresRoot = resolvePath(config, 'features');
@@ -2889,7 +3045,6 @@ async function moveDirectory(fromPath, toPath, state, config, options = {}) {
         if (hasChanged) {
            await writeFile(toEntryPath, content, 'utf-8');
            // Re-calculate hash after content update
-           const { calculateHash } = await Promise.resolve().then(function () { return filesystem; });
            const updatedHash = calculateHash(content, config.hashing?.normalization);
            
            const normalizedToRelative = path.relative(process.cwd(), toEntryPath).replace(/\\/g, '/');
@@ -2922,6 +3077,39 @@ async function moveDirectory(fromPath, toPath, state, config, options = {}) {
   }
 }
 
+async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+  if (!existsSync(filePath)) return;
+  
+  let content = await readFile(filePath, 'utf-8');
+  const oldDir = path.dirname(oldFilePath);
+  const newDir = path.dirname(newFilePath);
+  
+  if (oldDir === newDir) return;
+  
+  // Find all relative imports
+  const relativeImportRegex = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
+  let match;
+  const replacements = [];
+  
+  while ((match = relativeImportRegex.exec(content)) !== null) {
+    const relativePath = match[1];
+    const absoluteTarget = path.resolve(oldDir, relativePath);
+    const newRelativePath = getRelativeImportPath(newFilePath, absoluteTarget);
+    
+    replacements.push({
+      full: match[0],
+      oldRel: relativePath,
+      newRel: newRelativePath
+    });
+  }
+  
+  for (const repl of replacements) {
+    content = content.replace(repl.full, `from '${repl.newRel}'`);
+  }
+  
+  await writeFile(filePath, content, 'utf-8');
+}
+
 async function createComponentCommand(componentName, options) {
   try {
     const config = await loadConfig();
@@ -3402,9 +3590,13 @@ async function removeComponentCommand(identifier, options) {
       owner: identifier
     });
     
-    if (result.deleted) {
-      console.log(`✓ Deleted component: ${componentDir}/`);
-      await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
+    if (result.deleted || (result.reason === 'not-found' && component)) {
+      if (result.deleted) {
+        console.log(`✓ Deleted component: ${componentDir}/`);
+        await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
+      } else {
+        console.log(`✓ Component ${identifier} removed from state (directory was already missing on disk).`);
+      }
       
       // Unregister files
       const relComponentPath = path.relative(process.cwd(), componentDir).replace(/\\/g, '/');
@@ -4155,7 +4347,7 @@ program
   .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('--layout <name>', 'Layout component name (use "none" for no layout)')
   .option('--name <name>', 'Section name for state tracking')
   .option('--endpoint', 'Create an API endpoint (.ts) instead of an Astro page')
   .option('--api', 'Create api directory')
@@ -4170,6 +4362,11 @@ program
   .option('--index', 'Create index.ts')
   .option('--no-sub-components-dir', 'Skip creating sub-components directory')
   .option('--no-scripts-dir', 'Skip creating scripts directory')
+  .option('--prop <key=value>', 'Layout property', (val, memo) => {
+    const [key, ...rest] = val.split('=');
+    memo[key] = rest.join('=');
+    return memo;
+  }, {})
   .option('--dry-run', 'Show what would be created without creating')
   .option('--force', 'Overwrite existing files')
   .action(addSectionCommand);

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}