@t8/serve 0.1.0

package/dist/index.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  serve: () => serve
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/serve.ts
+var import_node_fs = require("node:fs");
+var import_node_http = require("node:http");
+var import_node_path2 = require("node:path");
+
+// src/getFilePath.ts
+var import_node_path = require("node:path");
+
+// src/isValidFilePath.ts
+var import_promises = require("node:fs/promises");
+async function isValidFilePath(filePath, dirPath) {
+  if (!filePath.startsWith(dirPath)) return false;
+  try {
+    await (0, import_promises.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/getFilePath.ts
+var cwd = process.cwd();
+async function getFilePath(urlPath = "", { path = "", dirs = [""] }) {
+  for (let dir of dirs) {
+    let dirPath = (0, import_node_path.join)(cwd, path, dir);
+    let filePath = (0, import_node_path.join)(dirPath, urlPath);
+    if (await isValidFilePath(filePath, dirPath)) return filePath;
+    if (!/\.\w+$/.test(filePath)) {
+      filePath = (0, import_node_path.join)(dirPath, urlPath, "index.html");
+      if (await isValidFilePath(filePath, dirPath)) return filePath;
+    }
+  }
+}
+
+// src/mimeTypes.ts
+var mimeTypes = {
+  html: "text/html; charset=utf-8",
+  js: "text/javascript",
+  json: "application/json",
+  css: "text/css",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  txt: "text/plain",
+  md: "text/markdown"
+};
+
+// src/serve.ts
+var defaultHost = "localhost";
+var defaultPort = 3e3;
+function serve(config = {}) {
+  let [, , host, , port] = config.url?.match(/^(https?:\/\/)?([^:/]+)(:(\d+))?\/?/) ?? [];
+  if (!port && /^\d+$/.test(host)) {
+    port = host;
+    host = defaultHost;
+  }
+  let server = (0, import_node_http.createServer)(async (req, res) => {
+    let filePath = await getFilePath(req.url, config);
+    if (filePath === void 0) {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end("Not found");
+      return;
+    }
+    let ext = (0, import_node_path2.extname)(filePath).slice(1).toLowerCase();
+    let mimeType = mimeTypes[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "content-type": mimeType });
+    (0, import_node_fs.createReadStream)(filePath).pipe(res);
+  });
+  server.on("close", () => {
+    process.exit(0);
+  });
+  server.listen(Number(port) || defaultPort, host || defaultHost);
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serve
+});

package/dist/run.cjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/serve.ts
+var import_node_fs = require("node:fs");
+var import_node_http = require("node:http");
+var import_node_path2 = require("node:path");
+
+// src/getFilePath.ts
+var import_node_path = require("node:path");
+
+// src/isValidFilePath.ts
+var import_promises = require("node:fs/promises");
+async function isValidFilePath(filePath, dirPath) {
+  if (!filePath.startsWith(dirPath)) return false;
+  try {
+    await (0, import_promises.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/getFilePath.ts
+var cwd = process.cwd();
+async function getFilePath(urlPath = "", { path = "", dirs = [""] }) {
+  for (let dir of dirs) {
+    let dirPath = (0, import_node_path.join)(cwd, path, dir);
+    let filePath = (0, import_node_path.join)(dirPath, urlPath);
+    if (await isValidFilePath(filePath, dirPath)) return filePath;
+    if (!/\.\w+$/.test(filePath)) {
+      filePath = (0, import_node_path.join)(dirPath, urlPath, "index.html");
+      if (await isValidFilePath(filePath, dirPath)) return filePath;
+    }
+  }
+}
+
+// src/mimeTypes.ts
+var mimeTypes = {
+  html: "text/html; charset=utf-8",
+  js: "text/javascript",
+  json: "application/json",
+  css: "text/css",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  txt: "text/plain",
+  md: "text/markdown"
+};
+
+// src/serve.ts
+var defaultHost = "localhost";
+var defaultPort = 3e3;
+function serve(config = {}) {
+  let [, , host, , port] = config.url?.match(/^(https?:\/\/)?([^:/]+)(:(\d+))?\/?/) ?? [];
+  if (!port && /^\d+$/.test(host)) {
+    port = host;
+    host = defaultHost;
+  }
+  let server = (0, import_node_http.createServer)(async (req, res) => {
+    let filePath = await getFilePath(req.url, config);
+    if (filePath === void 0) {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end("Not found");
+      return;
+    }
+    let ext = (0, import_node_path2.extname)(filePath).slice(1).toLowerCase();
+    let mimeType = mimeTypes[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "content-type": mimeType });
+    (0, import_node_fs.createReadStream)(filePath).pipe(res);
+  });
+  server.on("close", () => {
+    process.exit(0);
+  });
+  server.listen(Number(port) || defaultPort, host || defaultHost);
+  return server;
+}
+
+// src/run.ts
+var args = process.argv.slice(2);
+serve({
+  url: args[0],
+  path: args[1],
+  dirs: args.slice(2)
+});

package/dist/run.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+// src/serve.ts
+import { createReadStream } from "node:fs";
+import { createServer } from "node:http";
+import { extname } from "node:path";
+
+// src/getFilePath.ts
+import { join } from "node:path";
+
+// src/isValidFilePath.ts
+import { access } from "node:fs/promises";
+async function isValidFilePath(filePath, dirPath) {
+  if (!filePath.startsWith(dirPath)) return false;
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/getFilePath.ts
+var cwd = process.cwd();
+async function getFilePath(urlPath = "", { path = "", dirs = [""] }) {
+  for (let dir of dirs) {
+    let dirPath = join(cwd, path, dir);
+    let filePath = join(dirPath, urlPath);
+    if (await isValidFilePath(filePath, dirPath)) return filePath;
+    if (!/\.\w+$/.test(filePath)) {
+      filePath = join(dirPath, urlPath, "index.html");
+      if (await isValidFilePath(filePath, dirPath)) return filePath;
+    }
+  }
+}
+
+// src/mimeTypes.ts
+var mimeTypes = {
+  html: "text/html; charset=utf-8",
+  js: "text/javascript",
+  json: "application/json",
+  css: "text/css",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  txt: "text/plain",
+  md: "text/markdown"
+};
+
+// src/serve.ts
+var defaultHost = "localhost";
+var defaultPort = 3e3;
+function serve(config = {}) {
+  let [, , host, , port] = config.url?.match(/^(https?:\/\/)?([^:/]+)(:(\d+))?\/?/) ?? [];
+  if (!port && /^\d+$/.test(host)) {
+    port = host;
+    host = defaultHost;
+  }
+  let server = createServer(async (req, res) => {
+    let filePath = await getFilePath(req.url, config);
+    if (filePath === void 0) {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end("Not found");
+      return;
+    }
+    let ext = extname(filePath).slice(1).toLowerCase();
+    let mimeType = mimeTypes[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "content-type": mimeType });
+    createReadStream(filePath).pipe(res);
+  });
+  server.on("close", () => {
+    process.exit(0);
+  });
+  server.listen(Number(port) || defaultPort, host || defaultHost);
+  return server;
+}
+
+// src/run.ts
+var args = process.argv.slice(2);
+serve({
+  url: args[0],
+  path: args[1],
+  dirs: args.slice(2)
+});

package/index.ts

@@ -0,0 +1,2 @@
+export * from "./src/Config";
+export * from "./src/serve";

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@t8/serve",
+  "version": "0.1.0",
+  "description": "",
+  "keywords": [
+    "node",
+    "server",
+    "static"
+  ],
+  "bin": {
+    "serve": "dist/run.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/t8js/serve.git"
+  },
+  "license": "ISC",
+  "author": "axtk",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "npx npm-run-all clean -p compile compile-mjs-bin compile-cjs-bin",
+    "clean": "node -e \"require('node:fs').rmSync('dist', {force: true, recursive: true});\"",
+    "compile": "npx esbuild index.ts --bundle --outdir=dist --platform=node",
+    "compile-mjs-bin": "npx esbuild src/run.ts --bundle --outfile=dist/run.mjs --platform=node --format=esm",
+    "compile-cjs-bin": "npx esbuild src/run.ts --bundle --outfile=dist/run.cjs --platform=node --format=cjs",
+    "prepublishOnly": "npm run build",
+    "preversion": "npx npm-run-all typecheck shape build",
+    "shape": "npx codeshape",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "typescript": "^5.9.2"
+  }
+}

package/src/Config.ts

@@ -0,0 +1,5 @@
+export type Config = {
+  url?: string;
+  path?: string;
+  dirs?: string[];
+};

package/src/getFilePath.ts

@@ -0,0 +1,23 @@
+import { join } from "node:path";
+import type { Config } from "./Config";
+import { isValidFilePath } from "./isValidFilePath";
+
+const cwd = process.cwd();
+
+export async function getFilePath(
+  urlPath: string = "",
+  { path = "", dirs = [""] }: Config,
+) {
+  for (let dir of dirs) {
+    let dirPath = join(cwd, path, dir);
+    let filePath = join(dirPath, urlPath);
+
+    if (await isValidFilePath(filePath, dirPath)) return filePath;
+
+    if (!/\.\w+$/.test(filePath)) {
+      filePath = join(dirPath, urlPath, "index.html");
+
+      if (await isValidFilePath(filePath, dirPath)) return filePath;
+    }
+  }
+}

package/src/isValidFilePath.ts

@@ -0,0 +1,12 @@
+import { access } from "node:fs/promises";
+
+export async function isValidFilePath(filePath: string, dirPath: string) {
+  if (!filePath.startsWith(dirPath)) return false;
+
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/mimeTypes.ts

@@ -0,0 +1,13 @@
+export const mimeTypes: Record<string, string> = {
+  html: "text/html; charset=utf-8",
+  js: "text/javascript",
+  json: "application/json",
+  css: "text/css",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  txt: "text/plain",
+  md: "text/markdown",
+};

package/src/run.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { serve } from "./serve";
+
+let args = process.argv.slice(2);
+
+/**
+ * @example
+ * serve 3000 app public dist
+ * serve 127.0.0.1:3000 app public dist
+ */
+serve({
+  url: args[0],
+  path: args[1],
+  dirs: args.slice(2),
+});

package/src/serve.ts

@@ -0,0 +1,43 @@
+import { createReadStream } from "node:fs";
+import { createServer } from "node:http";
+import { extname } from "node:path";
+import type { Config } from "./Config";
+import { getFilePath } from "./getFilePath";
+import { mimeTypes } from "./mimeTypes";
+
+const defaultHost = "localhost";
+const defaultPort = 3000;
+
+export function serve(config: Config = {}) {
+  let [, , host, , port] =
+    config.url?.match(/^(https?:\/\/)?([^:/]+)(:(\d+))?\/?/) ?? [];
+
+  if (!port && /^\d+$/.test(host)) {
+    port = host;
+    host = defaultHost;
+  }
+
+  let server = createServer(async (req, res) => {
+    let filePath = await getFilePath(req.url, config);
+
+    if (filePath === undefined) {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end("Not found");
+      return;
+    }
+
+    let ext = extname(filePath).slice(1).toLowerCase();
+    let mimeType = mimeTypes[ext] ?? "application/octet-stream";
+
+    res.writeHead(200, { "content-type": mimeType });
+    createReadStream(filePath).pipe(res);
+  });
+
+  server.on("close", () => {
+    process.exit(0);
+  });
+
+  server.listen(Number(port) || defaultPort, host || defaultHost);
+
+  return server;
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "include": ["index.ts", "src"],
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "target": "ESNext",
+    "outDir": "dist",
+    "moduleResolution": "node",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  }
+}