@e22m4u/js-http-static-router 0.0.7

package/.c8rc

@@ -0,0 +1,9 @@
+{
+  "all": true,
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "src/**/*.spec.ts"
+  ]
+}

package/.commitlintrc

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "@commitlint/config-conventional"
+  ]
+}

package/.editorconfig

@@ -0,0 +1,13 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 2
+max_line_length = 80

package/.husky/commit-msg

@@ -0,0 +1 @@
+npx --no -- commitlint --edit $1

package/.husky/pre-commit

@@ -0,0 +1,6 @@
+npm run lint:fix
+npm run format
+npm run test
+npm run build
+
+git add -A

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+  "extension": ["ts"],
+  "spec": "src/**/*.spec.ts",
+  "require": ["tsx"]
+}

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "bracketSpacing": false,
+  "singleQuote": true,
+  "printWidth": 80,
+  "trailingComma": "all",
+  "arrowParens": "avoid"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 Mikhail Evstropov <e22m4u@yandex.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+## @e22m4u/js-http-static-router
+
+HTTP-маршрутизатор статичных ресурсов.
+
+## Установка
+
+```bash
+npm install @e22m4u/js-http-static-router
+```
+
+## Использование
+
+```ts
+import http from 'http';
+import {HttpStaticRouter} from '@e22m4u/js-http-static-router';
+
+// обертка инициализации в асинхронную функцию
+async function main() {
+  // создание экземпляра маршрутизатора
+  const staticRouter = new HttpStaticRouter();
+
+  // добавление маршрутов:
+  // (Promise.all для параллельной и быстрой инициализации)
+  await Promise.all([
+    // объявление содержимого папки "../static"
+    // доступным по URL "/static"
+    staticRouter.addRoute(
+      '/static',                          // путь маршрута
+      `${import.meta.dirname}/../static`, // файловый путь
+    ),
+    // объявление отдельного файла
+    staticRouter.addRoute(
+      '/favicon.ico',
+      `${import.meta.dirname}/../static/favicon.ico`,
+    ),
+  ]);
+
+  // создание HTTP сервера и подключение обработчика
+  const server = new http.Server();
+  server.on('request', (req, res) => {
+    // если статический маршрут найден,
+    // выполняется поиск и отдача файла
+    const staticRoute = staticRouter.matchRoute(req);
+    if (staticRoute) staticRouter.sendFileByRoute(staticRoute, req, res);
+    // в противном случае запрос обрабатывается
+    // основной логикой приложения
+    res.writeHead(200, {'Content-Type': 'text/plain'});
+    res.end('Hello from App!');
+  });
+
+  server.listen(3000, () => {
+    console.log('Server is running on http://localhost:3000');
+    console.log('Try to open:');
+    console.log('http://localhost:3000/static/');
+    console.log('http://localhost:3000/favicon.ico');
+  });
+}
+
+// запуск
+main().catch(error => {
+  console.error('Failed to start the server:', error);
+  process.exit(1);
+});
+```
+
+## Тесты
+
+```bash
+npm run test
+```
+
+## Лицензия
+
+MIT

package/build-cjs.js

@@ -0,0 +1,16 @@
+import * as esbuild from 'esbuild';
+import packageJson from './package.json' with {type: 'json'};
+
+await esbuild.build({
+  entryPoints: ['dist/esm/index.js'],
+  outfile: 'dist/cjs/index.cjs',
+  format: 'cjs',
+  platform: 'node',
+  target: ['node12'],
+  bundle: true,
+  keepNames: true,
+  external: [
+    ...Object.keys(packageJson.peerDependencies || {}),
+    ...Object.keys(packageJson.dependencies || {}),
+  ],
+});

package/dist/cjs/index.cjs

@@ -0,0 +1,196 @@
+"use strict";
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/esm/index.js
+var index_exports = {};
+__export(index_exports, {
+  HttpStaticRouter: () => HttpStaticRouter
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/esm/http-static-router.js
+var import_path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs/promises"), 1);
+var import_mime_types = __toESM(require("mime-types"), 1);
+var import_fs = require("fs");
+var import_js_format = require("@e22m4u/js-format");
+
+// dist/esm/services/debuggable-service.js
+var import_js_service = require("@e22m4u/js-service");
+
+// dist/esm/utils/to-camel-case.js
+function toCamelCase(input) {
+  return input.replace(/(^\w|[A-Z]|\b\w)/g, (c) => c.toUpperCase()).replace(/\W+/g, "").replace(/(^\w)/g, (c) => c.toLowerCase());
+}
+__name(toCamelCase, "toCamelCase");
+
+// dist/esm/services/debuggable-service.js
+var import_js_debug = require("@e22m4u/js-debug");
+var _DebuggableService = class _DebuggableService extends import_js_service.Service {
+  /**
+   * Debug.
+   */
+  debug;
+  /**
+   * Возвращает функцию-отладчик с сегментом пространства имен
+   * указанного в параметре метода.
+   *
+   * @param method
+   * @protected
+   */
+  getDebuggerFor(method) {
+    return this.debug.withHash().withNs(method.name);
+  }
+  /**
+   * Constructor.
+   *
+   * @param container
+   */
+  constructor(container) {
+    super(container);
+    const serviceName = toCamelCase(this.constructor.name);
+    this.debug = (0, import_js_debug.createDebugger)(serviceName).withoutEnvNs();
+    const debug = this.debug.withNs("constructor").withHash();
+    debug("Service created.");
+  }
+};
+__name(_DebuggableService, "DebuggableService");
+var DebuggableService = _DebuggableService;
+
+// dist/esm/http-static-router.js
+var _HttpStaticRouter = class _HttpStaticRouter extends DebuggableService {
+  /**
+   * Routes.
+   *
+   * @protected
+   */
+  routes = [];
+  /**
+   * Add route.
+   *
+   * @param remotePath
+   * @param resourcePath
+   */
+  async addRoute(remotePath, resourcePath) {
+    const debug = this.getDebuggerFor(this.addRoute);
+    resourcePath = import_path.default.resolve(resourcePath);
+    debug("Adding a new route.");
+    debug("Resource path is %v.", resourcePath);
+    debug("Remote path is %v.", remotePath);
+    let stats;
+    try {
+      stats = await fs.stat(resourcePath);
+    } catch (error) {
+      console.error(error);
+      throw new import_js_format.Errorf("Static resource path does not exist %v.", resourcePath);
+    }
+    const isFile = stats.isFile();
+    debug("Resource type is %s.", isFile ? "File" : "Folder");
+    const regexp = new RegExp(`^${remotePath}`, "i");
+    const route = { remotePath, resourcePath, regexp, isFile };
+    this.routes.push(route);
+    return this;
+  }
+  /**
+   * Match route.
+   *
+   * @param req
+   */
+  matchRoute(req) {
+    const debug = this.getDebuggerFor(this.matchRoute);
+    debug("Matching route by incoming request.");
+    const url = req.url || "/";
+    debug("Incoming request is %s %v.", req.method, url);
+    debug("Walking through %v routes.", this.routes.length);
+    const route = this.routes.find((route2) => {
+      const res = route2.regexp.test(url);
+      const phrase = res ? "matched" : "not matched";
+      debug("Resource %v %s.", route2.resourcePath, phrase);
+      return res;
+    });
+    route ? debug("Resource %v matched.", route.resourcePath) : debug("No route matched.");
+    return route;
+  }
+  /**
+   * Send file by route.
+   *
+   * @param route
+   * @param req
+   * @param res
+   */
+  sendFileByRoute(route, req, res) {
+    const reqUrl = (req.url || "/").replace(/\?.*$/, "");
+    if (/[^/]$/.test(route.remotePath) && reqUrl === route.remotePath) {
+      res.writeHead(302, { location: `${reqUrl}/` });
+      res.end();
+      return;
+    }
+    let filePath = route.resourcePath;
+    if (!route.isFile) {
+      let relativePath = reqUrl.replace(new RegExp(`^${route.remotePath}`), "");
+      if (!relativePath || relativePath === "/")
+        relativePath = "/index.html";
+      filePath = import_path.default.join(route.resourcePath, relativePath);
+    }
+    const resolvedPath = import_path.default.resolve(filePath);
+    const resourceRoot = import_path.default.resolve(route.resourcePath);
+    if (!resolvedPath.startsWith(resourceRoot)) {
+      res.writeHead(403, { "content-type": "text/plain" });
+      res.end("403 Forbidden");
+      return;
+    }
+    const extname = import_path.default.extname(resolvedPath);
+    const contentType = import_mime_types.default.contentType(extname) || "application/octet-stream";
+    const fileStream = (0, import_fs.createReadStream)(resolvedPath);
+    fileStream.on("error", (error) => {
+      if (res.headersSent)
+        return;
+      if ("code" in error && error.code === "ENOENT") {
+        res.writeHead(404, { "content-type": "text/plain" });
+        res.write("404 Not Found");
+        res.end();
+      } else {
+        res.writeHead(500, { "content-type": "text/plain" });
+        res.write("500 Internal Server Error");
+        res.end();
+      }
+    });
+    fileStream.on("open", () => {
+      res.writeHead(200, { "content-type": contentType });
+      fileStream.pipe(res);
+    });
+  }
+};
+__name(_HttpStaticRouter, "HttpStaticRouter");
+var HttpStaticRouter = _HttpStaticRouter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpStaticRouter
+});

package/dist/esm/http-static-router.d.ts

@@ -0,0 +1,45 @@
+import { ServerResponse } from 'node:http';
+import { IncomingMessage } from 'node:http';
+import { DebuggableService } from './services/index.js';
+/**
+ * Static file route.
+ */
+type HttpStaticRoute = {
+    remotePath: string;
+    resourcePath: string;
+    regexp: RegExp;
+    isFile: boolean;
+};
+/**
+ * Http static router.
+ */
+export declare class HttpStaticRouter extends DebuggableService {
+    /**
+     * Routes.
+     *
+     * @protected
+     */
+    protected routes: HttpStaticRoute[];
+    /**
+     * Add route.
+     *
+     * @param remotePath
+     * @param resourcePath
+     */
+    addRoute(remotePath: string, resourcePath: string): Promise<this>;
+    /**
+     * Match route.
+     *
+     * @param req
+     */
+    matchRoute(req: IncomingMessage): HttpStaticRoute | undefined;
+    /**
+     * Send file by route.
+     *
+     * @param route
+     * @param req
+     * @param res
+     */
+    sendFileByRoute(route: HttpStaticRoute, req: IncomingMessage, res: ServerResponse): void;
+}
+export {};

package/dist/esm/http-static-router.js

@@ -0,0 +1,141 @@
+import path from 'path';
+import * as fs from 'fs/promises';
+import mimeTypes from 'mime-types';
+import { createReadStream } from 'fs';
+import { Errorf } from '@e22m4u/js-format';
+import { DebuggableService } from './services/index.js';
+/**
+ * Http static router.
+ */
+export class HttpStaticRouter extends DebuggableService {
+    /**
+     * Routes.
+     *
+     * @protected
+     */
+    routes = [];
+    /**
+     * Add route.
+     *
+     * @param remotePath
+     * @param resourcePath
+     */
+    async addRoute(remotePath, resourcePath) {
+        const debug = this.getDebuggerFor(this.addRoute);
+        resourcePath = path.resolve(resourcePath);
+        debug('Adding a new route.');
+        debug('Resource path is %v.', resourcePath);
+        debug('Remote path is %v.', remotePath);
+        let stats;
+        try {
+            stats = await fs.stat(resourcePath);
+        }
+        catch (error) {
+            // если ресурс не существует в момент старта,
+            // это может быть ошибкой конфигурации
+            console.error(error);
+            throw new Errorf('Static resource path does not exist %v.', resourcePath);
+        }
+        const isFile = stats.isFile();
+        debug('Resource type is %s.', isFile ? 'File' : 'Folder');
+        const regexp = new RegExp(`^${remotePath}`, 'i');
+        const route = { remotePath, resourcePath, regexp, isFile };
+        this.routes.push(route);
+        return this;
+    }
+    /**
+     * Match route.
+     *
+     * @param req
+     */
+    matchRoute(req) {
+        const debug = this.getDebuggerFor(this.matchRoute);
+        debug('Matching route by incoming request.');
+        const url = req.url || '/';
+        debug('Incoming request is %s %v.', req.method, url);
+        debug('Walking through %v routes.', this.routes.length);
+        const route = this.routes.find(route => {
+            const res = route.regexp.test(url);
+            const phrase = res ? 'matched' : 'not matched';
+            debug('Resource %v %s.', route.resourcePath, phrase);
+            return res;
+        });
+        route
+            ? debug('Resource %v matched.', route.resourcePath)
+            : debug('No route matched.');
+        return route;
+    }
+    /**
+     * Send file by route.
+     *
+     * @param route
+     * @param req
+     * @param res
+     */
+    sendFileByRoute(route, req, res) {
+        const reqUrl = (req.url || '/').replace(/\?.*$/, '');
+        // так как в html обычно используются относительные
+        // пути, то адрес папки статических ресурсов должен
+        // завершаться косой чертой, что бы файлы стилей и
+        // изображений загружались именно из нее,
+        // а не обращались на уровень выше
+        if (/[^/]$/.test(route.remotePath) && reqUrl === route.remotePath) {
+            res.writeHead(302, { location: `${reqUrl}/` });
+            res.end();
+            return;
+        }
+        // если ресурс ссылается на папку, то из адреса
+        // запроса извлекается относительный путь до файла,
+        // и объединяется с адресом ресурса
+        let filePath = route.resourcePath;
+        if (!route.isFile) {
+            // формирование относительного пути до файла
+            // путем удаления из пути запроса той части,
+            // которая была указана при объявлении маршрута
+            let relativePath = reqUrl.replace(new RegExp(`^${route.remotePath}`), '');
+            // если относительный путь указывает
+            // на корень, то подставляется index.html
+            if (!relativePath || relativePath === '/')
+                relativePath = '/index.html';
+            // объединение адреса ресурса
+            // с относительным путем до файла
+            filePath = path.join(route.resourcePath, relativePath);
+        }
+        // если обнаружена попытка выхода за пределы
+        // корневой директории, то выбрасывается ошибка
+        const resolvedPath = path.resolve(filePath);
+        const resourceRoot = path.resolve(route.resourcePath);
+        if (!resolvedPath.startsWith(resourceRoot)) {
+            res.writeHead(403, { 'content-type': 'text/plain' });
+            res.end('403 Forbidden');
+            return;
+        }
+        // формирование заголовка "content-type"
+        // в зависимости от расширения файла
+        const extname = path.extname(resolvedPath);
+        const contentType = mimeTypes.contentType(extname) || 'application/octet-stream';
+        // файл читается и отправляется частями,
+        // что значительно снижает использование памяти
+        const fileStream = createReadStream(resolvedPath);
+        fileStream.on('error', error => {
+            if (res.headersSent)
+                return;
+            if ('code' in error && error.code === 'ENOENT') {
+                res.writeHead(404, { 'content-type': 'text/plain' });
+                res.write('404 Not Found');
+                res.end();
+            }
+            else {
+                res.writeHead(500, { 'content-type': 'text/plain' });
+                res.write('500 Internal Server Error');
+                res.end();
+            }
+        });
+        // отправка заголовка 200, только после
+        // этого начинается отдача файла
+        fileStream.on('open', () => {
+            res.writeHead(200, { 'content-type': contentType });
+            fileStream.pipe(res);
+        });
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export * from './http-static-router.js';

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from './http-static-router.js';

package/dist/esm/services/debuggable-service.d.ts

@@ -0,0 +1,27 @@
+import { Callable } from '../types.js';
+import { Debugger } from '@e22m4u/js-debug';
+import { Service } from '@e22m4u/js-service';
+import { ServiceContainer } from '@e22m4u/js-service';
+/**
+ * Service.
+ */
+export declare class DebuggableService extends Service {
+    /**
+     * Debug.
+     */
+    debug: Debugger;
+    /**
+     * Возвращает функцию-отладчик с сегментом пространства имен
+     * указанного в параметре метода.
+     *
+     * @param method
+     * @protected
+     */
+    protected getDebuggerFor(method: Callable): Debugger;
+    /**
+     * Constructor.
+     *
+     * @param container
+     */
+    constructor(container?: ServiceContainer);
+}

package/dist/esm/services/debuggable-service.js

@@ -0,0 +1,34 @@
+import { Service } from '@e22m4u/js-service';
+import { toCamelCase } from '../utils/index.js';
+import { createDebugger } from '@e22m4u/js-debug';
+/**
+ * Service.
+ */
+export class DebuggableService extends Service {
+    /**
+     * Debug.
+     */
+    debug;
+    /**
+     * Возвращает функцию-отладчик с сегментом пространства имен
+     * указанного в параметре метода.
+     *
+     * @param method
+     * @protected
+     */
+    getDebuggerFor(method) {
+        return this.debug.withHash().withNs(method.name);
+    }
+    /**
+     * Constructor.
+     *
+     * @param container
+     */
+    constructor(container) {
+        super(container);
+        const serviceName = toCamelCase(this.constructor.name);
+        this.debug = createDebugger(serviceName).withoutEnvNs();
+        const debug = this.debug.withNs('constructor').withHash();
+        debug('Service created.');
+    }
+}

package/dist/esm/services/index.d.ts

@@ -0,0 +1 @@
+export * from './debuggable-service.js';

package/dist/esm/services/index.js

@@ -0,0 +1 @@
+export * from './debuggable-service.js';

package/dist/esm/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A callable type with the "new" operator
+ * that allows class and constructor types.
+ */
+export interface Constructor<T = object> {
+    new (...args: any[]): T;
+}
+/**
+ * An object prototype that excludes
+ * function and scalar values.
+ */
+export type Prototype<T = object> = T & object & {
+    bind?: never;
+} & {
+    call?: never;
+} & {
+    prototype?: object;
+};
+/**
+ * A function type without class and constructor.
+ */
+export type Callable<T = unknown> = (...args: any[]) => T;
+/**
+ * Makes a specific property of T as optional.
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * A part of the Flatten type.
+ */
+export type Identity<T> = T;
+/**
+ * Makes T more human-readable.
+ */
+export type Flatten<T> = Identity<{
+    [k in keyof T]: T[k];
+}>;

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './to-camel-case.js';

package/dist/esm/utils/index.js

@@ -0,0 +1 @@
+export * from './to-camel-case.js';

package/dist/esm/utils/to-camel-case.d.ts

@@ -0,0 +1,6 @@
+/**
+ * To camel case.
+ *
+ * @param input
+ */
+export declare function toCamelCase(input: string): string;

package/dist/esm/utils/to-camel-case.js

@@ -0,0 +1,11 @@
+/**
+ * To camel case.
+ *
+ * @param input
+ */
+export function toCamelCase(input) {
+    return input
+        .replace(/(^\w|[A-Z]|\b\w)/g, c => c.toUpperCase())
+        .replace(/\W+/g, '')
+        .replace(/(^\w)/g, c => c.toLowerCase());
+}

package/eslint.config.js

@@ -0,0 +1,42 @@
+import globals from 'globals';
+import eslintJs from '@eslint/js';
+import eslintTypescript from 'typescript-eslint';
+import eslintMochaPlugin from 'eslint-plugin-mocha';
+import eslintPrettierConfig from 'eslint-config-prettier';
+import eslintChaiExpectPlugin from 'eslint-plugin-chai-expect';
+
+export default [
+  {
+    ignores: ['**/*.js'],
+  },
+  {
+    files: ['src/**/*.ts'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.es2021,
+        ...globals.mocha,
+      },
+      parser: eslintTypescript.parser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    plugins: {
+      '@typescript-eslint': eslintTypescript.plugin,
+      'mocha': eslintMochaPlugin,
+      'chai-expect': eslintChaiExpectPlugin,
+    },
+    rules: {
+      ...eslintJs.configs.recommended.rules,
+      ...eslintPrettierConfig.rules,
+      ...eslintMochaPlugin.configs.recommended.rules,
+      ...eslintTypescript.configs.recommended.reduce(
+        (rules, config) => ({...rules, ...config.rules}),
+        {},
+      ),
+      '@typescript-eslint/no-unused-expressions': 0,
+    },
+  },
+];

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@e22m4u/js-http-static-router",
+  "version": "0.0.7",
+  "description": "HTTP-маршрутизатор статичных ресурсов",
+  "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
+  "license": "MIT",
+  "keywords": [
+    "static",
+    "router",
+    "http"
+  ],
+  "homepage": "https://github.com/e22m4u/js-http-static-router",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/e22m4u/js-http-static-router.git"
+  },
+  "type": "module",
+  "types": "./dist/esm/index.d.ts",
+  "module": "./dist/esm/index.js",
+  "main": "./dist/cjs/index.cjs",
+  "exports": {
+    "types": "./dist/esm/index.d.ts",
+    "import": "./dist/esm/index.js",
+    "require": "./dist/cjs/index.cjs"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "scripts": {
+    "build:esm": "tsc --build",
+    "build:cjs": "rimraf ./dist/cjs && node --no-warnings=ExperimentalWarning build-cjs.js",
+    "build": "rimraf dist && npm run build:esm && npm run build:cjs",
+    "postbuild": "rimraf ./dist/**/*.spec.* --glob ./dist/tsconfig.tsbuildinfo",
+    "lint": "eslint ./src",
+    "lint:fix": "eslint ./src --fix",
+    "format": "prettier --write \"./src/**/*.ts\"",
+    "test": "npm run lint && c8 --reporter=text-summary mocha --bail",
+    "test:coverage": "npm run lint && c8 --reporter=text mocha --bail",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@e22m4u/js-debug": "~0.3.1",
+    "@e22m4u/js-format": "~0.2.0",
+    "@e22m4u/js-service": "~0.4.2",
+    "mime-types": "~3.0.1"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "~20.1.0",
+    "@commitlint/config-conventional": "~20.0.0",
+    "@eslint/js": "~9.37.0",
+    "@types/chai": "~5.2.2",
+    "@types/mime-types": "^3.0.1",
+    "@types/mocha": "~10.0.10",
+    "@types/node": "~24.7.0",
+    "c8": "~10.1.3",
+    "chai": "~6.2.0",
+    "esbuild": "~0.25.10",
+    "eslint": "~9.37.0",
+    "eslint-config-prettier": "~10.1.8",
+    "eslint-plugin-chai-expect": "~3.1.0",
+    "eslint-plugin-mocha": "~11.2.0",
+    "globals": "~16.4.0",
+    "husky": "~9.1.7",
+    "mocha": "~11.7.4",
+    "prettier": "~3.6.2",
+    "rimraf": "~6.0.1",
+    "tsx": "~4.20.6",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "~8.46.0"
+  }
+}

package/src/http-static-router.ts

@@ -0,0 +1,158 @@
+import path from 'path';
+import * as fs from 'fs/promises';
+import mimeTypes from 'mime-types';
+import {createReadStream} from 'fs';
+import {ServerResponse} from 'node:http';
+import {Errorf} from '@e22m4u/js-format';
+import {IncomingMessage} from 'node:http';
+import {DebuggableService} from './services/index.js';
+
+/**
+ * Static file route.
+ */
+type HttpStaticRoute = {
+  remotePath: string;
+  resourcePath: string;
+  regexp: RegExp;
+  isFile: boolean;
+};
+
+/**
+ * Http static router.
+ */
+export class HttpStaticRouter extends DebuggableService {
+  /**
+   * Routes.
+   *
+   * @protected
+   */
+  protected routes: HttpStaticRoute[] = [];
+
+  /**
+   * Add route.
+   *
+   * @param remotePath
+   * @param resourcePath
+   */
+  async addRoute(remotePath: string, resourcePath: string): Promise<this> {
+    const debug = this.getDebuggerFor(this.addRoute);
+    resourcePath = path.resolve(resourcePath);
+    debug('Adding a new route.');
+    debug('Resource path is %v.', resourcePath);
+    debug('Remote path is %v.', remotePath);
+    let stats;
+    try {
+      stats = await fs.stat(resourcePath);
+    } catch (error) {
+      // если ресурс не существует в момент старта,
+      // это может быть ошибкой конфигурации
+      console.error(error);
+      throw new Errorf('Static resource path does not exist %v.', resourcePath);
+    }
+    const isFile = stats.isFile();
+    debug('Resource type is %s.', isFile ? 'File' : 'Folder');
+    const regexp = new RegExp(`^${remotePath}`, 'i');
+    const route = {remotePath, resourcePath, regexp, isFile};
+    this.routes.push(route);
+    return this;
+  }
+
+  /**
+   * Match route.
+   *
+   * @param req
+   */
+  matchRoute(req: IncomingMessage) {
+    const debug = this.getDebuggerFor(this.matchRoute);
+    debug('Matching route by incoming request.');
+    const url = req.url || '/';
+    debug('Incoming request is %s %v.', req.method, url);
+    debug('Walking through %v routes.', this.routes.length);
+    const route = this.routes.find(route => {
+      const res = route.regexp.test(url);
+      const phrase = res ? 'matched' : 'not matched';
+      debug('Resource %v %s.', route.resourcePath, phrase);
+      return res;
+    });
+    route
+      ? debug('Resource %v matched.', route.resourcePath)
+      : debug('No route matched.');
+    return route;
+  }
+
+  /**
+   * Send file by route.
+   *
+   * @param route
+   * @param req
+   * @param res
+   */
+  sendFileByRoute(
+    route: HttpStaticRoute,
+    req: IncomingMessage,
+    res: ServerResponse,
+  ) {
+    const reqUrl = (req.url || '/').replace(/\?.*$/, '');
+    // так как в html обычно используются относительные
+    // пути, то адрес папки статических ресурсов должен
+    // завершаться косой чертой, что бы файлы стилей и
+    // изображений загружались именно из нее,
+    // а не обращались на уровень выше
+    if (/[^/]$/.test(route.remotePath) && reqUrl === route.remotePath) {
+      res.writeHead(302, {location: `${reqUrl}/`});
+      res.end();
+      return;
+    }
+    // если ресурс ссылается на папку, то из адреса
+    // запроса извлекается относительный путь до файла,
+    // и объединяется с адресом ресурса
+    let filePath = route.resourcePath;
+    if (!route.isFile) {
+      // формирование относительного пути до файла
+      // путем удаления из пути запроса той части,
+      // которая была указана при объявлении маршрута
+      let relativePath = reqUrl.replace(new RegExp(`^${route.remotePath}`), '');
+      // если относительный путь указывает
+      // на корень, то подставляется index.html
+      if (!relativePath || relativePath === '/') relativePath = '/index.html';
+      // объединение адреса ресурса
+      // с относительным путем до файла
+      filePath = path.join(route.resourcePath, relativePath);
+    }
+    // если обнаружена попытка выхода за пределы
+    // корневой директории, то выбрасывается ошибка
+    const resolvedPath = path.resolve(filePath);
+    const resourceRoot = path.resolve(route.resourcePath);
+    if (!resolvedPath.startsWith(resourceRoot)) {
+      res.writeHead(403, {'content-type': 'text/plain'});
+      res.end('403 Forbidden');
+      return;
+    }
+    // формирование заголовка "content-type"
+    // в зависимости от расширения файла
+    const extname = path.extname(resolvedPath);
+    const contentType =
+      mimeTypes.contentType(extname) || 'application/octet-stream';
+    // файл читается и отправляется частями,
+    // что значительно снижает использование памяти
+    const fileStream = createReadStream(resolvedPath);
+    fileStream.on('error', error => {
+      if (res.headersSent) return;
+      if ('code' in error && error.code === 'ENOENT') {
+        res.writeHead(404, {'content-type': 'text/plain'});
+        res.write('404 Not Found');
+        res.end();
+      } else {
+        res.writeHead(500, {'content-type': 'text/plain'});
+        res.write('500 Internal Server Error');
+        res.end();
+      }
+    });
+    // отправка заголовка 200, только после
+    // этого начинается отдача файла
+    fileStream.on('open', () => {
+      res.writeHead(200, {'content-type': contentType});
+      fileStream.pipe(res);
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './http-static-router.js';

package/src/services/debuggable-service.spec.ts

@@ -0,0 +1,17 @@
+import {expect} from 'chai';
+import {Service} from '@e22m4u/js-service';
+import {DebuggableService} from './debuggable-service.js';
+
+describe('DebuggableService', function () {
+  it('has the debug method', function () {
+    const res = new DebuggableService();
+    expect(typeof res.debug).to.be.eq('function');
+  });
+
+  describe('constructor', function () {
+    it('extends the Service class', function () {
+      const res = new DebuggableService();
+      expect(res).to.be.instanceof(Service);
+    });
+  });
+});

package/src/services/debuggable-service.ts

@@ -0,0 +1,40 @@
+import {Callable} from '../types.js';
+import {Debugger} from '@e22m4u/js-debug';
+import {Service} from '@e22m4u/js-service';
+import {toCamelCase} from '../utils/index.js';
+import {createDebugger} from '@e22m4u/js-debug';
+import {ServiceContainer} from '@e22m4u/js-service';
+
+/**
+ * Service.
+ */
+export class DebuggableService extends Service {
+  /**
+   * Debug.
+   */
+  debug: Debugger;
+
+  /**
+   * Возвращает функцию-отладчик с сегментом пространства имен
+   * указанного в параметре метода.
+   *
+   * @param method
+   * @protected
+   */
+  protected getDebuggerFor(method: Callable) {
+    return this.debug.withHash().withNs(method.name);
+  }
+
+  /**
+   * Constructor.
+   *
+   * @param container
+   */
+  constructor(container?: ServiceContainer) {
+    super(container);
+    const serviceName = toCamelCase(this.constructor.name);
+    this.debug = createDebugger(serviceName).withoutEnvNs();
+    const debug = this.debug.withNs('constructor').withHash();
+    debug('Service created.');
+  }
+}

package/src/services/index.ts

@@ -0,0 +1 @@
+export * from './debuggable-service.js';

package/src/types.ts

@@ -0,0 +1,38 @@
+/**
+ * A callable type with the "new" operator
+ * that allows class and constructor types.
+ */
+export interface Constructor<T = object> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  new (...args: any[]): T;
+}
+
+/**
+ * An object prototype that excludes
+ * function and scalar values.
+ */
+export type Prototype<T = object> = T &
+  object & {bind?: never} & {
+    call?: never;
+  } & {prototype?: object};
+
+/**
+ * A function type without class and constructor.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Callable<T = unknown> = (...args: any[]) => T;
+
+/**
+ * Makes a specific property of T as optional.
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/**
+ * A part of the Flatten type.
+ */
+export type Identity<T> = T;
+
+/**
+ * Makes T more human-readable.
+ */
+export type Flatten<T> = Identity<{[k in keyof T]: T[k]}>;

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './to-camel-case.js';

package/src/utils/to-camel-case.spec.ts

@@ -0,0 +1,11 @@
+import {expect} from 'chai';
+import {toCamelCase} from './to-camel-case.js';
+
+describe('toCamelCase', function () {
+  it('returns a camelCase string', function () {
+    expect(toCamelCase('TestString')).to.be.eq('testString');
+    expect(toCamelCase('test-string')).to.be.eq('testString');
+    expect(toCamelCase('test string')).to.be.eq('testString');
+    expect(toCamelCase('Test string')).to.be.eq('testString');
+  });
+});

package/src/utils/to-camel-case.ts

@@ -0,0 +1,11 @@
+/**
+ * To camel case.
+ *
+ * @param input
+ */
+export function toCamelCase(input: string): string {
+  return input
+    .replace(/(^\w|[A-Z]|\b\w)/g, c => c.toUpperCase())
+    .replace(/\W+/g, '')
+    .replace(/(^\w)/g, c => c.toLowerCase());
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist/esm",
+    "target": "es2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "incremental": false
+  }
+}