qleaner 1.0.15 → 1.0.17

package/README.md

@@ -9,9 +9,10 @@ A powerful CLI tool to analyze and clean up your React codebase by finding unuse
 - 🎯 **File listing**: List all files in your project
 - 📊 **Table output**: Display results in formatted tables for better readability
 - ⚙️ **Flexible configuration**: Exclude directories and files from scanning
-- 🚀 **Fast performance**: Efficient file scanning across large codebases
+- 🚀 **Fast performance**: Efficient file scanning across large codebases with intelligent caching
 - 💪 **TypeScript support**: Works with TypeScript, JavaScript, JSX, and TSX files
 - 🧪 **Dry run mode**: Preview what would be deleted without actually deleting files
+- 💾 **Smart caching**: Caches scan results for faster subsequent runs (automatically invalidates on file changes)
 
 ## Installation
 
@@ -80,6 +81,7 @@ qleaner qlean-scan <path> [options]
 - `-F, --exclude-file-print <files...>` - Do not print the excluded files
 - `-t, --table` - Display results in a formatted table
 - `-d, --dry-run` - Show what would be deleted without actually deleting (skips prompt)
+- `-C, --clear-cache` - Clear the cache before scanning (use when code changes have been made)
 
 **Examples:**
 
@@ -107,6 +109,12 @@ qleaner qlean-scan src --dry-run
 
 # Dry run with table output
 qleaner qlean-scan src --dry-run --table
+
+# Clear cache and scan (recommended after making code changes)
+qleaner qlean-scan src --clear-cache
+
+# Clear cache with dry run
+qleaner qlean-scan src --clear-cache --dry-run
 ```
 
 ## Output Formats
@@ -127,11 +135,13 @@ Qleaner provides two output formats:
 ## How It Works
 
 1. **File Discovery**: Recursively finds all `.tsx`, `.ts`, `.js`, and `.jsx` files in the specified directory
-2. **Import Extraction**: Parses files using Babel AST and extracts all import statements
-3. **Module Resolution**: Uses enhanced-resolve to properly resolve import paths (supports path aliases like `@/` and `~/`)
-4. **Analysis**: Compares file paths with resolved import paths to identify unused files
-5. **Reporting**: Outputs the results in standard or table format based on your preferences
-6. **Safe Deletion**: In dry run mode, shows what would be deleted without making changes. In normal mode, prompts for confirmation before deletion
+2. **Caching**: Checks cache for previously scanned files. Files that haven't changed are skipped for faster performance
+3. **Import Extraction**: Parses files using Babel AST and extracts all import statements (only for changed files or cache misses)
+4. **Module Resolution**: Uses enhanced-resolve to properly resolve import paths (supports path aliases like `@/` and `~/`)
+5. **Analysis**: Compares file paths with resolved import paths to identify unused files
+6. **Cache Update**: Saves scan results to cache for faster subsequent runs
+7. **Reporting**: Outputs the results in standard or table format based on your preferences
+8. **Safe Deletion**: In dry run mode, shows what would be deleted without making changes. In normal mode, prompts for confirmation before deletion
 
 ## Supported File Types
 
@@ -168,11 +178,12 @@ You can exclude directories and files from scanning using the command-line optio
 
 1. **Start with a small scope**: Begin by scanning a specific directory before scanning the entire project
 2. **Use dry run first**: Always run with `--dry-run` first to preview what would be deleted before actually deleting files
-3. **Use exclusions**: Exclude test files and build outputs when scanning for unused files
-4. **Review before deleting**: Always review the unused files list before removing them - some files might be used dynamically (e.g., through dynamic imports, configuration files, or asset references)
-5. **Use table format**: The table format is easier to read for large results
-6. **Combine options**: Use multiple flags together for comprehensive analysis
-7. **Check dynamic imports**: Files imported using dynamic imports (`import()`) may appear as unused but are actually needed
+3. **Clear cache after code changes**: If you've made changes to your codebase (added/removed files, changed imports), use `--clear-cache` to ensure accurate results. The cache automatically invalidates when files change, but clearing it manually ensures a fresh scan
+4. **Use exclusions**: Exclude test files and build outputs when scanning for unused files
+5. **Review before deleting**: Always review the unused files list before removing them - some files might be used dynamically (e.g., through dynamic imports, configuration files, or asset references)
+6. **Use table format**: The table format is easier to read for large results
+7. **Combine options**: Use multiple flags together for comprehensive analysis
+8. **Check dynamic imports**: Files imported using dynamic imports (`import()`) may appear as unused but are actually needed
 
 ## Important Notes
 
@@ -184,6 +195,12 @@ You can exclude directories and files from scanning using the command-line optio
 
 💡 **Tip**: Always use `--dry-run` first to preview what would be deleted. This is especially important in CI/CD pipelines or when scanning large codebases.
 
+💾 **Cache Management**: Qleaner uses intelligent caching to speed up scans. The cache automatically detects file changes via content hashing. However, if you've made significant changes to your codebase structure or want to ensure a completely fresh scan, use `--clear-cache` before scanning. This is particularly useful:
+- After major refactoring
+- When files have been moved or renamed
+- When you want to ensure the most up-to-date results
+- In CI/CD pipelines where you want consistent, fresh scans
+
 ## Requirements
 
 - Node.js 14+ 

package/bin/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 const { Command } = require("commander");
 const { list, scan } = require("../controllers/list");
-
+const { clearCache } = require("../utils/cache");
+const { getUnusedImages } = require("../controllers/image");
 
 async function loadChalk() {
   return (await import("chalk")).default;
@@ -46,23 +47,37 @@ async function loadChalk() {
     )
     .option("-t, --table", "Print the results in a table")
     .option("-d, --dry-run", "Show what would be deleted without actually deleting (skips prompt)")
+    .option("-C, --clear-cache", "Clear the cache")
     .action(async (path, options) => {
+      if(options.clearCache) {
+        clearCache(process.cwd());
+        console.log(chalk.green('✓ Cache cleared successfully'));
+      }
       await scan(chalk, path, options);
     });
 
   program
   .command('qlean-image')
   .description("Scan the project for unused images")
-  .argument("<path>", "The path to the directory to scan for unused images")
-  .option("-e, --exclude-dir <dir...>", "Exclude directories from the scan")
-  .option("-f, --exclude-file <file...>", "Exclude files from the scan")
+  .argument("<directory>", "The path to the directory to scan for unused images")
+  .argument("<rootPath>", "The root path to the project code utilizing the images")
+  .option("-e, --exclude-dir-assets <dir...>", "Exclude directories from the scan")
+  .option("-f, --exclude-file-asset <file...>", "Exclude files from the scan")
   .option(
-    "-F, --exclude-file-print <files...>",
+    "-F, --exclude-file-print-asset <files...>",
+    "Scan but don't print the excluded files"
+  )
+  .option("-E, --exclude-dir-code <dir...>", "Exclude directories from the scan")
+  .option("-S, --exclude-file-code <file...>", "Exclude files from the scan")
+  .option(
+    "-P, --exclude-file-print-code <files...>",
     "Scan but don't print the excluded files"
   )
   .option("-t, --table", "Print the results in a table")
-  .action(async (path, options) => {
-
+  .option("-d, --dry-run", "Show what would be deleted without actually deleting (skips prompt)")
+  .option("-C, --clear-cache", "Clear the cache")
+  .action(async (directory, rootPath, options) => {
+    await getUnusedImages(ora, chalk, directory, rootPath, options);
   });
   program.parse(process.argv);
 })();

package/command.js

@@ -5,7 +5,13 @@ const parser = require("@babel/parser");
 const traverse = require("@babel/traverse").default;
 const path = require("path");
 const { createResolver } = require("./utils/resolver");
-const { loadCache, getFileHash, needsRebuild, saveCache } = require("./utils/cache");
+const {
+  loadCache,
+  getFileHash,
+  needsRebuild,
+  saveCache,
+} = require("./utils/cache");
+const { isExcludedFile, compareFiles } = require("./utils/utils");
 
 async function getFiles(directory = "src", options, chalk) {
   const contentPaths = [`${directory}/**/*.{tsx,ts,js,jsx}`];
@@ -101,7 +107,6 @@ async function getFiles(directory = "src", options, chalk) {
 }
 
 async function unUsedFiles(chalk, directory = "src", options) {
-  console.time('unUsedFiles');
   const resolver = createResolver(directory);
   const cache = loadCache(process.cwd());
   const contentPaths = [`${directory}/**/*.{tsx,ts,js,jsx}`];
@@ -117,7 +122,7 @@ async function unUsedFiles(chalk, directory = "src", options) {
   }
 
   const files = await fg(contentPaths);
-  const imports = [];
+  let imports = [];
   const unusedFiles = [];
 
   // debug log
@@ -125,7 +130,7 @@ async function unUsedFiles(chalk, directory = "src", options) {
   // console.log('total files---', files.length);
   for (const file of files) {
     const code = fs.readFileSync(file, "utf8");
-    if(needsRebuild(file, code, cache)) {
+    if (needsRebuild(file, code, cache)) {
       const ast = parser.parse(code, {
         sourceType: "module",
         plugins: ["jsx", "typescript"],
@@ -149,33 +154,32 @@ async function unUsedFiles(chalk, directory = "src", options) {
             file: file,
             line: node.loc.start.line,
             column: node.loc.start.column,
-            lastModified: fs.statSync(file).mtime.getTime(),
+            lastModified: fs.statSync(path.resolve(file)).mtime.getTime(),
           });
         },
       });
-    }else {
+    } else {
       // debugCount++;
       // console.log('cache hit', debugCount);
     }
   }
 
-  // console.log('imports', imports);
-  // console.log('files', files);
+  // imports beings empty shows all the files were cached
+  if(imports.length === 0) {
+    imports = cache[directory]? cache[directory].imports: [];
+  }
+
   // debugCount = 0;
-  // console.log('total files', files.length);
   for (const file of files) {
     const code = fs.readFileSync(file, "utf8");
-    if(!cache[file].isImported || needsRebuild(file, code, cache)) {
+    if (!cache[file].isImported || needsRebuild(file, code, cache)) {
       let i = 0;
-      // console.log('Checking', file);
       let isFound = false;
       while (!isFound && i < imports.length) {
         const importFilePath = await resolver(
-          chalk,
           imports[i].file,
           imports[i].from
         );
-        // console.log(chalk.blue('importFilePath'), importFilePath);
         if (compareFiles(path.resolve(file), importFilePath)) {
           isFound = true;
           cache[file].isImported = true;
@@ -192,23 +196,19 @@ async function unUsedFiles(chalk, directory = "src", options) {
         }
         i++;
       }
-    }else {
+    } else {
       // debugCount++;
-      // console.log('debug hit', debugCount);
+      // console.log("debug hit", debugCount);
     }
   }
-  console.timeEnd('unUsedFiles');
+  cache[directory] =  {
+    imports: imports,
+  }
   saveCache(process.cwd(), cache);
   return unusedFiles;
 }
 
-function isExcludedFile(file, excludeFiles) {
-  return excludeFiles.some((exclude) => file.includes(exclude));
-}
 
-function compareFiles(filePath, importPath) {
-  return filePath === importPath;
-}
 
 module.exports = {
   getFiles,

package/controllers/image.js

@@ -0,0 +1,191 @@
+const fg = require("fast-glob");
+const fs = require("fs");
+const parser = require("@babel/parser");
+const traverse = require("@babel/traverse").default;
+const { getCssImages } = require("../utils/cssImages");
+const path = require("path");
+const { createResolver } = require("../utils/resolver");
+const { compareFiles, isExcludedFile, askDeleteFiles } = require("../utils/utils");
+const Table = require('cli-table3');
+
+async function getUnusedImages(chalk, imageDirectory, codeDirectory, options) {
+  const usedImages = [];
+  const unusedImages = [];
+  const imageRegex = /\.(png|jpg|jpeg|svg|gif|webp)$/i;
+  const contentPaths = [`${imageDirectory}/**/*.{png,jpg,jpeg,svg,gif,webp}`];
+  if (options.excludeDirAssets && options.excludeDirAssets.length > 0) {
+    options.excludeDirAssets.forEach((dir) => {
+      contentPaths.push(`!${dir}/**`);
+    });
+  }
+  if (options.excludeFileAsset && options.excludeFileAsset.length > 0) {
+    options.excludeFileAsset.forEach((file) => {
+      contentPaths.push(`!${imageDirectory}/**/${file}`);
+    });
+  }
+
+  const rootPaths = [`${codeDirectory}/**/*.{js,jsx,ts,tsx}`];
+  if (options.excludeDirCode && options.excludeDirCode.length > 0) {
+    options.excludeDirCode.forEach((dir) => {
+      rootPaths.push(`!${dir}/**`);
+    });
+  }
+  if (options.excludeFileCode && options.excludeFileCode.length > 0) {
+    options.excludeFileCode.forEach((file) => {
+      rootPaths.push(`!${codeDirectory}/**/${file}`);
+    });
+  }
+
+  const files = await fg(contentPaths);
+  const codeFiles = await fg(rootPaths);
+
+  for (const file of codeFiles) {
+
+    const code = fs.readFileSync(file, "utf8");
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+    });
+
+    traverse(ast, {
+      // <img src="...">
+      JSXAttribute(path) {
+        if (path.node.name.name !== "src") return;
+
+        const value = path.node.value;
+
+        // String literals: `img/a.png`
+        if (value.type === "StringLiteral") {
+          if (imageRegex.test(value.value)) {
+            usedImages.push({
+              value: value.value,
+              file,
+            });
+          }
+        }
+
+        if (value.type === "JSXExpressionContainer") {
+          const expr = value.expression;
+          // String literals: `img/a.png`
+          if (expr.type === "StringLiteral" && imageRegex.test(expr.value)) {
+            usedImages.push({
+              value: expr.value,
+              file,
+            });
+          }
+
+          // Template literals: `/images/${name}.png`
+          if (expr.type === "TemplateLiteral") {
+            expr.quasis.forEach((q) => {
+              if (imageRegex.test(q.value.raw)) {
+                usedImages.push({
+                  value: q.value.raw,
+                  file,
+                });
+              }
+            });
+          }
+        }
+      },
+
+      // String literals anywhere in code
+      StringLiteral(path) {
+        if (imageRegex.test(path.node.value)) {
+          usedImages.push({
+            value: path.node.value,
+            file,
+          });
+        }
+      },
+
+      // Template literals: `/images/${name}.png`
+      TemplateLiteral(path) {
+        path.node.quasis.forEach((quasi) => {
+          if (imageRegex.test(quasi.value.raw)) {
+            usedImages.push({
+              value: quasi.value.raw,
+              file,
+            });
+          }
+        });
+      },
+
+      // Arrays: ["img/a.png", "img/b.png"]
+      ArrayExpression(path) {
+        path.node.elements.forEach((el) => {
+          if (el?.type === "StringLiteral" && imageRegex.test(el.value)) {
+            usedImages.push({
+              value: el.value,
+              file,
+            });
+          }
+        });
+      },
+
+      // Objects: { image: "img/a.png" }
+      ObjectProperty(path) {
+        const val = path.node.value;
+        if (val.type === "StringLiteral" && imageRegex.test(val.value)) {
+          usedImages.push({
+            value: val.value,
+            file,
+          });
+        }
+      },
+    });
+  }
+
+  const cssImages = await getCssImages(codeDirectory);
+  const combinedImages = [...usedImages, ...cssImages];
+
+
+  const resolver = createResolver(imageDirectory);
+
+  for (const file of files) {
+    let i = 0
+    let isFound = false;
+    while(!isFound && i < combinedImages.length) {
+        const imageFilePath = await resolver(path.resolve(combinedImages[i].file), combinedImages[i].value);
+        if(compareFiles(path.resolve(file), imageFilePath)) {
+            isFound = true;
+            break;
+        }else if(i === combinedImages.length - 1) {
+            if(options.excludeFilePrint && options.excludeFilePrint.length > 0) {
+                if(!isExcludedFile(file, options.excludeFilePrint)) {
+                    unusedImages.push(file);
+                }
+            }else{
+                unusedImages.push(file);
+            }
+        }
+        i++;
+    }
+  }
+
+  if(options.table) {
+    const table = new Table({
+      head: options.dryRun ? ['Unused Images (Would Delete)'] : ['Unused Images'],
+      colWidths: [50]
+    });
+    unusedImages.forEach(image => {
+      table.push([image]);
+    });
+    console.log(table.toString());
+  }else{
+    unusedImages.forEach(image => {
+      console.log(chalk.red(image));
+    });
+  }
+
+  if(options.dryRun && unusedImages.length > 0) {
+    console.log(chalk.cyan(`\n[DRY RUN] Would delete ${unusedImages.length} file(s)`));
+    console.log(chalk.cyan('Run without --dry-run to actually delete files\n'));
+  } else if (!options.dryRun && unusedImages.length > 0) {
+    askDeleteFiles(unusedImages);
+  }
+  return unusedImages;
+}
+
+module.exports = {
+  getUnusedImages,
+};

package/controllers/list.js

@@ -45,15 +45,6 @@ async function scan(chalk, path, options) {
     }
 }
 
-async function image(chalk, path, options) {
-    const unusedImages = await unUsedImages(chalk,path, options);
-    if(options.table){
-      console.log(chalk.yellow('***************** Unused Images *****************'));
-      console.log(unusedImages.toString());
-    }
-}
-
-
 module.exports = {
   list,
   scan

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qleaner",
   "packageManager": "yarn@4.6.0",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "main": "command.js",
   "bin": "./bin/cli.js",
   "scripts": {
@@ -20,6 +20,7 @@
     "commander": "^14.0.2",
     "enhanced-resolve": "^5.18.3",
     "fast-glob": "^3.3.3",
+    "ora": "^9.0.0",
     "prompts": "^2.4.2"
   }
 }

package/utils/cache.js

@@ -30,9 +30,17 @@ function saveCache(rootPath, cache) {
     fs.writeFileSync(file, JSON.stringify(cache, null, 2))
 }
 
+
+function clearCache(rootPath) {
+    const file = path.join(rootPath, "unused-check-cache.json");
+    if (fs.existsSync(file)) {
+        fs.unlinkSync(file);
+    }
+}
 module.exports = {
     loadCache,
     getFileHash,
     needsRebuild,
-    saveCache
+    saveCache,
+    clearCache
 }

package/{cssImages.js → utils/cssImages.js}

@@ -1,9 +1,9 @@
 const fs = require('fs');
 const fg = require('fast-glob');
+const path = require('path');
 
-function extractCssImages(cssContent) {
+function extractCssImages(cssContent, images, file) {
   const urlRegex = /url\((['"]?)(.*?)\1\)/g;
-  const images = new Set();
   let match;
 
   while ((match = urlRegex.exec(cssContent)) !== null) {
@@ -11,23 +11,28 @@ function extractCssImages(cssContent) {
 
     // Only collect image file types
     if (/\.(png|jpg|jpeg|svg|gif|webp)$/i.test(url)) {
-      images.add(url);
+      images.push({
+        value: url,
+        file: path.resolve(file),
+      });
     }
   }
-
-  return Array.from(images);
+  return images
 }
 
-async function getCssImages() {
+async function getCssImages(directory = "src") {
   const cssFiles = await fg([
-    "src/**/*.{css,scss}",
+    `${directory}/**/*.{css,scss}`,
   ]);
+  let images = [];
   for (const file of cssFiles) {
     const css = fs.readFileSync(file, "utf-8");
-    const images = extractCssImages(css);
-    console.log(images);
+    images = extractCssImages(css, images, file);
   }
+  return images;
 }
 
-getCssImages();
+module.exports = {
+  getCssImages,
+};
 

package/utils/resolver.js

@@ -16,7 +16,7 @@ const resolver = create({
     ]
   });
 
-  return function resolveImport(chalk,sourceFile, importPath) {
+  return function resolveImport(sourceFile, importPath) {
     // console.log(chalk.yellow('sourceFile--resolver'), sourceFile, chalk.yellow('importPath--resolver'), importPath);
     return new Promise((resolve, reject) => {
       resolver(path.dirname(sourceFile), importPath, (err, result) => {

package/utils/utils.js

@@ -53,4 +53,16 @@ async function deleteFiles(files) {
     console.log(`Deleted ${files.length} files`);
 }
 
-module.exports = askDeleteFiles;
+function isExcludedFile(file, excludeFiles) {
+    return excludeFiles.some((exclude) => file.includes(exclude));
+  }
+  
+  function compareFiles(filePath, importPath) {
+    return filePath === importPath;
+  }
+
+module.exports = {
+    askDeleteFiles,
+    isExcludedFile,
+    compareFiles,
+};

package/unused-check-cache.json

@@ -1,180 +0,0 @@
-{
-  "src/hello.find.tsx": {
-    "hash": "13088ef1169a758d26b7fde99ca67d5a",
-    "imports": [
-      {
-        "from": "./demo/functions",
-        "file": "src/hello.find.tsx",
-        "line": 1,
-        "column": 0,
-        "lastModified": 1764776380790
-      },
-      {
-        "from": "~/demo/book/hidden",
-        "file": "src/hello.find.tsx",
-        "line": 2,
-        "column": 0,
-        "lastModified": 1764776380790
-      }
-    ],
-    "isImported": true,
-    "lastModified": 1764776380790
-  },
-  "src/jambo.tsx": {
-    "hash": "6b9a7f99ad2bd68e567368a35bc2831c",
-    "imports": [
-      {
-        "from": "./demo/functions",
-        "file": "src/jambo.tsx",
-        "line": 1,
-        "column": 0,
-        "lastModified": 1764776380792
-      },
-      {
-        "from": "hello.find",
-        "file": "src/jambo.tsx",
-        "line": 2,
-        "column": 0,
-        "lastModified": 1764776380792
-      }
-    ],
-    "isImported": true,
-    "lastModified": 1764776380792
-  },
-  "src/main.js": {
-    "hash": "961f4425237e1551bb8ec8a136f12a66",
-    "imports": [
-      {
-        "from": "jambo",
-        "file": "src/main.js",
-        "line": 1,
-        "column": 0,
-        "lastModified": 1764776380796
-      },
-      {
-        "from": "poa",
-        "file": "src/main.js",
-        "line": 2,
-        "column": 0,
-        "lastModified": 1764776380796
-      },
-      {
-        "from": "./style.css",
-        "file": "src/main.js",
-        "line": 3,
-        "column": 0,
-        "lastModified": 1764776380796
-      },
-      {
-        "from": "./demo/demo",
-        "file": "src/main.js",
-        "line": 4,
-        "column": 0,
-        "lastModified": 1764776380796
-      },
-      {
-        "from": "./jambo",
-        "file": "src/main.js",
-        "line": 5,
-        "column": 0,
-        "lastModified": 1764776380796
-      },
-      {
-        "from": "@/demo/book/hidden",
-        "file": "src/main.js",
-        "line": 6,
-        "column": 0,
-        "lastModified": 1764776380796
-      }
-    ],
-    "isImported": true,
-    "lastModified": 1764776380796
-  },
-  "src/poa.tsx": {
-    "hash": "09d1c8072d500780c9d6b223f5609cc5",
-    "imports": [
-      {
-        "from": "one.png",
-        "file": "src/poa.tsx",
-        "line": 1,
-        "column": 0,
-        "lastModified": 1764776380809
-      }
-    ],
-    "isImported": true,
-    "lastModified": 1764776380809
-  },
-  "src/demo/demo.tsx": {
-    "hash": "fe20d628c85aad8b491b3e45e6559ce4",
-    "imports": [
-      {
-        "from": "../hello.find",
-        "file": "src/demo/demo.tsx",
-        "line": 1,
-        "column": 0,
-        "lastModified": 1764828590237
-      },
-      {
-        "from": "../demo/book/hidden",
-        "file": "src/demo/demo.tsx",
-        "line": 2,
-        "column": 0,
-        "lastModified": 1764828590237
-      }
-    ],
-    "isImported": true,
-    "lastModified": 1764828590237
-  },
-  "src/demo/functions.js": {
-    "hash": "091a10616a5be2b7c7803a3f7513453e",
-    "imports": [],
-    "isImported": true,
-    "lastModified": 1764776380788
-  },
-  "src/demo/public.tsx": {
-    "hash": "d41d8cd98f00b204e9800998ecf8427e",
-    "imports": [],
-    "isImported": false,
-    "lastModified": 1764690373726
-  },
-  "src/shell/main.js": {
-    "hash": "d41d8cd98f00b204e9800998ecf8427e",
-    "imports": [],
-    "isImported": false,
-    "lastModified": 1764822800241
-  },
-  "src/demo/book/hidden.tsx": {
-    "hash": "6c3fb783f6f246ad67252489ba9367f4",
-    "imports": [
-      {
-        "from": "../../main",
-        "file": "src/demo/book/hidden.tsx",
-        "line": 1,
-        "column": 0,
-        "lastModified": 1764776380785
-      }
-    ],
-    "isImported": true,
-    "lastModified": 1764776380785
-  },
-  "src/demo/book/public.tsx": {
-    "hash": "d41d8cd98f00b204e9800998ecf8427e",
-    "imports": [],
-    "isImported": false,
-    "lastModified": 1764690329997
-  },
-  "src/layer/shell/shell.tsx": {
-    "hash": "659029bd48113a93f0ce44bc1e8005d3",
-    "imports": [
-      {
-        "from": "../../demo/book/hidden",
-        "file": "src/layer/shell/shell.tsx",
-        "line": 1,
-        "column": 0,
-        "lastModified": 1764776380795
-      }
-    ],
-    "isImported": false,
-    "lastModified": 1764776380795
-  }
-}