@oamm/textor 1.0.5 → 1.0.8

package/dist/index.cjs

@@ -35,10 +35,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
@@ -103,7 +106,9 @@ const DEFAULT_CONFIG = {
         createTypes: false,
         createReadme: false,
         createStories: false,
-        createIndex: false
+        createIndex: false,
+        layout: 'Main',
+        layoutProps: {}
     },
     components: {
         framework: 'react',
@@ -873,27 +878,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;
@@ -955,13 +939,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;
@@ -973,12 +959,24 @@ import ${featureComponentName} from '${featureImportPath}';
 <${featureComponentName} />
 `;
     }
+    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}>
 `;
@@ -1177,6 +1175,10 @@ 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';
 `;
@@ -1590,7 +1592,7 @@ async function addSectionCommand(route, featurePath, options) {
         const apiDirInside = secureJoin(featureDirPath, 'api');
         const servicesDirInside = secureJoin(featureDirPath, 'services');
         const schemasDirInside = secureJoin(featureDirPath, 'schemas');
-        const { framework, createSubComponentsDir: shouldCreateSubComponentsDir, createScriptsDir: shouldCreateScriptsDir, createApi: shouldCreateApi, createServices: shouldCreateServices, createSchemas: shouldCreateSchemas, createHooks: shouldCreateHooks, createContext: shouldCreateContext, createTests: shouldCreateTests, createTypes: shouldCreateTypes, createReadme: shouldCreateReadme, createStories: shouldCreateStories, createIndex: shouldCreateIndex } = effectiveOptions;
+        const { framework, layout, layoutProps: configLayoutProps, createSubComponentsDir: shouldCreateSubComponentsDir, createScriptsDir: shouldCreateScriptsDir, createApi: shouldCreateApi, createServices: shouldCreateServices, createSchemas: shouldCreateSchemas, createHooks: shouldCreateHooks, createContext: shouldCreateContext, createTests: shouldCreateTests, createTypes: shouldCreateTypes, createReadme: shouldCreateReadme, createStories: shouldCreateStories, createIndex: shouldCreateIndex } = effectiveOptions;
         const featurePatterns = config.filePatterns?.features || {};
         const patternData = {
             componentName: featureComponentName,
@@ -1687,7 +1689,12 @@ async function addSectionCommand(route, featurePath, options) {
                     delete state.files[oldRelative];
                 }
                 // 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 promises.readFile(reorg.to, 'utf-8');
+                    state.files[newRelative].hash = calculateHash(content, config.hashing?.normalization);
+                }
                 console.log(`✓ Reorganized ${oldRelative} to ${newRelative}`);
             }
             await saveState(state);
@@ -1718,19 +1725,43 @@ 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);
             }
         }
         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}`;
@@ -1758,7 +1789,7 @@ async function addSectionCommand(route, featurePath, options) {
                 routeSignature = getSignature(config, 'typescript');
             }
             else {
-                routeContent = generateRouteTemplate(options.layout, layoutImportPath, featureImportPath, featureComponentName, routeExtension);
+                routeContent = generateRouteTemplate(layout, layoutImportPath, featureImportPath, featureComponentName, routeExtension, layoutProps);
                 routeSignature = getSignature(config, 'astro');
             }
         }
@@ -1959,7 +1990,7 @@ async function addSectionCommand(route, featurePath, options) {
             name: options.name || featureComponentName,
             route: normalizedRoute,
             featurePath: normalizedFeaturePath,
-            layout: options.layout,
+            layout: layout,
             extension: routeExtension
         });
         if (config.git?.stageChanges) {
@@ -1974,7 +2005,7 @@ async function addSectionCommand(route, featurePath, options) {
         throw error;
     }
 }
-async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+async function updateImportsInFile$2(filePath, oldFilePath, newFilePath) {
     if (!fs.existsSync(filePath))
         return;
     let content = await promises.readFile(filePath, 'utf-8');
@@ -2009,29 +2040,37 @@ async function removeSectionCommand(route, featurePath, options) {
             throw new Error('Git repository is not clean. Please commit or stash your changes before proceeding.');
         }
         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');
-        const routeFilePath = secureJoin(pagesRoot, routeFileName);
+        // 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 featureDirPath = secureJoin(featuresRoot, normalizedFeaturePath);
         const deletedFiles = [];
         const skippedFiles = [];
@@ -2106,9 +2145,58 @@ 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 (fs.existsSync(parentDirPath)) {
+                            const filesInDir = await promises.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 (!fs.existsSync(flatFilePath)) {
+                                            await promises.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 promises.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);
         }
@@ -2121,6 +2209,33 @@ async function removeSectionCommand(route, featurePath, options) {
         throw error;
     }
 }
+async function updateImportsInFile$1(filePath, oldFilePath, newFilePath) {
+    if (!fs.existsSync(filePath))
+        return;
+    let content = await promises.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 promises.writeFile(filePath, content, 'utf-8');
+}
 
 /**
  * Move a section (route + feature).
@@ -2239,40 +2354,58 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
             const toFeatureDirPath = secureJoin(featuresRoot, targetFeature);
             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 promises.readFile(toRoutePath, 'utf-8');
+            let changed = false;
+            // Update component name in JSX tags
             if (fromFeatureComponentName !== toFeatureComponentName) {
-                let content = await promises.readFile(toRoutePath, 'utf-8');
                 content = content.replace(new RegExp(`<${fromFeatureComponentName}`, 'g'), `<${toFeatureComponentName}`);
                 content = content.replace(new RegExp(`</${fromFeatureComponentName}`, 'g'), `</${toFeatureComponentName}`);
-                await promises.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);
+                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 (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}'`);
+                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}'`;
-                if (oldImportPath !== newImportPath) {
-                    await updateSignature(toRoutePath, oldImportPath, newImportPath);
+                // Flexible regex for relative imports
+                const relImportRegex = new RegExp(`(import\\s+)(${fromFeatureComponentName})(\\s+from\\s+['"])${oldRelativeDir}(/[^'"]+)?(['"])`, 'g');
+                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 promises.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) {
             const fromFeaturePath = secureJoin(featuresRoot, normalizedFromFeature);
@@ -2331,7 +2464,6 @@ async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
     const { fromFeaturePath, fromComponentName } = fromInfo;
     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');
     for (const relPath of allFiles) {
@@ -2446,7 +2578,6 @@ async function moveDirectory(fromPath, toPath, state, config, options = {}) {
                 if (hasChanged) {
                     await promises.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, '/');
                     if (fileState) {
@@ -2478,6 +2609,33 @@ async function moveDirectory(fromPath, toPath, state, config, options = {}) {
         await promises.rmdir(fromPath);
     }
 }
+async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+    if (!fs.existsSync(filePath))
+        return;
+    let content = await promises.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 promises.writeFile(filePath, content, 'utf-8');
+}
 
 async function createComponentCommand(componentName, options) {
     try {
@@ -2814,9 +2972,14 @@ async function removeComponentCommand(identifier, options) {
             normalization: config.hashing?.normalization,
             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, '/');
             const dirPrefix = relComponentPath + '/';