fluxion-ts 0.0.4

package/scripts/configs.ts

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+import type { RollupReplaceOptions } from '@rollup/plugin-replace';
+
+export const getTSConfig = () => {
+  const tsconfigBuildPath = path.join(import.meta.dirname, '..', 'tsconfig.build.json');
+  const tsconfigPath = path.join(import.meta.dirname, '..', 'tsconfig.json');
+  return fs.existsSync(tsconfigBuildPath) ? tsconfigBuildPath : tsconfigPath;
+};
+
+// #region replace options
+
+interface CommonPackageJson {
+  name: string;
+  version: string;
+  description: string;
+  description_zh: string;
+  author: {
+    name: string;
+    email: string;
+  };
+  license: string;
+  repository: {
+    type: string;
+    url: string;
+  };
+}
+
+export function replaceOpts(): RollupReplaceOptions {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(import.meta.dirname, '..', 'package.json'), 'utf-8'),
+  ) as CommonPackageJson;
+  function formatDateFull(dt = new Date()) {
+    const y = dt.getFullYear();
+    const m = String(dt.getMonth() + 1).padStart(2, '0');
+    const d = String(dt.getDate()).padStart(2, '0');
+    const hh = String(dt.getHours()).padStart(2, '0');
+    const mm = String(dt.getMinutes()).padStart(2, '0');
+    const ss = String(dt.getSeconds()).padStart(2, '0');
+    const ms = String(dt.getMilliseconds()).padStart(3, '0');
+    return `${y}.${m}.${d} ${hh}:${mm}:${ss}.${ms}`;
+  }
+
+  const __KEBAB_NAME__ = pkg.name.replace('rollup-plugin-', '');
+  const __VERSION__ = pkg.version;
+  const __NAME__ = __KEBAB_NAME__.replace(/(^|-)(\w)/g, (_, __, c) => c.toUpperCase());
+
+  const __PKG_INFO__ = `## About
+ * @package ${__NAME__}
+ * @author ${pkg.author.name} <${pkg.author.email}>
+ * @version ${pkg.version} (Last Update: ${formatDateFull()})
+ * @license ${pkg.license}
+ * @link ${pkg.repository.url}
+ * @link https://baendlorel.github.io/ Welcome to my site!
+ * @description ${pkg.description.replace(/\n/g, '\n * \n * ')}
+ * @copyright Copyright (c) ${new Date().getFullYear()} ${pkg.author.name}. All rights reserved.`;
+
+  return {
+    preventAssignment: true,
+    delimiters: ['', ''],
+    values: {
+      __IS_DEV__: 'false',
+      __NAME__,
+      __KEBAB_NAME__,
+      __PKG_INFO__,
+      __VERSION__,
+
+      // global error/warn/debug
+      "$throw('": `throw new Error('[${__NAME__} error] `,
+      '$throw(`': `throw new Error(\`[${__NAME__} error] `,
+      '$throw("': `throw new Error("[${__NAME__} error] `,
+      '$warn(': `console.warn('[${__NAME__} warn]',`,
+      '$error(': `console.error('[${__NAME__} error]',`,
+      '$debug(': `console.debug('[${__NAME__} debug]',`,
+    },
+  };
+}
+// #endregion

package/scripts/lines.ts

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ROOT = path.resolve('./packages');
+
+const INCLUDE = ['**/*.{ts,tsx,css}'];
+const EXCLUDE = ['**/node_modules/**', '**/dist/**', '**/*.test.{ts,tsx}'];
+
+let totalLines = 0;
+let fileCount = 0;
+
+function countLines(filePath: string): number {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return content.split(/\r\n|\n|\r/).length;
+}
+
+function resolveFiles(rootDir: string): string[] {
+  const matched = fs
+    .globSync(INCLUDE, {
+      cwd: rootDir,
+      exclude: EXCLUDE,
+    })
+    .map((relativePath) => path.relative(ROOT, path.join(rootDir, relativePath)).replaceAll(path.sep, '/'));
+
+  const unique = Array.from(new Set(matched));
+
+  return unique
+    .filter((relativePath) => fs.existsSync(path.join(ROOT, relativePath)))
+    .sort((a, b) => a.localeCompare(b));
+}
+
+// "lines": "clear && find ./packages -type f \\( -name \"*.ts\" -o -name \"*.tsx\" -o -name \"*.js\" -o -name \"*.mjs\" -o -name \"*.cjs\" \\) | xargs wc -l",
+
+function main() {
+  const subPackage = process.argv[2];
+  const rootDir = subPackage ? path.join(ROOT, subPackage) : ROOT;
+  if (!fs.existsSync(rootDir)) {
+    console.error(`Sub package not found: ${subPackage}`);
+    process.exit(1);
+  }
+
+  const files = resolveFiles(rootDir);
+  for (const relativePath of files) {
+    const fullPath = path.join(ROOT, relativePath);
+    const lines = countLines(fullPath);
+    totalLines += lines;
+    fileCount++;
+    console.log(`${lines.toString().padStart(7)}  ${relativePath}`);
+  }
+
+  console.log(`Files: ${fileCount} for ${INCLUDE.join(', ')}`);
+  console.log(`Total lines: ${totalLines}`);
+}
+main();

package/scripts/publish.ts

@@ -0,0 +1,6 @@
+import { execSync } from 'node:child_process';
+import { bumpVersion } from './bump-version';
+
+bumpVersion();
+execSync('pnpm build', { stdio: 'inherit' });
+execSync('pnpm publish --access public --no-git-checks', { stdio: 'inherit' });

package/src/common/consts.ts

@@ -0,0 +1,30 @@
+export const DUMMY_BASE_URL = 'http://fluxion.local';
+export const META_PREFIX = '/_fluxion';
+
+export const STATIC_CONTENT_TYPES: Record<string, string> = {
+  '.css': 'text/css; charset=utf-8',
+  '.html': 'text/html; charset=utf-8',
+  '.ico': 'image/x-icon',
+  '.js': 'text/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.svg': 'image/svg+xml',
+  '.txt': 'text/plain; charset=utf-8',
+  '.webp': 'image/webp',
+};
+
+export const enum HttpCode {
+  Ok = 200,
+  BadRequest = 400,
+  PayloadTooLarge = 413,
+  NotFound = 404,
+  InternalServerError = 500,
+}
+
+export const enum HandlerResult {
+  NotFound,
+  Handled,
+}

package/src/common/dtm.ts

@@ -0,0 +1,10 @@
+export function dtm(dt = new Date()) {
+  const y = dt.getFullYear();
+  const m = String(dt.getMonth() + 1).padStart(2, '0');
+  const d = String(dt.getDate()).padStart(2, '0');
+  const hh = String(dt.getHours()).padStart(2, '0');
+  const mm = String(dt.getMinutes()).padStart(2, '0');
+  const ss = String(dt.getSeconds()).padStart(2, '0');
+  const ms = String(dt.getMilliseconds()).padStart(3, '0');
+  return `${y}.${m}.${d} ${hh}:${mm}:${ss}.${ms}`;
+}

package/src/common/logger.ts

@@ -0,0 +1,145 @@
+import chalk from 'chalk';
+import { dtm } from './dtm.js';
+
+export type LogLevel = 'INFO' | 'WARN' | 'ERROR' | 'SUCC';
+
+export interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  event: string;
+  message?: string;
+  [key: string]: unknown;
+}
+
+export type LoggerMode = 'one-line' | 'json-line';
+export type LoggerSink = (entry: LogEntry) => void;
+export type LoggerOption = LoggerMode | LoggerSink;
+
+export interface FluxionLogger {
+  write(level: LogLevel, event: string, fields?: Record<string, unknown>): void;
+}
+
+function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return '[unserializable]';
+  }
+}
+
+function omitReservedFields(entry: LogEntry): Record<string, unknown> {
+  const fields: Record<string, unknown> = {};
+  const keys = Object.keys(entry);
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key === 'timestamp' || key === 'level' || key === 'event' || key === 'message') {
+      continue;
+    }
+
+    fields[key] = entry[key];
+  }
+
+  return fields;
+}
+
+function writeOneLine(entry: LogEntry): void {
+  const fields = omitReservedFields(entry);
+  const hasFields = Object.keys(fields).length > 0;
+  const timestampText = chalk.hex('#166534')(`[${entry.timestamp}]`);
+  const levelText = formatLevel(entry.level);
+  const body = entry.message ?? entry.event;
+  const bodyText = chalk.white(body);
+  const fieldsText = hasFields ? ` ${chalk.dim(safeStringify(fields))}` : '';
+
+  console.log(`${timestampText} ${levelText} ${bodyText}${fieldsText}`);
+}
+
+function writeJsonLine(entry: LogEntry): void {
+  console.log(safeStringify(entry));
+}
+
+export function resolveLoggerSink(option: LoggerOption | undefined): LoggerSink {
+  if (option === undefined || option === 'one-line') {
+    return writeOneLine;
+  }
+
+  if (option === 'json-line') {
+    return writeJsonLine;
+  }
+
+  if (typeof option === 'function') {
+    return option;
+  }
+
+  throw new Error('Invalid logger option: expected function | "one-line" | "json-line"');
+}
+
+function formatLevel(level: LogLevel): string {
+  const label = level;
+
+  switch (level) {
+    case 'INFO':
+      return chalk.hex('#38bdf8')(label);
+    case 'WARN':
+      return chalk.hex('#fb923c')(label);
+    case 'ERROR':
+      return chalk.hex('#ef4444')(label);
+    case 'SUCC':
+      return chalk.hex('#22c55e')(label);
+    default:
+      return label;
+  }
+}
+
+export function createLogger(option: LoggerOption | undefined = 'one-line'): FluxionLogger {
+  const sink = resolveLoggerSink(option);
+
+  return {
+    write(level: LogLevel, event: string, fields: Record<string, unknown> = {}): void {
+      const entry: LogEntry = {
+        timestamp: dtm(),
+        level,
+        event,
+      };
+
+      const keys = Object.keys(fields);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+
+        if (key === 'timestamp' || key === 'level' || key === 'event') {
+          continue;
+        }
+
+        entry[key] = fields[key];
+      }
+
+      try {
+        sink(entry);
+      } catch {
+        // Ignore logger sink failures to avoid breaking request handling.
+      }
+    },
+  };
+}
+
+export function getErrorMessage(error: unknown): string {
+  // ! Error.isError needs Node.js 24
+  return Error.isError(error) ? error.message : String(error);
+}
+
+const defaultLogger = createLogger('one-line');
+
+/**
+ * Compatibility helper for existing call sites. Prefer `createLogger().write`.
+ */
+export function logJsonl(level: LogLevel, event: string, fields: Record<string, unknown> = {}): void {
+  defaultLogger.write(level, event, fields);
+}
+
+/**
+ * Compatibility helper for existing call sites. Prefer structured events.
+ */
+export function log(level: LogLevel, message: string, fields: Record<string, unknown> = {}): void {
+  defaultLogger.write(level, 'Message', { message, ...fields });
+}

package/src/core/meta-api.ts

@@ -0,0 +1,48 @@
+import type http from 'node:http';
+
+import type { FileRouteSnapshot, FileWorkerSnapshot } from '@/workers/file-runtime.js';
+import { sendJson } from './utils/send-json.js';
+import type { NormalizedRequest } from './types.js';
+import { META_PREFIX } from '@/common/consts.js';
+
+interface CreateMetaApiOptions {
+  /**
+   * Same as `FluxionOptions.dir`.
+   */
+  dir: string;
+  getRouteSnapshot: () => Promise<FileRouteSnapshot> | FileRouteSnapshot;
+  getWorkerSnapshot: () => Promise<FileWorkerSnapshot> | FileWorkerSnapshot;
+}
+
+export function createMetaApi(options: CreateMetaApiOptions) {
+  return {
+    handleRequest: async (
+      _req: http.IncomingMessage,
+      res: http.ServerResponse,
+      normalized: NormalizedRequest,
+    ): Promise<boolean> => {
+      const pathname = normalized.url.pathname;
+
+      if (normalized.method === 'GET') {
+        if (pathname === META_PREFIX + '/routes') {
+          const routes = await options.getRouteSnapshot();
+          sendJson(res, { routes });
+          return true;
+        }
+
+        if (pathname === META_PREFIX + '/healthz') {
+          sendJson(res, { ok: true, now: Date.now() });
+          return true;
+        }
+
+        if (pathname === META_PREFIX + '/workers') {
+          const workers = await options.getWorkerSnapshot();
+          sendJson(res, { workers });
+          return true;
+        }
+      }
+
+      return false;
+    },
+  };
+}