refactor: remove unused constants and comments

Author: ITboo

src/commands/fs/cat.js

@@ -3,14 +3,14 @@ import { resolve as resolvePath } from 'path';
 import { cwd } from 'process';
 
 export const cat = async (path) => {
-   await new Promise((resolve, reject) => {
+   await new Promise((res, rej) => {
       const filePath = resolvePath(cwd(), path);
-      const fileContent = createReadStream(filePath, { encoding: 'utf8' });
+      const stream = createReadStream(filePath, { encoding: 'utf8' });
 
-      fileContent.on('data', (chunk) => {
+      stream.on('data', (chunk) => {
         console.log(chunk);
       });
-      fileContent.on('error', reject);
-      fileContent.on('end', resolve);
+      stream.on('error', rej);
+      stream.on('end', res);
     });
 };

src/commands/fs/cp.js

@@ -1,21 +1,21 @@
 import { createReadStream, createWriteStream } from 'fs';
-import { resolve as pathResolve, basename } from 'path';
+import { resolve, basename } from 'path';
 
 export const cp = async (path, newPath) => {
-   const fileToCopyPath = pathResolve(process.cwd(), path);
-   const fileName = basename(fileToCopyPath);
-   const dirToWritePath = pathResolve(process.cwd(), newPath);
-   const fileToWritePath = pathResolve(dirToWritePath, fileName);
+   const srcPath = resolve(process.cwd(), path);
+   const fileName = basename(srcPath);
+   const destPath = resolve(process.cwd(), newPath);
+   const fileToWritePath = resolve(destPath, fileName);
    try {
       await new Promise(async (res, rej) => {
-         const fileToCopy = createReadStream(fileToCopyPath, { encoding: 'utf8' });
-         const fileToWrite = createWriteStream(fileToWritePath, {
+         const file = createReadStream(srcPath, { encoding: 'utf8' });
+         const copy = createWriteStream(fileToWritePath, {
             flags: 'wx',
          });
 
-         fileToCopy.pipe(fileToWrite);
-         fileToCopy.on('error', rej);
-         fileToCopy.on('end', res);
+         file.pipe(copy);
+         file.on('error', rej);
+         file.on('end', res);
       });
    } catch (error) {
       throw error;

src/commands/fs/rm.js

@@ -1,11 +1,7 @@
 import { rm as rmFile} from 'fs/promises';
 import { resolve } from 'path';
-import { cwd } from 'process';
-
-import { rm_success } from '../../common/messages.js';
 
 export const remove = async (path) => {
-    const filePath = resolve(cwd(), path);
+    const filePath = resolve(process.cwd(), path);
     await rmFile(filePath);
-
 };

src/commands/fs/rn.js

@@ -1,7 +1,6 @@
 import { rename } from 'fs/promises';
 import { resolve } from 'path';
 import { cwd } from 'process';
-import { rn_success } from '../../common/messages.js';
 
 export const rn = async (currentName, newName) => {
     const filePath = resolve(cwd(), currentName);

src/commands/zip/brotli.js

@@ -3,28 +3,28 @@ import { resolve, basename, parse } from 'path';
 import { createBrotliDecompress, createBrotliCompress } from 'zlib';
 
 export const brotli = async (option, path, newPath) => {
-    const EXT = 'br';
+  const EXT = 'br';
   try {
     const needCompress = option === 'compress';
 
-    const fileToConvertPath = resolve(process.cwd(), path);
+    const filePath = resolve(process.cwd(), path);
 
-    const baseName = basename(fileToConvertPath);
+    const baseName = basename(filePath);
     const fileName = parse(baseName).name;
 
-    const fileNameToWrite = needCompress ? `${baseName}.${EXT}` : fileName;
-    const dirToWritePath = resolve(process.cwd(), newPath);
-    const fileToWritePath = resolve(dirToWritePath, fileNameToWrite);
+    const newFileName = needCompress ? `${baseName}.${EXT}` : fileName;
+    const dirPath = resolve(process.cwd(), newPath);
+    const brotliPath = resolve(dirPath, newFileName);
 
     await new Promise((res, rej) => {
-      const fileToConvert = createReadStream(fileToConvertPath);
-      const fileToWrite = createWriteStream(fileToWritePath, { flags: 'wx',});
+      const file = createReadStream(filePath);
+      const brotliFile = createWriteStream(brotliPath, { flags: 'wx', });
 
       const brotliHandler = needCompress ? createBrotliCompress() : createBrotliDecompress();
 
-      fileToConvert.pipe(brotliHandler).pipe(fileToWrite);
-      fileToConvert.on('error', rej);
-      fileToConvert.on('end', res);
+      file.pipe(brotliHandler).pipe(brotliFile);
+      file.on('error', rej);
+      file.on('end', res);
     });
   } catch (err) {
     throw err;