@ywal123456/jskim 0.2.0 → 0.3.0

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

@@ -7,13 +7,15 @@ const nunjucks = require('nunjucks');
 /**
  * プロジェクト用の Nunjucks 環境を作成します。
  * loader ルート: sourceDir + templates[]（重複除去）。
+ * filters / globals を登録します。
  *
  * @param {object} options
  * @param {string} options.sourceDir
  * @param {string[]} options.templates
+ * @param {object} [options.nunjucks]
  * @returns {nunjucks.Environment}
  */
-function createNunjucksEnv({ sourceDir, templates }) {
+function createNunjucksEnv({ sourceDir, templates, nunjucks: nunjucksConfig }) {
   const roots = [];
   const seen = new Set();
 
@@ -48,14 +50,50 @@ function createNunjucksEnv({ sourceDir, templates }) {
     noCache: true,
   });
 
+  // HTML 互換のため autoescape は維持する。
+  // JSON/JS 出力が必要な filter は SafeString を返すこと。
   const env = new nunjucks.Environment(loader, {
     autoescape: true,
     noCache: true,
   });
 
+  const config =
+    nunjucksConfig && typeof nunjucksConfig === 'object' ? nunjucksConfig : {};
+  registerFilters(env, config.filters || {});
+  registerGlobals(env, config.globals || {});
+
   return env;
 }
 
+function registerFilters(env, filters) {
+  for (const [name, fn] of Object.entries(filters)) {
+    env.addFilter(name, wrapSyncCallable(fn, `filter:${name}`));
+  }
+}
+
+function registerGlobals(env, globals) {
+  for (const [name, value] of Object.entries(globals)) {
+    if (typeof value === 'function') {
+      env.addGlobal(name, wrapSyncCallable(value, `global:${name}`));
+    } else {
+      env.addGlobal(name, value);
+    }
+  }
+}
+
+function wrapSyncCallable(fn, label) {
+  return function wrapped(...args) {
+    const result = fn.apply(this, args);
+    if (result && typeof result.then === 'function') {
+      throw new Error(
+        `[JSKim] 非同期${label.startsWith('filter') ? 'filter' : 'global'}は現在サポートされていません。\n` +
+          `対象: ${label}`
+      );
+    }
+    return result;
+  };
+}
+
 module.exports = {
   createNunjucksEnv,
 };

package/scripts/lib/merge-config.js

@@ -4,8 +4,8 @@
  * defaults とプロジェクト設定をマージします。
  *
  * - スカラー: プロジェクト側があれば優先
- * - オブジェクト (build / watch / serve / dev): 1段階の shallow merge
- * - 配列 (render / templates / copy): プロジェクト側配列が defaults を丸ごと置き換え
+ * - オブジェクト (build / watch / serve / dev / data / nunjucks): 1段階の shallow merge
+ * - 配列 (render / templates / copy / files): プロジェクト側配列が defaults を丸ごと置き換え
  *
  * 元の defaults / プロジェクトオブジェクトは変更しません。
  *
@@ -23,6 +23,9 @@ function mergeConfig(defaults, project) {
     render: pickArray(override.render, base.render, []),
     templates: pickArray(override.templates, base.templates, []),
     copy: pickArray(override.copy, base.copy, []),
+    files: pickOptionalArray(override.files, base.files),
+    data: mergePlainObject(base.data, override.data),
+    nunjucks: mergeNunjucks(base.nunjucks, override.nunjucks),
     build: mergeBuild(base.build, override.build),
     watch: mergeWatch(base.watch, override.watch),
     serve: mergeServe(base.serve, override.serve),
@@ -35,6 +38,19 @@ function mergeConfig(defaults, project) {
     render: merged.render.map((rule) => ({ ...rule })),
     templates: [...merged.templates],
     copy: merged.copy.map((rule) => ({ ...rule })),
+    files:
+      merged.files == null
+        ? null
+        : merged.files.map((rule) => ({
+            ...rule,
+            include: Array.isArray(rule.include) ? [...rule.include] : undefined,
+            exclude: Array.isArray(rule.exclude) ? [...rule.exclude] : undefined,
+          })),
+    data: isPlainObject(merged.data) ? { ...merged.data } : merged.data,
+    nunjucks: {
+      filters: { ...merged.nunjucks.filters },
+      globals: { ...merged.nunjucks.globals },
+    },
     build: { ...merged.build },
     watch: { ...merged.watch },
     serve: { ...merged.serve },
@@ -56,6 +72,75 @@ function pickArray(projectValue, defaultValue, fallback) {
   return fallback.slice();
 }
 
+/**
+ * files 未設定を null で表し、legacy と区別します。
+ * @returns {object[]|null}
+ */
+function pickOptionalArray(projectValue, defaultValue) {
+  if (Array.isArray(projectValue)) {
+    return projectValue.slice();
+  }
+  if (Array.isArray(defaultValue)) {
+    return defaultValue.slice();
+  }
+  return null;
+}
+
+function mergePlainObject(defaultValue, projectValue) {
+  if (projectValue !== undefined && !isPlainObject(projectValue)) {
+    return projectValue;
+  }
+  if (projectValue === undefined && defaultValue !== undefined && !isPlainObject(defaultValue)) {
+    return defaultValue;
+  }
+
+  const base = isPlainObject(defaultValue) ? defaultValue : {};
+  const override = isPlainObject(projectValue) ? projectValue : {};
+  return { ...base, ...override };
+}
+
+function isPlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function mergeNunjucks(defaultValue, projectValue) {
+  const base =
+    defaultValue && typeof defaultValue === 'object' && !Array.isArray(defaultValue)
+      ? defaultValue
+      : {};
+  const override =
+    projectValue && typeof projectValue === 'object' && !Array.isArray(projectValue)
+      ? projectValue
+      : {};
+
+  const baseFilters =
+    base.filters && typeof base.filters === 'object' && !Array.isArray(base.filters)
+      ? base.filters
+      : {};
+  const overrideFilters =
+    override.filters &&
+    typeof override.filters === 'object' &&
+    !Array.isArray(override.filters)
+      ? override.filters
+      : {};
+
+  const baseGlobals =
+    base.globals && typeof base.globals === 'object' && !Array.isArray(base.globals)
+      ? base.globals
+      : {};
+  const overrideGlobals =
+    override.globals &&
+    typeof override.globals === 'object' &&
+    !Array.isArray(override.globals)
+      ? override.globals
+      : {};
+
+  return {
+    filters: { ...baseFilters, ...overrideFilters },
+    globals: { ...baseGlobals, ...overrideGlobals },
+  };
+}
+
 function mergeBuild(defaultBuild, projectBuild) {
   const base =
     defaultBuild && typeof defaultBuild === 'object' ? defaultBuild : {};

package/scripts/lib/process-files.js

@@ -0,0 +1,263 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+const fse = require('fs-extra');
+const fg = require('fast-glob');
+const { computeRootPath } = require('./render-pages');
+
+const RESERVED_CONTEXT_KEYS = new Set(['rootPath']);
+
+/**
+ * files pipeline を実行します。
+ * *.njk → render（末尾 .njk のみ削除）
+ * それ以外 → byte copy
+ *
+ * @param {object} options
+ * @param {import('nunjucks').Environment} options.env
+ * @param {object} options.project
+ * @returns {Promise<{ renderedCount: number, copiedCount: number, files: string[] }>}
+ */
+async function processFiles({ env, project }) {
+  const { name, sourceDir, outputDir, files, templates, data } = project;
+  const rules = Array.isArray(files) ? files : [];
+  const templateRoots = resolveTemplateRoots(sourceDir, templates);
+
+  assertNoReservedDataCollision(data, name);
+
+  /** @type {Map<string, { sourceFile: string, outputFile: string, kind: string, relative: string, ruleIndex: number }>} */
+  const planned = new Map();
+
+  for (let i = 0; i < rules.length; i += 1) {
+    const rule = normalizeFilesRule(rules[i], name, i);
+    const fromDir = path.resolve(sourceDir, rule.from);
+    const toDir = path.resolve(outputDir, rule.to);
+
+    assertInside(sourceDir, fromDir, name, `files[${i}].from`);
+    assertInside(outputDir, toDir, name, `files[${i}].to`);
+
+    if (!(await fse.pathExists(fromDir))) {
+      throw new Error(
+        `[JSKim] プロジェクト "${name}" の files[${i}].from が存在しません。\n` +
+          `パス: ${fromDir}\n` +
+          `設定: files[${i}].from = ${rule.from}`
+      );
+    }
+
+    const matches = await fg(rule.include, {
+      cwd: fromDir,
+      onlyFiles: true,
+      dot: false,
+      absolute: false,
+      ignore: rule.exclude,
+    });
+    matches.sort();
+
+    for (const relativeMatch of matches) {
+      const normalizedRel = relativeMatch.split(path.sep).join('/');
+      const sourceFile = path.join(fromDir, relativeMatch);
+
+      if (isInsideAny(templateRoots, sourceFile)) {
+        continue;
+      }
+
+      const isNjk = normalizedRel.endsWith('.njk');
+      const outRel = isNjk
+        ? stripTrailingNjk(normalizedRel)
+        : normalizedRel;
+      const outputFile = path.resolve(toDir, outRel.split('/').join(path.sep));
+
+      assertInside(outputDir, outputFile, name, `files[${i}] output`);
+
+      const collisionKey =
+        process.platform === 'win32'
+          ? outputFile.toLowerCase()
+          : outputFile;
+
+      if (planned.has(collisionKey)) {
+        const previous = planned.get(collisionKey);
+        throw new Error(
+          `[JSKim] 出力パスが衝突しています。\n` +
+            `プロジェクト: ${name}\n` +
+            `出力: ${toDisplay(outputFile, project.workspaceRoot)}\n` +
+            `ソース1: ${toDisplay(previous.sourceFile, project.workspaceRoot)}\n` +
+            `ソース2: ${toDisplay(sourceFile, project.workspaceRoot)}`
+        );
+      }
+
+      planned.set(collisionKey, {
+        sourceFile,
+        outputFile,
+        kind: isNjk ? 'render' : 'copy',
+        relative: normalizedRel,
+        ruleIndex: i,
+      });
+    }
+  }
+
+  let renderedCount = 0;
+  let copiedCount = 0;
+  const outputFiles = [];
+
+  for (const item of planned.values()) {
+    await fse.ensureDir(path.dirname(item.outputFile));
+
+    if (item.kind === 'copy') {
+      await fse.copy(item.sourceFile, item.outputFile, { overwrite: true });
+      copiedCount += 1;
+      outputFiles.push(item.outputFile);
+      continue;
+    }
+
+    const templatePath = path
+      .relative(sourceDir, item.sourceFile)
+      .split(path.sep)
+      .join('/');
+    const rootPath = computeRootPath(item.outputFile, outputDir);
+    const context = buildRenderContext(data, rootPath);
+
+    let text;
+    try {
+      text = env.render(templatePath, context);
+    } catch (err) {
+      const message = err && err.message ? err.message : String(err);
+      throw new Error(
+        `[JSKim] プロジェクト "${name}" の Nunjucks レンダリングに失敗しました。\n` +
+          `ソース: ${item.sourceFile}\n` +
+          `テンプレート: ${templatePath}\n` +
+          `原因: ${message}`
+      );
+    }
+
+    await fse.writeFile(item.outputFile, text, 'utf8');
+    renderedCount += 1;
+    outputFiles.push(item.outputFile);
+  }
+
+  return { renderedCount, copiedCount, files: outputFiles };
+}
+
+function normalizeFilesRule(rule, projectName, index) {
+  if (!rule || typeof rule !== 'object') {
+    throw new Error(
+      `[JSKim] プロジェクト "${projectName}" の files[${index}] が不正です。\n` +
+        `原因: 各 files ルールはオブジェクトである必要があります。`
+    );
+  }
+  if (!rule.from || String(rule.from).trim() === '') {
+    throw new Error(
+      `[JSKim] プロジェクト "${projectName}" の files[${index}].from が不正です。\n` +
+        `原因: from は必須です（sourceDir 基準）。`
+    );
+  }
+
+  const include = Array.isArray(rule.include) ? rule.include : ['**/*'];
+  if (include.length === 0) {
+    throw new Error(
+      `[JSKim] プロジェクト "${projectName}" の files[${index}].include が不正です。\n` +
+        `原因: include は空でない glob 配列である必要があります。`
+    );
+  }
+
+  const exclude = Array.isArray(rule.exclude) ? rule.exclude : [];
+
+  return {
+    from: String(rule.from).trim(),
+    to: rule.to == null ? '' : String(rule.to),
+    include: [...include],
+    exclude: [...exclude],
+  };
+}
+
+function stripTrailingNjk(relativePath) {
+  if (relativePath.endsWith('.njk')) {
+    return relativePath.slice(0, -4);
+  }
+  return relativePath;
+}
+
+function resolveTemplateRoots(sourceDir, templates) {
+  const roots = [];
+  for (const rel of Array.isArray(templates) ? templates : []) {
+    if (!rel) {
+      continue;
+    }
+    const abs = path.resolve(sourceDir, rel);
+    if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
+      roots.push(abs);
+    }
+  }
+  return roots;
+}
+
+function isInsideAny(roots, candidate) {
+  for (const root of roots) {
+    if (isInsideOrSame(root, candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isInsideOrSame(parent, child) {
+  const p = path.resolve(parent);
+  const c = path.resolve(child);
+  if (samePath(p, c)) {
+    return true;
+  }
+  const rel = path.relative(p, c);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+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 assertInside(root, candidate, projectName, label) {
+  if (!isInsideOrSame(root, candidate)) {
+    throw new Error(
+      `[JSKim] プロジェクト "${projectName}" の ${label} が許可範囲外です。\n` +
+        `ルート: ${root}\n` +
+        `対象: ${candidate}`
+    );
+  }
+}
+
+function assertNoReservedDataCollision(data, projectName) {
+  const keys = Object.keys(data || {});
+  for (const key of keys) {
+    if (RESERVED_CONTEXT_KEYS.has(key)) {
+      throw new Error(
+        `[JSKim] data のキーが予約語と衝突しています: ${key}\n` +
+          `プロジェクト: ${projectName}\n` +
+          `予約キー: ${[...RESERVED_CONTEXT_KEYS].join(', ')}`
+      );
+    }
+  }
+}
+
+function buildRenderContext(data, rootPath) {
+  return {
+    ...(data && typeof data === 'object' ? data : {}),
+    rootPath,
+  };
+}
+
+function toDisplay(abs, workspaceRoot) {
+  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 = {
+  processFiles,
+  stripTrailingNjk,
+  RESERVED_CONTEXT_KEYS,
+};

package/scripts/lib/render-pages.js

@@ -81,10 +81,26 @@ async function renderPages({ env, project }) {
         .join('/');
 
       const rootPath = computeRootPath(outputFile, outputDir);
+      const context = {
+        ...(project.data && typeof project.data === 'object'
+          ? project.data
+          : {}),
+        rootPath,
+      };
+
+      if (
+        project.data &&
+        Object.prototype.hasOwnProperty.call(project.data, 'rootPath')
+      ) {
+        throw new Error(
+          `[JSKim] data のキーが予約語と衝突しています: rootPath\n` +
+            `プロジェクト: ${name}`
+        );
+      }
 
       let html;
       try {
-        html = env.render(templatePath, { rootPath });
+        html = env.render(templatePath, context);
       } catch (err) {
         const message = err && err.message ? err.message : String(err);
         throw new Error(

package/scripts/lib/resolve-project.js

@@ -12,7 +12,7 @@ const { mergeConfig } = require('./merge-config');
  * @param {string} options.workspaceRoot
  * @param {string|undefined} options.projectName
  * @param {string} [options.commandName='build']
- * @param {string} [options.usageLine] プロジェクト名欠落時の使用方法行
+ * @param {string} [options.usageLine]
  * @returns {object} 解決済みプロジェクト
  */
 function resolveProject({
@@ -45,7 +45,8 @@ function resolveProject({
     );
   }
 
-  const merged = mergeConfig(config.defaults || {}, projectConfig);
+  const defaults = config.defaults || {};
+  const merged = mergeConfig(defaults, projectConfig);
 
   if (!merged.sourceDir || String(merged.sourceDir).trim() === '') {
     throw new Error(
@@ -79,39 +80,42 @@ function resolveProject({
     );
   }
 
-  if (!Array.isArray(merged.render) || merged.render.length === 0) {
+  validateData(merged.data, name);
+  validateNunjucks(merged.nunjucks, name);
+
+  const hasFiles = Array.isArray(merged.files) && merged.files.length > 0;
+  const hasRender = Array.isArray(merged.render) && merged.render.length > 0;
+  const hasCopy = Array.isArray(merged.copy) && merged.copy.length > 0;
+
+  if (hasFiles && (hasRender || hasCopy)) {
+    const conflict = [];
+    if (hasRender) {
+      conflict.push('render');
+    }
+    if (hasCopy) {
+      conflict.push('copy');
+    }
     throw new Error(
-      `[JSKim] プロジェクト "${name}" の render 設定が無い、または空です。\n` +
-        `jskim.config.js の defaults.render または projects.${name}.render を定義してください。`
+      `[JSKim] files と ${conflict.join(' / ')} を同時に設定できません。\n` +
+        `プロジェクト: ${name}\n` +
+        `files mode を使う場合は render / copy を空にしてください。\n` +
+        `legacy mode を使う場合は files を設定しないでください。`
     );
   }
 
-  for (let i = 0; i < merged.render.length; i += 1) {
-    const rule = merged.render[i];
-    if (!rule || typeof rule !== 'object') {
-      throw new Error(
-        `[JSKim] プロジェクト "${name}" の render[${i}] が不正です。\n` +
-          `原因: 各 render ルールはオブジェクトである必要があります。`
-      );
-    }
-    if (!rule.from || String(rule.from).trim() === '') {
-      throw new Error(
-        `[JSKim] プロジェクト "${name}" の render[${i}].from が不正です。\n` +
-          `原因: from は必須です（sourceDir 基準）。`
-      );
-    }
-    if (!Array.isArray(rule.include) || rule.include.length === 0) {
-      throw new Error(
-        `[JSKim] プロジェクト "${name}" の render[${i}].include が不正です。\n` +
-          `原因: include は空でない glob パターン配列である必要があります。`
-      );
-    }
-    if (!rule.extension || String(rule.extension).trim() === '') {
+  const pipelineMode = hasFiles ? 'files' : 'legacy';
+
+  if (pipelineMode === 'files') {
+    validateFilesRules(merged.files, name);
+  } else {
+    if (!hasRender) {
       throw new Error(
-        `[JSKim] プロジェクト "${name}" の render[${i}].extension が不正です。\n` +
-          `原因: extension は必須です（例: ".html"）。`
+        `[JSKim] プロジェクト "${name}" の render 設定が無い、または空です。\n` +
+          `jskim.config.js の defaults.render または projects.${name}.render を定義してください。\n` +
+          `新しい files pipeline を使う場合は defaults.files を設定してください。`
       );
     }
+    validateRenderRules(merged.render, name);
   }
 
   validateWatchConfig(merged.watch, name);
@@ -124,9 +128,13 @@ function resolveProject({
     outputDir,
     sourceDirConfig: merged.sourceDir,
     outputDirConfig: merged.outputDir,
+    pipelineMode,
     render: merged.render,
     templates: merged.templates,
     copy: merged.copy,
+    files: merged.files || [],
+    data: merged.data,
+    nunjucks: merged.nunjucks,
     build: merged.build,
     watch: merged.watch,
     serve: merged.serve,
@@ -135,6 +143,122 @@ function resolveProject({
   };
 }
 
+function validateFilesRules(files, projectName) {
+  for (let i = 0; i < files.length; i += 1) {
+    const rule = files[i];
+    if (!rule || typeof rule !== 'object') {
+      throw new Error(
+        `[JSKim] プロジェクト "${projectName}" の files[${i}] が不正です。\n` +
+          `原因: 各 files ルールはオブジェクトである必要があります。`
+      );
+    }
+    if (!rule.from || String(rule.from).trim() === '') {
+      throw new Error(
+        `[JSKim] プロジェクト "${projectName}" の files[${i}].from が不正です。\n` +
+          `原因: from は必須です（sourceDir 基準）。`
+      );
+    }
+    if (rule.include !== undefined) {
+      if (!Array.isArray(rule.include) || rule.include.length === 0) {
+        throw new Error(
+          `[JSKim] プロジェクト "${projectName}" の files[${i}].include が不正です。\n` +
+            `原因: include は空でない glob 配列である必要があります。`
+        );
+      }
+    }
+    if (rule.exclude !== undefined && !Array.isArray(rule.exclude)) {
+      throw new Error(
+        `[JSKim] プロジェクト "${projectName}" の files[${i}].exclude が不正です。\n` +
+          `原因: exclude は配列である必要があります。`
+      );
+    }
+  }
+}
+
+function validateRenderRules(render, projectName) {
+  for (let i = 0; i < render.length; i += 1) {
+    const rule = render[i];
+    if (!rule || typeof rule !== 'object') {
+      throw new Error(
+        `[JSKim] プロジェクト "${projectName}" の render[${i}] が不正です。\n` +
+          `原因: 各 render ルールはオブジェクトである必要があります。`
+      );
+    }
+    if (!rule.from || String(rule.from).trim() === '') {
+      throw new Error(
+        `[JSKim] プロジェクト "${projectName}" の render[${i}].from が不正です。\n` +
+          `原因: from は必須です（sourceDir 基準）。`
+      );
+    }
+    if (!Array.isArray(rule.include) || rule.include.length === 0) {
+      throw new Error(
+        `[JSKim] プロジェクト "${projectName}" の render[${i}].include が不正です。\n` +
+          `原因: include は空でない glob パターン配列である必要があります。`
+      );
+    }
+    if (!rule.extension || String(rule.extension).trim() === '') {
+      throw new Error(
+        `[JSKim] プロジェクト "${projectName}" の render[${i}].extension が不正です。\n` +
+          `原因: extension は必須です（例: ".html"）。`
+      );
+    }
+  }
+}
+
+function validateData(data, projectName) {
+  if (data == null) {
+    return;
+  }
+  if (typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error(
+      `[JSKim] 設定値が不正です: data\n` +
+        `プロジェクト: ${projectName}\n` +
+        `plain object を指定してください（null / array / primitive は不可）。\n` +
+        `受け取った値: ${Array.isArray(data) ? 'array' : typeof data}`
+    );
+  }
+}
+
+function validateNunjucks(nunjucks, projectName) {
+  if (nunjucks == null) {
+    return;
+  }
+  if (typeof nunjucks !== 'object' || Array.isArray(nunjucks)) {
+    throw new Error(
+      `[JSKim] 設定値が不正です: nunjucks\n` +
+        `プロジェクト: ${projectName}\n` +
+        `plain object を指定してください。`
+    );
+  }
+
+  const filters = nunjucks.filters || {};
+  if (typeof filters !== 'object' || Array.isArray(filters)) {
+    throw new Error(
+      `[JSKim] 設定値が不正です: nunjucks.filters\n` +
+        `プロジェクト: ${projectName}\n` +
+        `plain object を指定してください。`
+    );
+  }
+  for (const [key, value] of Object.entries(filters)) {
+    if (typeof value !== 'function') {
+      throw new Error(
+        `[JSKim] 設定値が不正です: nunjucks.filters.${key}\n` +
+          `プロジェクト: ${projectName}\n` +
+          `filter は function である必要があります。`
+      );
+    }
+  }
+
+  const globals = nunjucks.globals || {};
+  if (typeof globals !== 'object' || Array.isArray(globals)) {
+    throw new Error(
+      `[JSKim] 設定値が不正です: nunjucks.globals\n` +
+        `プロジェクト: ${projectName}\n` +
+        `plain object を指定してください。`
+    );
+  }
+}
+
 function validateWatchConfig(watch, projectName) {
   const debounce = watch && watch.debounce;