@t8/serve 0.1.39 → 0.2.0

package/README.md

@@ -9,28 +9,32 @@ Use cases:
 
 ## CLI
 
-```sh
-npx @t8/serve [url|port] [*] [app_dir] [...assets_dirs] [-b [bundle_input_path] [bundle_output_path] [bundle_output_dir]] [--watch] [--minify]
-# * = SPA mode: serve all unmatched paths as "/"
 ```
+npx @t8/serve <app_dir> [...optional flags]
 
-Examples:
+Flag            Usage
 
-```sh
-npx @t8/serve 3000 app
-# - serve files from './app' at 'localhost:3000'
+--bundle, -b    -b [input_path [[output_path] [output_dir]]]
+                Defaults:
+                - input_path: "index.ts" (relative to <app_dir>)
+                - ouput_path: "index.js" (relative to <app_dir>/<output_dir>)
+                - output_dir: "dist"
+
+--url, -u       -u [<host>:]<port>
+                Default: "localhost:3000"
+
+--spa, -s       -s
+                Enables the SPA mode by handling all unmatched paths as "/".
 
-npx @t8/serve 3000 * app -b
-# - bundle './app/index.ts' to './app/dist/index.js' [-b]
-# - serve files from './app' at 'localhost:3000' in the SPA mode [*] (handling all unmatched paths as "/")
+--dirs          --dirs assets public
+                To serve files from the listed subdirectories of <app_dir>.
+                By default, files are served from <app_dir>.
 
-npx @t8/serve 3000 * app -b src/index.ts
-# - bundle './app/src/index.ts' to './app/dist/index.js'
-# - serve files from './app' at 'localhost:3000' in the SPA mode
+--watch         --watch
+                To rebuild the bundled code if the source code changes.
 
-npx @t8/serve 127.0.0.1:3000 app public dist -b
-# - bundle './app/index.ts' to './app/dist/index.js'
-# - serve files from './app/public' and './app/dist' at '127.0.0.1:3000'
+--minify        --minify
+                To minify the bundled code.
 ```
 
 <details>
@@ -39,7 +43,7 @@ npx @t8/serve 127.0.0.1:3000 app public dist -b
 ```
 // package.json
 "scripts": {
-  "play": "npx @t8/serve 3000 * playground -b"
+  "play": "npx @t8/serve playground -s -b"
 }
 ```
 
@@ -76,7 +80,7 @@ webServer: {
 ```
 // package.json
 "scripts": {
-  "play": "npx @t8/serve 3000 * playground -b src/index.tsx"
+  "play": "npx @t8/serve playground -s -b src/index.tsx"
 }
 ```
 
@@ -127,7 +131,7 @@ webServer: {
 {
   "name": "app",
   "scripts": {
-    "start": "npx @t8/serve 80 . -b src/index.ts --watch"
+    "start": "npx @t8/serve . -u 80 -b src/index.ts --watch"
   }
 }
 ```

package/dist/run.mjs

@@ -1,4 +1,118 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/args-json/dist/index.cjs
+var require_dist = __commonJS({
+  "node_modules/args-json/dist/index.cjs"(exports) {
+    function toCamelCase(x) {
+      let s = x.replace(/^[-_.\s~+]|[-_.\s~+]$/g, "");
+      if (!/[-_.\s~+]/.test(s)) return s.slice(0, 1).toLowerCase() + s.slice(1);
+      return s.toLowerCase().replace(/[-_.\s~+](\S)/g, (_, match) => match.toUpperCase());
+    }
+    function toKey(x) {
+      if (x) {
+        if (x.startsWith("--") && x.length > 2) return toCamelCase(x.slice(2));
+        if (x.startsWith("-") && x.length === 2) return toCamelCase(x.slice(1));
+      }
+    }
+    function split(x) {
+      let words = [], word = "";
+      let hasOpenSingleQuote = false;
+      let hasOpenDoubleQuote = false;
+      for (let i = 0; i < x.length; i++) {
+        let c = x[i];
+        if (/^\s/.test(c) && !hasOpenSingleQuote && !hasOpenDoubleQuote) {
+          if (word) words.push(word);
+          word = "";
+          continue;
+        }
+        if (c === "'" && x[i - 1] !== "\\") hasOpenSingleQuote = !hasOpenSingleQuote;
+        if (c === '"' && x[i - 1] !== "\\") hasOpenDoubleQuote = !hasOpenDoubleQuote;
+        word += c;
+      }
+      if (word) words.push(word);
+      return words;
+    }
+    function getDefaultInput() {
+      return typeof process === "undefined" ? [] : process.argv;
+    }
+    function parseArgs2(input, map) {
+      let normalizedInput;
+      let normalizedMap;
+      if (input === void 0) normalizedInput = getDefaultInput();
+      else if (typeof input === "string") normalizedInput = split(input);
+      else if (Array.isArray(input)) normalizedInput = input.map((x) => String(x));
+      else if (input !== null && typeof input === "object") {
+        normalizedInput = getDefaultInput();
+        normalizedMap = input;
+      } else normalizedInput = [];
+      normalizedInput = normalizedInput.flatMap((item) => {
+        let normalizedItem = item.trim();
+        let k = normalizedItem.indexOf("=");
+        if (k === -1) return normalizedItem;
+        return [normalizedItem.slice(0, k), normalizedItem.slice(k + 1)];
+      });
+      if (map) normalizedMap = map;
+      let key = "";
+      let parsedArgs = {};
+      for (let rawValue of normalizedInput) {
+        rawValue = rawValue.trim();
+        if (rawValue.startsWith('"') && rawValue.endsWith('"')) rawValue = rawValue.slice(1, -1);
+        else if (rawValue.startsWith("'") && rawValue.endsWith("'")) rawValue = rawValue.slice(1, -1);
+        let parsedKey = toKey(rawValue);
+        if (parsedKey !== void 0) {
+          let nextKey = normalizedMap?.[parsedKey] ?? parsedKey;
+          if (key && nextKey !== key && parsedArgs[key] === void 0) parsedArgs[key] = true;
+          key = nextKey;
+          continue;
+        }
+        let parsedValue;
+        if (rawValue) try {
+          parsedValue = JSON.parse(rawValue);
+        } catch {
+          parsedValue = rawValue;
+        }
+        else parsedValue = true;
+        let prevValue = parsedArgs[key];
+        let value;
+        if (prevValue === void 0) value = key === "" ? [parsedValue] : parsedValue;
+        else if (Array.isArray(prevValue)) value = [...prevValue, parsedValue];
+        else value = [prevValue, parsedValue];
+        parsedArgs[key] = value;
+      }
+      if (key && parsedArgs[key] === void 0) parsedArgs[key] = true;
+      return parsedArgs;
+    }
+    exports.parseArgs = parseArgs2;
+  }
+});
+
+// src/run.ts
+var import_args_json = __toESM(require_dist(), 1);
 
 // src/serve.ts
 import { createReadStream } from "node:fs";
@@ -143,47 +257,23 @@ async function serve(config = {}) {
 
 // src/run.ts
 async function run() {
-  let [url, ...args] = process.argv.slice(2);
-  let spa = false;
-  let watch = false;
-  let minify = false;
-  if (args[0] === "*") {
-    spa = true;
-    args.shift();
-  }
-  while (args.at(-1)?.startsWith("--")) {
-    let arg = args.pop();
-    switch (arg) {
-      case "--watch":
-        watch = true;
-        break;
-      case "--minify":
-        minify = true;
-        break;
-    }
-  }
-  let bundleFlagIndex = args.indexOf("-b");
-  let path = args[0];
-  let dirs;
-  let bundle2;
-  if (bundleFlagIndex === -1) dirs = args.slice(1);
-  else {
-    dirs = args.slice(1, bundleFlagIndex);
-    bundle2 = {
-      input: args[bundleFlagIndex + 1] || void 0,
-      output: args[bundleFlagIndex + 2] || void 0,
-      dir: args[bundleFlagIndex + 3] || void 0
-    };
-  }
-  await serve({
-    url,
-    path,
-    dirs,
-    spa,
+  let {
+    "": unkeyedArgs,
     bundle: bundle2,
-    log: true,
-    watch,
-    minify
+    dirs,
+    ...args
+  } = (0, import_args_json.parseArgs)(process.argv.slice(2), {
+    b: "bundle",
+    u: "url",
+    s: "spa"
   });
+  let config = {
+    path: unkeyedArgs?.[0],
+    dirs: Array.isArray(dirs) ? dirs : dirs && [dirs],
+    bundle: Array.isArray(bundle2) ? { input: bundle2[0], output: bundle2[1], dir: bundle2[2] } : bundle2,
+    log: true,
+    ...args
+  };
+  await serve(config);
 }
 run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t8/serve",
-  "version": "0.1.39",
+  "version": "0.2.0",
   "description": "Simple static file server + bundler, primarily for demo apps and tests, manual or automated",
   "keywords": [
     "node",
@@ -27,9 +27,10 @@
     "shape": "npx codeshape"
   },
   "devDependencies": {
-    "@types/node": "^24.5.2"
+    "@types/node": "^25.0.3"
   },
   "dependencies": {
-    "esbuild": "^0.27.1"
+    "args-json": "^1.2.10",
+    "esbuild": "^0.27.2"
   }
 }

package/src/run.ts

@@ -1,57 +1,36 @@
 #!/usr/bin/env node
+import { parseArgs } from "args-json";
 import type { Config } from "./Config.ts";
 import { serve } from "./serve.ts";
 
-async function run() {
-  let [url, ...args] = process.argv.slice(2);
-  let spa = false;
-  let watch = false;
-  let minify = false;
-
-  if (args[0] === "*") {
-    spa = true;
-    args.shift();
-  }
-
-  while (args.at(-1)?.startsWith("--")) {
-    let arg = args.pop();
-
-    switch (arg) {
-      case "--watch":
-        watch = true;
-        break;
-      case "--minify":
-        minify = true;
-        break;
-    }
-  }
-
-  let bundleFlagIndex = args.indexOf("-b");
-  let path = args[0];
-
-  let dirs: string[];
-  let bundle: Config["bundle"];
-
-  if (bundleFlagIndex === -1) dirs = args.slice(1);
-  else {
-    dirs = args.slice(1, bundleFlagIndex);
-    bundle = {
-      input: args[bundleFlagIndex + 1] || undefined,
-      output: args[bundleFlagIndex + 2] || undefined,
-      dir: args[bundleFlagIndex + 3] || undefined,
-    };
-  }
+type CLIConfig = Omit<Config, "bundle" | "onRequest"> & {
+  ""?: string[];
+  bundle?: string | string[];
+};
 
-  await serve({
-    url,
-    path,
-    dirs,
-    spa,
+async function run() {
+  let {
+    "": unkeyedArgs,
     bundle,
-    log: true,
-    watch,
-    minify,
+    dirs,
+    ...args
+  } = parseArgs<CLIConfig>(process.argv.slice(2), {
+    b: "bundle",
+    u: "url",
+    s: "spa",
   });
+
+  let config: Config = {
+    path: unkeyedArgs?.[0],
+    dirs: Array.isArray(dirs) ? dirs : dirs && [dirs],
+    bundle: Array.isArray(bundle)
+      ? { input: bundle[0], output: bundle[1], dir: bundle[2] }
+      : bundle,
+    log: true,
+    ...args,
+  };
+
+  await serve(config);
 }
 
 run();