feat: Add server command & Remove unused commands

Author: araguma

package-lock.json

@@ -24,14 +24,14 @@
   },
   "homepage": "https://github.com/araguma/node-dev-utils#readme",
   "devDependencies": {
-    "@types/fs-extra": "^11.0.1",
+    "@types/express": "^4.17.17",
     "@types/node": "^20.3.1",
     "typescript": "^5.1.3"
   },
   "dependencies": {
     "chokidar": "^3.5.3",
     "commander": "^11.0.0",
-    "glob": "^10.3.0"
+    "express": "^4.18.2"
   },
   "bin": {
     "du": "./dist/bin/src/index.js"

package.json

@@ -1,47 +1,27 @@
 import fs from 'node:fs';
-import { join } from 'node:path';
-import { globSync } from 'glob';
-import chokidar from 'chokidar';
+import path from 'node:path';
+import { stringToRegex } from '../utils/regex';
 
-/**
- * Copy files or directories to another destination
- * @param pattern Source files or directories
- * @param destPath Destination directory
- * @param options Copy options
- */
-function cp(pattern: string, destPath: string, options: {
-    /**
-     * Copy subdirectories recursively
-     */
-    recursive?: boolean,
-    /**
-     * Force copy
-     */
-    force?: boolean,
-    /**
-     * Files or directories to ignore
-     */
-    ignore?: string,
-    /**
-     * Starts watch mode on source files or directories
-     */
-    watch?: boolean,
+function cp(src: string, dest: string, options: {
+    recursive?: boolean;
+    force?: boolean;
+    ignore?: string;
 }) {
-    const srcPaths = globSync(pattern, {
-        ignore: options.ignore,
-    });
-    const copytoDestFn = (path: string) => {
-        fs.cpSync(path, join(destPath, path), {
-            mode: fs.constants.COPYFILE_FICLONE,
-            errorOnExist: false,
-            recursive: options.recursive,
-            force: options.force,
+    src = path.normalize(src);
+    dest = path.normalize(dest);
+    const ignoreRegex = stringToRegex(options.ignore ?? '/$^/');
+
+    fs.readdirSync(src, {
+        recursive: options.recursive ?? false,
+        withFileTypes: true,
+    }).filter((entry) => {
+        return entry.isFile() && !ignoreRegex.test(entry.name);
+    }).forEach((entry) => {
+        const filePath = path.join(entry.path, entry.name);
+        fs.cpSync(filePath, path.join(dest, filePath), {
+            force: options.force ?? false,
         });
-    }
-    srcPaths.forEach(copytoDestFn);
-    if(options.watch)
-        chokidar.watch(srcPaths)
-            .on('change', copytoDestFn);
+    });
 }
 
 export default cp;

src/commands/cp.ts

@@ -0,0 +1,22 @@
+import { execSync } from 'node:child_process';
+import express from 'express';
+import chokidar from 'chokidar';
+
+function server(root: string, options: {
+    port: number;
+    watch?: string;
+    command?: string;
+}) {
+    const app = express();
+    app.use(express.static(root));
+    app.listen(options.port, () => {
+        console.log(`Server is listening on localhost:${options.port}`);
+    });
+
+    chokidar.watch(options.watch ?? root).on('change', (path) => {
+        if(options.command)
+            execSync(options.command.replace(/\$path/g, path));
+    });
+}
+
+export default server;

src/commands/mkdir.ts

@@ -1,51 +1,34 @@
 #!/usr/bin/env node
-import { version } from '../package.json';
 import { Command }  from 'commander';
-import mkdir from './commands/mkdir';
+import { version } from '../package.json';
 import cp from './commands/cp';
-import rm from './commands/rm';
-import watch from './commands/watch';
+import server from './commands/server';
 
 const program = new Command()
     .name('fsx')
     .description('A collection of cross-platform compatible functions and shell commands that aid in npm package development.')
     .version(version);
 
-program.command('mkdir')
-    .description('Create directory at the specified path.')
-    .argument('<string>', 'Directory path')
-    .action(mkdir);
-
 program.command('cp')
-    .description('Copy files or directories to another destination.')
-    .argument('<string>', 'Source files or directories')
+    .description('Copy files and directories.')
+    .argument('<string>', 'Source file or directory')
     .argument('<string>', 'Destination directory')
-    .option('-r, --recursive', 'Copy subdirectories recursively', false)
-    .option('-f, --force', 'Force copy', false)
-    .option('-i, --ignore <string>', 'Files or directories to ignore')
-    .option('-w, --watch', 'Starts watch mode on source files or directories', false)
+    .option('-r, --recursive', 'Copy directories recursively', false)
+    .option('-f, --force', 'Overwrite existing files', false)
+    .option('-i, --ignore <string>', 'Ignore file(s) or directory')
     .action(cp);
 
-program.command('rm')
-    .description('Remove files or directories.')
-    .argument('<string>', 'Files or directories')
-    .option('-r, --recursive', 'Remove subdirectories recursively', false)
-    .option('-f, --force', 'Force remove', false)
-    .option('-i, --ignore <string>', 'Files or directories to ignore')
-    .action(rm);
-
-program.command('watch')
-    .description('Watch a list of files and run a command if any changes occur.')
-    .argument('<string>', 'Files or directories to watch')
-    .argument('<string>', 'Command to run if any changes occur')
-    .option('-i --ignore <string>', 'Files or directories to ignore')
-    .action(watch);
+program.command('server')
+    .description('Host a static local server using the specified directory as root.')
+    .argument('<string>', 'Root directory')
+    .option('-p, --port <number>', 'Port to listen on', '3000')
+    .option('-w, --watch <string>', 'Watch directory')
+    .option('-c, --command <string>', 'Command to run on change')
+    .action(server);
 
 program.parse();
 
 export {
-    mkdir,
     cp,
-    rm,
-    watch,
-};
+    server
+}

src/commands/rm.ts

@@ -0,0 +1,11 @@
+function stringToRegex(string: string) {
+    // Matches the pattern in the first group and flags in the third group
+    const groups = string.match(/^\/(.*)\/(?!.*(.).*\2)([gmiyuvsd]*)$/m);
+    if(groups === null)
+        throw new Error(`Invalid regex: ${string}`);
+    return new RegExp(groups[1], groups[3]);
+}
+
+export {
+    stringToRegex,
+}