Use vscode workspace fs API

estruyf · estruyf · commit 0368de894829 · 2024-07-03T10:35:14.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,7 @@
 
 ## [2.8.0] 03-07-2024
 
+- Updates to use the `vscode.workspace.fs` API
 - [#13](https://github.com/estruyf/vscode-typescript-exportallmodules/issues/13) [#14](https://github.com/estruyf/vscode-typescript-exportallmodules/issues/14): Added support for named exports (thanks to [Mike Rheault](https://github.com/mrheault))
 
 ## [2.7.0] 11-09-2023
diff --git a/src/commands/ExportAll.ts b/src/commands/ExportAll.ts
@@ -1,69 +1,56 @@
 import * as vscode from "vscode";
-import * as path from "path";
-import * as fs from "fs";
 import {
-  CONFIG_EXCLUDE,
-  CONFIG_INCLUDE_FOLDERS,
-  CONFIG_RELATIVE_EXCLUDE,
-  CONFIG_SEMIS,
-  CONFIG_QUOTE,
   EXTENSION_NAME,
-  CONFIG_MESSAGE,
   EXTENSION_KEY,
   CONFIG_FOLDERS,
-  CONFIG_NAMED_EXPORTS,
+  BarrelFiles,
 } from "../constants";
 import {
   clearWildcard,
+  fileExists,
   getAbsoluteFolderPath,
   getFileContents,
   getRelativeFolderPath,
   parseFileForNamedExports,
   parseWinPath,
+  writeFile,
 } from "../helpers";
 import { Logger } from "../helpers/logger";
-
-interface FileOrFolderToExport {
-  name: string;
-  type: "file" | "folder";
-}
+import { join, parse } from "path";
+import { getConfig } from "../helpers/getConfig";
+import { FileOrFolderToExport } from "../models";
 
 export class ExportAll {
-  public static barrelFiles = ["index.ts", "index.tsx"];
-
   public static async start(crntUri: vscode.Uri, runSilent: boolean = true) {
     const uri = vscode.Uri.file(clearWildcard(parseWinPath(crntUri.fsPath)));
 
     try {
-      const config = vscode.workspace.getConfiguration(EXTENSION_KEY);
-      const excludeFiles: string | undefined = config.get(CONFIG_EXCLUDE);
-      const excludeRel: string | undefined = config.get(
-        CONFIG_RELATIVE_EXCLUDE
-      );
-      const includeFolders: boolean | undefined = config.get(
-        CONFIG_INCLUDE_FOLDERS
-      );
-      const namedExports: boolean | undefined = config.get(CONFIG_NAMED_EXPORTS);
-      const semis: boolean | undefined = config.get(CONFIG_SEMIS);
-      const quote: '"' | "'" = config.get(CONFIG_QUOTE) ?? "'";
-      const message: string | string[] | undefined = config.get<
-        string | string[]
-      >(CONFIG_MESSAGE);
+      const {
+        excludeFiles,
+        excludeRel,
+        includeFolders,
+        message,
+        namedExports,
+        quote,
+        semis,
+      } = getConfig();
 
       const folderPath = uri.fsPath;
-      const files = fs.readdirSync(folderPath);
+      const files = await vscode.workspace.fs.readDirectory(
+        vscode.Uri.parse(folderPath)
+      );
       let filesToExport: FileOrFolderToExport[] = [];
 
       if (files && files.length > 0) {
-        for (const file of files) {
-          const absPath = path.join(folderPath, file);
+        for (const [file] of files) {
+          const absPath = join(folderPath, file);
           let include = false;
           let relPath = file;
 
           // Include all TS files except for the index
           if (
             (file.endsWith(".ts") || file.endsWith(".tsx")) &&
-            this.barrelFiles.indexOf(file.toLowerCase()) === -1
+            BarrelFiles.indexOf(file.toLowerCase()) === -1
           ) {
             relPath = getRelativeFolderPath(absPath);
             include = true;
@@ -72,10 +59,13 @@ export class ExportAll {
           // Check if folders should be included
           if (includeFolders) {
             // Only allow folder which contain an index file
-            if (fs.lstatSync(absPath).isDirectory()) {
-              for (const indexFile of this.barrelFiles) {
-                const indexPath = path.join(absPath, indexFile);
-                if (fs.existsSync(indexPath)) {
+            const stat = await vscode.workspace.fs.stat(
+              vscode.Uri.file(absPath)
+            );
+            if (stat.type === vscode.FileType.Directory) {
+              for (const indexFile of BarrelFiles) {
+                const indexPath = join(absPath, indexFile);
+                if (await fileExists(indexPath)) {
                   relPath = getRelativeFolderPath(absPath);
                   include = true;
                   break;
@@ -114,9 +104,13 @@ export class ExportAll {
           // Add the file/folder to the array
           if (include) {
             try {
+              const stat = await vscode.workspace.fs.stat(
+                vscode.Uri.file(absPath)
+              );
               filesToExport.push({
                 name: file,
-                type: fs.statSync(absPath).isDirectory() ? "folder" : "file",
+                type:
+                  stat.type === vscode.FileType.Directory ? "folder" : "file",
               });
             } catch (ex) {
               // Ignore
@@ -127,33 +121,45 @@ export class ExportAll {
 
       // Check if there are still files after the filter
       if (filesToExport && filesToExport.length > 0) {
-        let output = filesToExport.map((item) => {
+        const output: string[] = [];
+
+        for (const item of filesToExport) {
           const fileWithoutExtension =
-            item.type === "folder" ? item.name : path.parse(item.name).name;
+            item.type === "folder" ? item.name : parse(item.name).name;
           if (namedExports) {
-            const filePath = path.join(uri.fsPath, item.name);
-            const fileContents = getFileContents(filePath);
-            const { namedExports, typeExports } = parseFileForNamedExports(fileContents);
+            const filePath = join(uri.fsPath, item.name);
+            const fileContents = await getFileContents(filePath);
+            const { namedExports, typeExports } = parseFileForNamedExports(
+              fileContents || ""
+            );
 
-            const namedExportsStr = namedExports.filter(Boolean).join(', ');
-            const typeExportsStr = typeExports.filter(Boolean).join(', ');
-            let exportStr = '';
+            const namedExportsStr = namedExports.filter(Boolean).join(", ");
+            const typeExportsStr = typeExports.filter(Boolean).join(", ");
+            let exportStr = "";
             if (namedExportsStr) {
-              exportStr += `export { ${namedExportsStr} } from ${quote}./${fileWithoutExtension}${quote}${semis ? ";" : ""}\n`;
+              exportStr += `export { ${namedExportsStr} } from ${quote}./${fileWithoutExtension}${quote}${
+                semis ? ";" : ""
+              }\n`;
             }
             if (typeExportsStr) {
-              exportStr += `export type { ${typeExportsStr} } from ${quote}./${fileWithoutExtension}${quote}${semis ? ";" : ""}\n`;
+              exportStr += `export type { ${typeExportsStr} } from ${quote}./${fileWithoutExtension}${quote}${
+                semis ? ";" : ""
+              }\n`;
             }
-            return exportStr;
+            output.push(exportStr);
           } else {
-            return `export * from ${quote}./${fileWithoutExtension}${quote}${semis ? ";" : ""}\n`;
+            output.push(
+              `export * from ${quote}./${fileWithoutExtension}${quote}${
+                semis ? ";" : ""
+              }\n`
+            );
           }
-        });
+        }
 
         if (output && output.length > 0) {
-          const filePath = path.join(uri.fsPath, "index.ts");
-          if (!fs.existsSync(filePath)) {
-            fs.writeFileSync(filePath, "");
+          const filePath = join(uri.fsPath, "index.ts");
+          if (!(await fileExists(filePath))) {
+            await writeFile(filePath, "");
           }
 
           const fileUri = vscode.Uri.file(filePath);
@@ -220,11 +226,10 @@ export class ExportAll {
         }
       }
     } catch (e) {
-      console.error((e as Error).message);
-
       Logger.error(
         `Sorry, something failed when exporting all modules in ${uri.fsPath}`
       );
+      Logger.error((e as Error).message);
       vscode.window.showErrorMessage(
         `${EXTENSION_NAME}: Sorry, something failed when exporting all modules in the current folder.`
       );
diff --git a/src/constants/BarrelFiles.ts b/src/constants/BarrelFiles.ts
@@ -0,0 +1 @@
+export const BarrelFiles = ["index.ts", "index.tsx"];
diff --git a/src/constants/index.ts b/src/constants/index.ts
@@ -1 +1,2 @@
-export * from './Extension';
+export * from "./BarrelFiles";
+export * from "./Extension";
diff --git a/src/extension.ts b/src/extension.ts
@@ -1,6 +1,5 @@
 import * as vscode from "vscode";
-import { ExportAll } from "./commands/ExportAll";
-import { FolderListener, ExcludeCommand } from "./commands";
+import { FolderListener, ExcludeCommand, ExportAll } from "./commands";
 import { ExportProvider, ExportFolder } from "./providers";
 import {
   EXTENSION_KEY,
@@ -10,14 +9,6 @@ import {
 } from "./constants";
 import { Logger } from "./helpers/logger";
 
-/**
- * TODO:
- * - add the excluded files & folders to the view
- * - add exclude file command
- * - add exclude folder command
- * - documentation
- * @param context
- */
 export function activate(context: vscode.ExtensionContext) {
   const generate = vscode.commands.registerCommand(
     getCommandName(COMMAND_KEYS.Generate),
diff --git a/src/helpers/fileExists.ts b/src/helpers/fileExists.ts
@@ -0,0 +1,10 @@
+import { Uri, workspace } from "vscode";
+
+export const fileExists = async (filePath: string): Promise<boolean> => {
+  try {
+    await workspace.fs.stat(Uri.file(filePath));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
diff --git a/src/helpers/getConfig.ts b/src/helpers/getConfig.ts
@@ -0,0 +1,37 @@
+import { workspace } from "vscode";
+import {
+  CONFIG_EXCLUDE,
+  CONFIG_INCLUDE_FOLDERS,
+  CONFIG_MESSAGE,
+  CONFIG_NAMED_EXPORTS,
+  CONFIG_QUOTE,
+  CONFIG_RELATIVE_EXCLUDE,
+  CONFIG_SEMIS,
+  EXTENSION_KEY,
+} from "../constants";
+import { Config } from "../models";
+
+export const getConfig = (): Config => {
+  const config = workspace.getConfiguration(EXTENSION_KEY);
+  const excludeFiles: string | undefined = config.get(CONFIG_EXCLUDE);
+  const excludeRel: string | undefined = config.get(CONFIG_RELATIVE_EXCLUDE);
+  const includeFolders: boolean | undefined = config.get(
+    CONFIG_INCLUDE_FOLDERS
+  );
+  const namedExports: boolean | undefined = config.get(CONFIG_NAMED_EXPORTS);
+  const semis: boolean | undefined = config.get(CONFIG_SEMIS);
+  const quote: '"' | "'" = config.get(CONFIG_QUOTE) ?? "'";
+  const message: string | string[] | undefined = config.get<string | string[]>(
+    CONFIG_MESSAGE
+  );
+
+  return {
+    excludeFiles,
+    excludeRel,
+    includeFolders,
+    namedExports,
+    semis,
+    quote,
+    message,
+  };
+};
diff --git a/src/helpers/getFileContents.ts b/src/helpers/getFileContents.ts
@@ -1,18 +1,22 @@
-import * as fs from "fs";
-import * as path from "path";
-import { ExportAll } from "../commands";
+import { join } from "path";
+import { fileExists, readFile } from ".";
+import { FileType, Uri, workspace } from "vscode";
+import { BarrelFiles } from "../constants";
 
-export const getFileContents = (filePath: string): string => {
-  if (fs.lstatSync(filePath).isDirectory()) {
-    for (const indexFile of ExportAll.barrelFiles) {
-      const indexPath = path.join(filePath, indexFile);
-      if (fs.existsSync(indexPath)) {
-        return fs.readFileSync(indexPath, "utf8");
+export const getFileContents = async (
+  filePath: string
+): Promise<string | undefined> => {
+  const stat = await workspace.fs.stat(Uri.file(filePath));
+  if (stat.type === FileType.Directory) {
+    for (const indexFile of BarrelFiles) {
+      const indexPath = join(filePath, indexFile);
+      if (await fileExists(indexPath)) {
+        return await readFile(indexPath);
       }
     }
-    return "";
-  } else if (fs.lstatSync(filePath).isFile()) {
-    return fs.readFileSync(filePath, "utf8");
+    return undefined;
+  } else if (stat.type === FileType.File) {
+    return await readFile(filePath);
   }
-  return "";
+  return undefined;
 };
diff --git a/src/helpers/index.ts b/src/helpers/index.ts
@@ -1,6 +1,9 @@
 export * from "./clearWildcard";
+export * from "./fileExists";
 export * from "./getFileContents";
 export * from "./logger";
 export * from "./parseFileForNamedExports";
 export * from "./parseWinPath";
+export * from "./readFile";
 export * from "./util";
+export * from "./writeFile";
diff --git a/src/helpers/readFile.ts b/src/helpers/readFile.ts
@@ -0,0 +1,13 @@
+import { TextDecoder } from "util";
+import { Uri, workspace } from "vscode";
+
+export const readFile = async (
+  filePath: string
+): Promise<string | undefined> => {
+  const file = await workspace.fs.readFile(Uri.file(filePath));
+  if (!file) {
+    return undefined;
+  }
+
+  return new TextDecoder().decode(file);
+};
diff --git a/src/helpers/writeFile.ts b/src/helpers/writeFile.ts
@@ -0,0 +1,10 @@
+import { TextEncoder } from "util";
+import { Uri, workspace } from "vscode";
+
+export const writeFile = async (
+  filePath: string,
+  content: string
+): Promise<void> => {
+  const encoder = new TextEncoder();
+  await workspace.fs.writeFile(Uri.file(filePath), encoder.encode(content));
+};
diff --git a/src/models/Config.ts b/src/models/Config.ts
@@ -0,0 +1,9 @@
+export interface Config {
+  excludeFiles: string | undefined;
+  excludeRel: string | undefined;
+  includeFolders: boolean | undefined;
+  namedExports: boolean | undefined;
+  semis: boolean | undefined;
+  quote: '"' | "'";
+  message: string | string[] | undefined;
+}
diff --git a/src/models/FileOrFolderToExport.ts b/src/models/FileOrFolderToExport.ts
@@ -0,0 +1,4 @@
+export interface FileOrFolderToExport {
+  name: string;
+  type: "file" | "folder";
+}
diff --git a/src/models/index.ts b/src/models/index.ts
@@ -0,0 +1,2 @@
+export * from "./Config";
+export * from "./FileOrFolderToExport";

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export const BarrelFiles = ["index.ts", "index.tsx"];`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`		`-export * from './Extension';`
	`1`	`+export * from "./BarrelFiles";`
	`2`	`+export * from "./Extension";`