@ywal123456/jskim 0.1.0

package/scripts/lib/create-project-watcher.js

@@ -0,0 +1,272 @@
+'use strict';
+
+const path = require('node:path');
+const { EventEmitter } = require('node:events');
+const chokidar = require('chokidar');
+const { resolveWatchPaths } = require('./resolve-watch-paths');
+const { runBuild } = require('./build-project');
+
+/**
+ * プロジェクトのファイル監視と全体再ビルドを担当する共通コアです。
+ * watch.js / dev.js の両方から再利用します。
+ *
+ * イベント:
+ * - change({ events })
+ * - build:start({ initial, events })
+ * - build:success({ initial, result, events })
+ * - build:failure({ initial, error, events })
+ * - ready({ displayPaths, debounceMs })
+ * - error(err)
+ *
+ * @param {object} project 解決済みプロジェクト
+ * @param {object} [options]
+ * @param {boolean} [options.runInitialBuild=true]
+ * @param {boolean} [options.logChanges=true]
+ * @returns {EventEmitter & { start: Function, close: Function, displayPaths: string[] }}
+ */
+function createProjectWatcher(project, options = {}) {
+  const runInitialBuild = options.runInitialBuild !== false;
+  const logChanges = options.logChanges !== false;
+  const workspaceRoot = project.workspaceRoot;
+  const debounceMs = project.watch.debounce;
+
+  const { absolutePaths, displayPaths } = resolveWatchPaths(project);
+  const emitter = new EventEmitter();
+
+  let chokidarWatcher = null;
+  let debounceTimer = null;
+  let building = false;
+  let rebuildPending = false;
+  let stopping = false;
+  let started = false;
+  let pendingEvents = [];
+  let buildPromise = null;
+
+  async function start(startOptions = {}) {
+    if (started && chokidarWatcher) {
+      return;
+    }
+
+    const watchFiles = startOptions.watchFiles !== false;
+
+    if (!started) {
+      started = true;
+      if (runInitialBuild) {
+        await executeBuild({ initial: true, events: [] });
+      }
+    }
+
+    if (watchFiles) {
+      beginWatching();
+    }
+  }
+
+  function beginWatching() {
+    if (chokidarWatcher || stopping) {
+      return;
+    }
+
+    emitter.emit('ready', { displayPaths, debounceMs });
+
+    chokidarWatcher = chokidar.watch(absolutePaths, {
+      ignoreInitial: true,
+      persistent: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 50,
+        pollInterval: 25,
+      },
+      ignored: [
+        /(^|[/\\])node_modules([/\\]|$)/,
+        /(^|[/\\])dist([/\\]|$)/,
+      ],
+    });
+
+    chokidarWatcher.on('all', (eventName, filePath) => {
+      if (
+        eventName === 'add' ||
+        eventName === 'addDir' ||
+        eventName === 'change' ||
+        eventName === 'unlink' ||
+        eventName === 'unlinkDir'
+      ) {
+        queueChange(eventName, filePath);
+      }
+    });
+
+    chokidarWatcher.on('error', (err) => {
+      const message = err && err.message ? err.message : String(err);
+      console.error(`[JSKim] ウォッチャーエラー: ${message}`);
+      emitter.emit('error', err);
+    });
+  }
+
+  async function startWatching() {
+    if (!started && runInitialBuild) {
+      started = true;
+      await executeBuild({ initial: true, events: [] });
+    }
+    started = true;
+    beginWatching();
+  }
+
+  function queueChange(eventName, filePath) {
+    if (stopping) {
+      return;
+    }
+
+    pendingEvents.push({
+      event: eventName,
+      file: toDisplayPath(filePath, workspaceRoot),
+    });
+
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      triggerBuild();
+    }, debounceMs);
+  }
+
+  function triggerBuild() {
+    if (stopping) {
+      return;
+    }
+
+    if (building) {
+      rebuildPending = true;
+      return;
+    }
+
+    const events = pendingEvents;
+    pendingEvents = [];
+    building = true;
+
+    buildPromise = (async () => {
+      try {
+        await executeBuild({ initial: false, events });
+      } finally {
+        building = false;
+        buildPromise = null;
+
+        if (!stopping && rebuildPending) {
+          rebuildPending = false;
+          triggerBuild();
+        }
+      }
+    })();
+  }
+
+  async function executeBuild({ initial, events }) {
+    if (!initial) {
+      if (logChanges) {
+        logChangeSummary(events);
+      }
+      emitter.emit('change', { events });
+    }
+
+    emitter.emit('build:start', { initial, events });
+
+    try {
+      const result = await runBuild(project, {
+        logTitle: initial ? 'ビルドが完了しました' : '再ビルドが完了しました',
+        includeOutput: initial,
+      });
+      emitter.emit('build:success', { initial, result, events });
+      return result;
+    } catch (err) {
+      const message = err && err.message ? err.message : String(err);
+
+      if (initial) {
+        console.error(message);
+        console.error(
+          `[JSKim] プロジェクト "${project.name}" の初回ビルドに失敗しました。ウォッチャーは開始します。`
+        );
+      } else {
+        const representative = events[events.length - 1] || null;
+        console.error(`[JSKim] 再ビルドに失敗しました`);
+        console.error(`プロジェクト: ${project.name}`);
+        if (representative) {
+          console.error(`イベント: ${representative.event}`);
+          console.error(`ファイル: ${representative.file}`);
+        }
+        if (events.length > 1) {
+          console.error(`変更数: ${events.length} ファイル`);
+        }
+        console.error(`原因: ${message}`);
+        console.error(
+          `[JSKim] ウォッチャーは継続中です。修正して保存すると再試行します。`
+        );
+      }
+
+      emitter.emit('build:failure', { initial, error: err, events });
+      return null;
+    }
+  }
+
+  async function close() {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+
+    if (chokidarWatcher) {
+      try {
+        await chokidarWatcher.close();
+      } catch {
+        // 終了時の close エラーは無視
+      }
+      chokidarWatcher = null;
+    }
+
+    if (buildPromise) {
+      try {
+        await buildPromise;
+      } catch {
+        // 再ビルドエラーは既にログ済み
+      }
+    }
+  }
+
+  emitter.start = start;
+  emitter.startWatching = startWatching;
+  emitter.close = close;
+  emitter.displayPaths = displayPaths;
+  emitter.debounceMs = debounceMs;
+
+  return emitter;
+}
+
+function logChangeSummary(events) {
+  if (!events || events.length === 0) {
+    console.log('[JSKim] 変更を検知しました');
+    return;
+  }
+
+  const last = events[events.length - 1];
+  console.log('[JSKim] 変更を検知しました');
+  console.log(`イベント: ${last.event}`);
+  console.log(`ファイル: ${last.file}`);
+  if (events.length > 1) {
+    console.log(`まとめた変更: ${events.length}`);
+  }
+}
+
+function toDisplayPath(filePath, workspaceRoot) {
+  const abs = path.resolve(filePath);
+  const rel = path.relative(workspaceRoot, abs);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) {
+    return abs.split(path.sep).join('/');
+  }
+  return rel.split(path.sep).join('/');
+}
+
+module.exports = {
+  createProjectWatcher,
+};

package/scripts/lib/create-static-server.js

@@ -0,0 +1,351 @@
+'use strict';
+
+const http = require('node:http');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const { pipeline } = require('node:stream/promises');
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.mjs': 'application/javascript; charset=utf-8',
+  '.cjs': 'application/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.ico': 'image/x-icon',
+  '.txt': 'text/plain; charset=utf-8',
+  '.xml': 'application/xml; charset=utf-8',
+  '.pdf': 'application/pdf',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.map': 'application/json; charset=utf-8',
+};
+
+/**
+ * outputDir をルートとするローカル静的 HTTP サーバーを作成します。
+ * serve / dev の両方から再利用します。
+ *
+ * @param {object} options
+ * @param {string} options.rootDir 提供ルート（通常は outputDir）
+ * @param {string} options.host
+ * @param {number} options.port
+ * @param {string} [options.projectName]
+ * @param {(html: string, meta: object) => string|Promise<string>} [options.transformHtml]
+ * @param {(req, res, meta: object) => boolean|Promise<boolean>} [options.handleInternalRequest]
+ * @returns {{ server: import('node:http').Server, start: Function, stop: Function, url: string }}
+ */
+function createStaticServer({
+  rootDir,
+  host,
+  port,
+  projectName,
+  transformHtml,
+  handleInternalRequest,
+}) {
+  const rootResolved = path.resolve(rootDir);
+  const displayName = projectName || '';
+
+  const server = http.createServer((req, res) => {
+    handleRequest(req, res, {
+      rootDir: rootResolved,
+      projectName: displayName,
+      transformHtml,
+      handleInternalRequest,
+    }).catch((err) => {
+      const message = err && err.message ? err.message : String(err);
+      console.error(
+        `[JSKim] リクエスト処理中にエラーが発生しました。\n` +
+          (displayName ? `プロジェクト: ${displayName}\n` : '') +
+          `原因: ${message}`
+      );
+      if (!res.headersSent) {
+        sendText(res, 500, 'ファイルの読み込み中にエラーが発生しました。\n');
+      } else {
+        res.destroy();
+      }
+    });
+  });
+
+  const url = `http://${host}:${port}/`;
+
+  function start() {
+    return new Promise((resolve, reject) => {
+      const onError = (err) => {
+        server.off('listening', onListening);
+        reject(err);
+      };
+      const onListening = () => {
+        server.off('error', onError);
+        resolve({
+          host,
+          port,
+          url,
+          rootDir: rootResolved,
+        });
+      };
+
+      server.once('error', onError);
+      server.once('listening', onListening);
+      server.listen(port, host);
+    });
+  }
+
+  function stop() {
+    return new Promise((resolve, reject) => {
+      if (!server.listening) {
+        resolve();
+        return;
+      }
+      server.close((err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+
+  return { server, start, stop, url, rootDir: rootResolved };
+}
+
+async function handleRequest(req, res, context) {
+  const method = (req.method || 'GET').toUpperCase();
+
+  let pathname;
+  try {
+    const base = 'http://127.0.0.1';
+    const parsed = new URL(req.url || '/', base);
+    pathname = decodeURIComponent(parsed.pathname);
+  } catch {
+    sendText(res, 400, 'リクエストURLが不正です。\n');
+    return;
+  }
+
+  const normalizedPath = pathname.replace(/\\/g, '/');
+
+  if (typeof context.handleInternalRequest === 'function') {
+    const handled = await context.handleInternalRequest(req, res, {
+      pathname: normalizedPath,
+      method,
+    });
+    if (handled) {
+      return;
+    }
+  }
+
+  if (method !== 'GET' && method !== 'HEAD') {
+    res.setHeader('Allow', 'GET, HEAD');
+    sendText(res, 405, 'このHTTPメソッドは使用できません。\n');
+    return;
+  }
+
+  const relativeUrlPath = normalizedPath.replace(/^\/+/, '');
+
+  let candidatePath;
+  if (relativeUrlPath === '' || normalizedPath.endsWith('/')) {
+    candidatePath = path.join(
+      context.rootDir,
+      relativeUrlPath,
+      'index.html'
+    );
+  } else {
+    candidatePath = path.join(context.rootDir, relativeUrlPath);
+  }
+
+  const safePath = await resolveSafePath(context.rootDir, candidatePath);
+  if (!safePath) {
+    sendText(res, 404, 'ファイルが見つかりません。\n');
+    return;
+  }
+
+  let stat;
+  try {
+    stat = await fsp.stat(safePath);
+  } catch {
+    sendText(res, 404, 'ファイルが見つかりません。\n');
+    return;
+  }
+
+  if (stat.isDirectory()) {
+    const indexPath = path.join(safePath, 'index.html');
+    const safeIndex = await resolveSafePath(context.rootDir, indexPath);
+    if (!safeIndex) {
+      sendText(res, 404, 'ファイルが見つかりません。\n');
+      return;
+    }
+    try {
+      const indexStat = await fsp.stat(safeIndex);
+      if (!indexStat.isFile()) {
+        sendText(res, 404, 'ファイルが見つかりません。\n');
+        return;
+      }
+      await sendFile(req, res, safeIndex, indexStat, method, context);
+    } catch {
+      sendText(res, 404, 'ファイルが見つかりません。\n');
+    }
+    return;
+  }
+
+  if (!stat.isFile()) {
+    sendText(res, 404, 'ファイルが見つかりません。\n');
+    return;
+  }
+
+  await sendFile(req, res, safePath, stat, method, context);
+}
+
+async function resolveSafePath(rootDir, candidatePath) {
+  const root = path.resolve(rootDir);
+  const resolvedCandidate = path.resolve(candidatePath);
+
+  if (!isInsideOrSame(root, resolvedCandidate)) {
+    return null;
+  }
+
+  try {
+    const realRoot = await fsp.realpath(root);
+    let realCandidate;
+    try {
+      realCandidate = await fsp.realpath(resolvedCandidate);
+    } catch (err) {
+      if (err && err.code === 'ENOENT') {
+        const parent = path.dirname(resolvedCandidate);
+        const base = path.basename(resolvedCandidate);
+        let realParent;
+        try {
+          realParent = await fsp.realpath(parent);
+        } catch {
+          return null;
+        }
+        realCandidate = path.join(realParent, base);
+      } else {
+        return null;
+      }
+    }
+
+    if (!isInsideOrSame(realRoot, realCandidate)) {
+      return null;
+    }
+
+    return realCandidate;
+  } catch {
+    return null;
+  }
+}
+
+async function sendFile(req, res, filePath, stat, method, context) {
+  const ext = path.extname(filePath).toLowerCase();
+  const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+  const shouldTransform =
+    typeof context.transformHtml === 'function' && ext === '.html';
+
+  if (shouldTransform) {
+    let html;
+    try {
+      html = await fsp.readFile(filePath, 'utf8');
+    } catch (err) {
+      const message = err && err.message ? err.message : String(err);
+      console.error(
+        `[JSKim] ファイルの読み込みに失敗しました。\n` +
+          `原因: ${message}`
+      );
+      sendText(res, 500, 'ファイルの読み込み中にエラーが発生しました。\n');
+      return;
+    }
+
+    const transformed = await context.transformHtml(html, {
+      filePath,
+      req,
+      method,
+    });
+    const body = Buffer.from(
+      typeof transformed === 'string' ? transformed : html,
+      'utf8'
+    );
+
+    res.statusCode = 200;
+    res.setHeader('Content-Type', contentType);
+    res.setHeader('Content-Length', String(body.length));
+    res.setHeader('Cache-Control', 'no-store');
+
+    if (method === 'HEAD') {
+      res.end();
+      return;
+    }
+
+    res.end(body);
+    return;
+  }
+
+  res.statusCode = 200;
+  res.setHeader('Content-Type', contentType);
+  res.setHeader('Content-Length', String(stat.size));
+  res.setHeader('Cache-Control', 'no-store');
+
+  if (method === 'HEAD') {
+    res.end();
+    return;
+  }
+
+  const stream = fs.createReadStream(filePath);
+  stream.on('error', (err) => {
+    const message = err && err.message ? err.message : String(err);
+    console.error(
+      `[JSKim] ファイルの読み込みに失敗しました。\n` +
+        `原因: ${message}`
+    );
+    if (!res.headersSent) {
+      sendText(res, 500, 'ファイルの読み込み中にエラーが発生しました。\n');
+    } else {
+      res.destroy();
+    }
+  });
+
+  try {
+    await pipeline(stream, res);
+  } catch (err) {
+    if (err && err.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+      return;
+    }
+  }
+}
+
+function sendText(res, statusCode, body) {
+  const payload = Buffer.from(body, 'utf8');
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+  res.setHeader('Content-Length', String(payload.length));
+  res.setHeader('Cache-Control', 'no-store');
+  res.end(payload);
+}
+
+function samePath(a, b) {
+  const na = path.resolve(a);
+  const nb = path.resolve(b);
+  if (process.platform === 'win32') {
+    return na.toLowerCase() === nb.toLowerCase();
+  }
+  return na === nb;
+}
+
+function isInsideOrSame(parent, child) {
+  if (samePath(parent, child)) {
+    return true;
+  }
+  const rel = path.relative(path.resolve(parent), path.resolve(child));
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+module.exports = {
+  createStaticServer,
+  MIME_TYPES,
+};

package/scripts/lib/load-config.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const path = require('node:path');
+
+const CONFIG_FILENAME = 'jskim.config.js';
+
+/**
+ * ワークスペースルートから jskim.config.js を読み込みます。
+ * @param {string} workspaceRoot
+ * @returns {object}
+ */
+function loadConfig(workspaceRoot) {
+  const configPath = path.join(workspaceRoot, CONFIG_FILENAME);
+
+  let config;
+  try {
+    // 同一プロセス内の再実行でも最新設定を読むためキャッシュを消す
+    delete require.cache[require.resolve(configPath)];
+    config = require(configPath);
+  } catch (err) {
+    if (err && err.code === 'MODULE_NOT_FOUND') {
+      const missingConfig =
+        typeof err.message === 'string' &&
+        err.message.includes(CONFIG_FILENAME);
+
+      if (missingConfig) {
+        throw new Error(
+          `[JSKim] 設定ファイルが見つかりません: ${configPath}\n` +
+            `ワークスペースルートに ${CONFIG_FILENAME} を作成してください。`
+        );
+      }
+    }
+
+    throw new Error(
+      `[JSKim] 設定ファイルの読み込みに失敗しました: ${configPath}\n` +
+        `原因: ${err && err.message ? err.message : String(err)}`
+    );
+  }
+
+  if (!config || typeof config !== 'object') {
+    throw new Error(
+      `[JSKim] 設定が不正です: ${configPath}\n` +
+        `原因: module.exports はオブジェクトである必要があります。`
+    );
+  }
+
+  if (!config.projects || typeof config.projects !== 'object') {
+    throw new Error(
+      `[JSKim] 設定が不正です: projects が無い、またはオブジェクトではありません。\n` +
+        `設定: ${configPath}`
+    );
+  }
+
+  return {
+    config,
+    configPath,
+    workspaceRoot,
+  };
+}
+
+module.exports = {
+  loadConfig,
+  CONFIG_FILENAME,
+};