@ywal123456/jskim 0.1.0

package/scripts/lib/clean-output.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+const fse = require('fs-extra');
+
+/**
+ * ビルド前に outputDir だけを安全に削除します。
+ *
+ * 次のパスは削除しません:
+ * - ファイルシステムルート
+ * - ワークスペースルート
+ * - sourceDir
+ * - sourceDir の祖先
+ * - 空 / 不正なパス
+ *
+ * @param {object} options
+ * @param {string} options.outputDir
+ * @param {string} options.sourceDir
+ * @param {string} options.workspaceRoot
+ * @param {string} options.projectName
+ */
+async function cleanOutput({
+  outputDir,
+  sourceDir,
+  workspaceRoot,
+  projectName,
+}) {
+  const resolvedOutput = path.resolve(outputDir);
+  const resolvedSource = path.resolve(sourceDir);
+  const resolvedWorkspace = path.resolve(workspaceRoot);
+
+  assertSafeToClean({
+    outputDir: resolvedOutput,
+    sourceDir: resolvedSource,
+    workspaceRoot: resolvedWorkspace,
+    projectName,
+  });
+
+  if (fs.existsSync(resolvedOutput)) {
+    await fse.remove(resolvedOutput);
+  }
+}
+
+function assertSafeToClean({
+  outputDir,
+  sourceDir,
+  workspaceRoot,
+  projectName,
+}) {
+  if (!outputDir || String(outputDir).trim() === '') {
+    throw new Error(
+      `[JSKim] クリーンを拒否しました: outputDir が空です。\n` +
+        `プロジェクト: ${projectName}`
+    );
+  }
+
+  const parsed = path.parse(outputDir);
+  // ファイルシステムルート（例: C:\ や /）
+  if (outputDir === parsed.root || outputDir === path.sep) {
+    throw new Error(
+      `[JSKim] クリーンを拒否しました: outputDir がファイルシステムルートです。\n` +
+        `プロジェクト: ${projectName}\n` +
+        `パス: ${outputDir}`
+    );
+  }
+
+  if (samePath(outputDir, workspaceRoot)) {
+    throw new Error(
+      `[JSKim] クリーンを拒否しました: outputDir がワークスペースルートです。\n` +
+        `プロジェクト: ${projectName}\n` +
+        `パス: ${outputDir}`
+    );
+  }
+
+  if (samePath(outputDir, sourceDir)) {
+    throw new Error(
+      `[JSKim] クリーンを拒否しました: outputDir が sourceDir と同じです。\n` +
+        `プロジェクト: ${projectName}\n` +
+        `パス: ${outputDir}`
+    );
+  }
+
+  if (isAncestorPath(outputDir, sourceDir)) {
+    throw new Error(
+      `[JSKim] クリーンを拒否しました: outputDir が sourceDir の祖先です。\n` +
+        `プロジェクト: ${projectName}\n` +
+        `outputDir: ${outputDir}\n` +
+        `sourceDir: ${sourceDir}`
+    );
+  }
+}
+
+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;
+}
+
+/**
+ * ancestor が descendant の厳密な祖先ディレクトリなら true。
+ */
+function isAncestorPath(ancestor, descendant) {
+  const a = path.resolve(ancestor);
+  const d = path.resolve(descendant);
+  if (samePath(a, d)) {
+    return false;
+  }
+  const rel = path.relative(a, d);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+module.exports = {
+  cleanOutput,
+  assertSafeToClean,
+};

package/scripts/lib/copy-files.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const path = require('node:path');
+const fse = require('fs-extra');
+const fg = require('fast-glob');
+
+/**
+ * copy ルールに従って静的ファイルをコピーします。
+ * copy.from が無い場合は警告して続行します。
+ *
+ * @param {object} options
+ * @param {object} options.project
+ * @returns {Promise<{ copiedCount: number, files: string[] }>}
+ */
+async function copyFiles({ project }) {
+  const { name, sourceDir, outputDir, copy } = project;
+  const rules = Array.isArray(copy) ? copy : [];
+  let copiedCount = 0;
+  const files = [];
+
+  for (let i = 0; i < rules.length; i += 1) {
+    const rule = rules[i];
+
+    if (!rule || typeof rule !== 'object') {
+      throw new Error(
+        `[JSKim] プロジェクト "${name}" の copy[${i}] が不正です。\n` +
+          `原因: 各 copy ルールは from/to を持つオブジェクトである必要があります。`
+      );
+    }
+
+    if (!rule.from || String(rule.from).trim() === '') {
+      throw new Error(
+        `[JSKim] プロジェクト "${name}" の copy[${i}].from が不正です。\n` +
+          `原因: from は必須です（sourceDir 基準）。`
+      );
+    }
+
+    const fromDir = path.resolve(sourceDir, rule.from);
+    const toDir = path.resolve(outputDir, rule.to || '');
+
+    if (!(await fse.pathExists(fromDir))) {
+      console.warn(
+        `[JSKim] 警告: copy[${i}].from が存在しないためスキップします。\n` +
+          `  プロジェクト: ${name}\n` +
+          `  パス: ${fromDir}\n` +
+          `  設定: copy[${i}].from = ${rule.from}`
+      );
+      continue;
+    }
+
+    const stat = await fse.stat(fromDir);
+
+    if (stat.isFile()) {
+      try {
+        await fse.ensureDir(path.dirname(toDir));
+        await fse.copy(fromDir, toDir, { overwrite: true });
+        copiedCount += 1;
+        files.push(toDir);
+      } catch (err) {
+        const message = err && err.message ? err.message : String(err);
+        throw new Error(
+          `[JSKim] プロジェクト "${name}" のファイルコピーに失敗しました。\n` +
+            `From: ${fromDir}\n` +
+            `To: ${toDir}\n` +
+            `原因: ${message}`
+        );
+      }
+      continue;
+    }
+
+    if (!stat.isDirectory()) {
+      console.warn(
+        `[JSKim] 警告: copy[${i}].from はファイルでもディレクトリでもないためスキップします。\n` +
+          `  プロジェクト: ${name}\n` +
+          `  パス: ${fromDir}`
+      );
+      continue;
+    }
+
+    const matches = await fg('**/*', {
+      cwd: fromDir,
+      onlyFiles: true,
+      dot: false,
+      absolute: false,
+    });
+
+    matches.sort();
+
+    for (const relativeMatch of matches) {
+      const srcFile = path.join(fromDir, relativeMatch);
+      const destFile = path.join(toDir, relativeMatch);
+
+      try {
+        await fse.ensureDir(path.dirname(destFile));
+        await fse.copy(srcFile, destFile, { overwrite: true });
+      } catch (err) {
+        const message = err && err.message ? err.message : String(err);
+        throw new Error(
+          `[JSKim] プロジェクト "${name}" のアセットコピーに失敗しました。\n` +
+            `From: ${srcFile}\n` +
+            `To: ${destFile}\n` +
+            `原因: ${message}`
+        );
+      }
+
+      copiedCount += 1;
+      files.push(destFile);
+    }
+  }
+
+  return { copiedCount, files };
+}
+
+module.exports = {
+  copyFiles,
+};

package/scripts/lib/create-live-reload.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const LIVE_RELOAD_PATH = '/_jskim/live-reload';
+const HEARTBEAT_MS = 20000;
+
+/**
+ * SSE ベースのライブリロード管理です。
+ * dist には書き込まず、dev の HTML レスポンス注入と SSE 配信だけを担当します。
+ *
+ * @param {object} options
+ * @param {string} options.projectName
+ * @param {boolean} [options.enabled=true]
+ */
+function createLiveReload({ projectName, enabled = true }) {
+  const clients = new Set();
+  let heartbeatTimer = null;
+  let closed = false;
+
+  function ensureHeartbeat() {
+    if (!enabled || heartbeatTimer || closed) {
+      return;
+    }
+    heartbeatTimer = setInterval(() => {
+      for (const res of [...clients]) {
+        try {
+          res.write(': heartbeat\n\n');
+        } catch {
+          removeClient(res);
+        }
+      }
+    }, HEARTBEAT_MS);
+    if (typeof heartbeatTimer.unref === 'function') {
+      heartbeatTimer.unref();
+    }
+  }
+
+  function removeClient(res) {
+    if (!clients.has(res)) {
+      return;
+    }
+    clients.delete(res);
+    try {
+      res.end();
+    } catch {
+      // 切断済み
+    }
+  }
+
+  /**
+   * 内部 SSE リクエストを処理します。
+   * @returns {boolean} 処理したら true
+   */
+  function handleRequest(req, res, context = {}) {
+    if (!enabled || closed) {
+      return false;
+    }
+
+    const pathname = context.pathname || '';
+    if (pathname !== LIVE_RELOAD_PATH) {
+      return false;
+    }
+
+    const method = (req.method || 'GET').toUpperCase();
+    if (method !== 'GET' && method !== 'HEAD') {
+      res.statusCode = 405;
+      res.setHeader('Allow', 'GET, HEAD');
+      res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+      res.setHeader('Cache-Control', 'no-store');
+      const body = Buffer.from('このHTTPメソッドは使用できません。\n', 'utf8');
+      res.setHeader('Content-Length', String(body.length));
+      if (method === 'HEAD') {
+        res.end();
+      } else {
+        res.end(body);
+      }
+      return true;
+    }
+
+    res.statusCode = 200;
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-store');
+    res.setHeader('Connection', 'keep-alive');
+    // nginx 等のバッファリング回避（ローカルでも無害）
+    res.setHeader('X-Accel-Buffering', 'no');
+
+    if (method === 'HEAD') {
+      res.end();
+      return true;
+    }
+
+    res.write(': connected\n\n');
+    clients.add(res);
+    ensureHeartbeat();
+
+    const onClose = () => {
+      removeClient(res);
+    };
+    req.on('close', onClose);
+    res.on('close', onClose);
+    res.on('error', onClose);
+
+    return true;
+  }
+
+  function getClientScript() {
+    return [
+      '<script>',
+      '(function () {',
+      '  try {',
+      `    var source = new EventSource(${JSON.stringify(LIVE_RELOAD_PATH)});`,
+      "    source.addEventListener('reload', function () {",
+      '      window.location.reload();',
+      '    });',
+      '    source.onerror = function () {',
+      "      console.info('[JSKim] ライブリロード接続を再試行しています…');",
+      '    };',
+      '  } catch (err) {',
+      "    console.warn('[JSKim] ライブリロードを開始できませんでした。');",
+      '  }',
+      '})();',
+      '</script>',
+    ].join('');
+  }
+
+  /**
+   * HTML 文字列に client script を注入します（メモリ上のみ）。
+   * @param {string} html
+   * @returns {string}
+   */
+  function injectHtml(html) {
+    if (!enabled || typeof html !== 'string') {
+      return html;
+    }
+
+    const script = getClientScript();
+    const bodyClose = html.search(/<\/body>/i);
+    if (bodyClose !== -1) {
+      return html.slice(0, bodyClose) + script + html.slice(bodyClose);
+    }
+
+    const htmlClose = html.search(/<\/html>/i);
+    if (htmlClose !== -1) {
+      return html.slice(0, htmlClose) + script + html.slice(htmlClose);
+    }
+
+    return html + script;
+  }
+
+  function broadcastReload() {
+    if (!enabled || closed) {
+      return;
+    }
+
+    const payload = `event: reload\ndata: ${JSON.stringify({
+      project: projectName,
+    })}\n\n`;
+
+    for (const res of [...clients]) {
+      try {
+        res.write(payload);
+      } catch {
+        removeClient(res);
+      }
+    }
+  }
+
+  function close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+
+    for (const res of [...clients]) {
+      removeClient(res);
+    }
+    clients.clear();
+  }
+
+  return {
+    enabled: Boolean(enabled),
+    path: LIVE_RELOAD_PATH,
+    handleRequest,
+    injectHtml,
+    broadcastReload,
+    getClientScript,
+    close,
+    get clientCount() {
+      return clients.size;
+    },
+  };
+}
+
+module.exports = {
+  createLiveReload,
+  LIVE_RELOAD_PATH,
+};

package/scripts/lib/create-nunjucks-env.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+const nunjucks = require('nunjucks');
+
+/**
+ * プロジェクト用の Nunjucks 環境を作成します。
+ * loader ルート: sourceDir + templates[]（重複除去）。
+ *
+ * @param {object} options
+ * @param {string} options.sourceDir
+ * @param {string[]} options.templates
+ * @returns {nunjucks.Environment}
+ */
+function createNunjucksEnv({ sourceDir, templates }) {
+  const roots = [];
+  const seen = new Set();
+
+  function addRoot(absPath) {
+    const normalized = path.resolve(absPath);
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) {
+      return;
+    }
+    if (!fs.existsSync(normalized) || !fs.statSync(normalized).isDirectory()) {
+      return;
+    }
+    seen.add(key);
+    roots.push(normalized);
+  }
+
+  addRoot(sourceDir);
+
+  const templateDirs = Array.isArray(templates) ? templates : [];
+  for (const rel of templateDirs) {
+    addRoot(path.resolve(sourceDir, rel));
+  }
+
+  if (roots.length === 0) {
+    throw new Error(
+      `[JSKim] 有効な Nunjucks loader パスがありません。\n` +
+        `sourceDir: ${sourceDir}`
+    );
+  }
+
+  const loader = new nunjucks.FileSystemLoader(roots, {
+    noCache: true,
+  });
+
+  const env = new nunjucks.Environment(loader, {
+    autoescape: true,
+    noCache: true,
+  });
+
+  return env;
+}
+
+module.exports = {
+  createNunjucksEnv,
+};