@coraltravelcenter/b2c-landing-builder 2.13.0 → 2.14.0

package/README.md

@@ -112,6 +112,9 @@ export default {
     markup: "pug",
     styles: "less",
   },
+  blocks: {
+    static: ["html-only"],
+  },
 };
 ```
 
@@ -134,6 +137,14 @@ builder распознать legacy-шаблон и предложить миг
 Builder загружает Vue-плагин из проекта, поэтому Vue-зависимости не
 устанавливаются вместе с глобальным builder.
 
+`blocks.static` явно перечисляет блоки без JavaScript initializer. Команда
+`b2c-landing-vite check --strict` требует initializer или такую декларацию.
+HTML-разметка поддерживает вложенные `<include src="./partial.html"></include>`.
+
+При первом запуске dev-сервер сохраняет выбранный свободный порт в
+`.b2c/dev-port`; следующие запуски используют его строго. Новый порт можно
+закрепить командой `B2C_PORT=5175 npm run dev`.
+
 Перед подготовкой deploy-артефактов builder рекурсивно проверяет `public/`.
 Изображения JPG, JPEG и PNG конвертируются в WebP с качеством 80, а ссылки в
 CMS-файлах автоматически переключаются на новые имена. Исходные файлы в

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@coraltravelcenter/b2c-landing-builder",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@coraltravelcenter/b2c-landing-builder",
-      "version": "2.13.0",
+      "version": "2.14.0",
       "license": "MIT",
       "dependencies": {
         "@babel/parser": "7.28.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coraltravelcenter/b2c-landing-builder",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "CLI and build toolkit for B2C landing projects",
   "type": "module",
   "bin": {

package/src/cli/index.mjs

@@ -15,10 +15,10 @@ Commands:
   block:rename <old> <new>  Rename a block
   update                    Show the manual update command`;
 
-async function check() {
+async function check({strict = false} = {}) {
   const config = await loadConfig();
   const preset = resolvePreset(config.site.preset);
-  const project = validateProject(config);
+  const project = validateProject(config, process.cwd(), {strict});
   console.log(`[check] project: ${config.project.name}`);
   console.log(`[check] schemaVersion: ${config.schemaVersion}`);
   console.log(`[check] site: ${preset.id} (${preset.domain})`);
@@ -28,6 +28,12 @@ async function check() {
     console.log(`[check] assets: not configured for ${preset.id} (production build unavailable)`);
   }
   console.log(`[check] blocks: ${project.blocks.length}`);
+  for (const block of project.blockDetails) {
+    console.log(
+      `[check] block ${block.key}: markup=yes styles=yes initializer=${block.initializer ? "yes" : "no"}` +
+      `${block.static ? " (static)" : ""}`
+    );
+  }
 }
 
 export async function runCli(args) {
@@ -38,7 +44,12 @@ export async function runCli(args) {
     return;
   }
 
-  if (command === "check") return check();
+  if (command === "check") {
+    if (rest.some((argument) => argument !== "--strict")) {
+      throw new Error("Usage: b2c-landing-vite check [--strict]");
+    }
+    return check({strict: rest.includes("--strict")});
+  }
   if (command === "dev") {
     const config = await loadConfig();
     validateProject(config);

package/src/config/validate-config.mjs

@@ -42,6 +42,12 @@ export function validateConfig(config) {
   if (!SITE_PRESETS.has(config.site?.preset)) {
     throw new Error(`Unknown site preset: ${JSON.stringify(config.site?.preset)}`);
   }
+  if (config.blocks?.static !== undefined && !Array.isArray(config.blocks.static)) {
+    throw new Error("blocks.static must be an array of block keys");
+  }
+  if (config.blocks?.static?.some((key) => typeof key !== "string" || !key)) {
+    throw new Error("blocks.static must contain non-empty block keys");
+  }
   for (const [key, allowed] of Object.entries(STACK_VALUES)) {
     if (!allowed.has(config.stack?.[key])) {
       throw new Error(`Unsupported stack.${key}: ${JSON.stringify(config.stack?.[key])}`);

package/src/config/validate-project.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import {createRequire} from "node:module";
 import path from "node:path";
 
+import {processMarkup} from "../lib/processMarkup.mjs";
 import {resolveScriptStack} from "./script-stack.mjs";
 import {hasDefaultInitializer} from "./validate-script-contract.mjs";
 
@@ -11,6 +12,7 @@ const STACK_DEPENDENCIES = {
   markup: {pug: ["pug"]},
   styles: {less: ["less"], scss: ["sass"]},
 };
+const SCRIPT_EXTENSIONS = ["js", "ts"];
 
 function validateLocalDependencies(config, root) {
   const projectRequire = createRequire(path.resolve(root, "package.json"));
@@ -46,7 +48,7 @@ function readJson(filePath, label) {
   }
 }
 
-export function validateProject(config, root = process.cwd()) {
+export function validateProject(config, root = process.cwd(), {strict = false} = {}) {
   const scriptStack = resolveScriptStack(config.stack.script);
   const orderPath = path.resolve(root, "src/order.json");
   const order = readJson(orderPath, "src/order.json");
@@ -58,6 +60,8 @@ export function validateProject(config, root = process.cwd()) {
   }
 
   const seen = new Set();
+  const staticBlocks = new Set(config.blocks?.static || []);
+  const blockDetails = [];
   for (const key of order.blocks) {
     if (typeof key !== "string" || !BLOCK_KEY_RE.test(key)) {
       throw new Error(`Invalid block key in src/order.json: ${JSON.stringify(key)}`);
@@ -69,6 +73,9 @@ export function validateProject(config, root = process.cwd()) {
     if (!fs.existsSync(markupPath)) {
       throw new Error(`Missing configured markup for block ${key}: src/markup/${key}.${config.stack.markup}`);
     }
+    if (config.stack.markup === "html") {
+      processMarkup(fs.readFileSync(markupPath, "utf8"), {filePath: markupPath});
+    }
 
     const stylePath = path.resolve(root, "src/styles", `${key}.${config.stack.styles}`);
     if (!fs.existsSync(stylePath)) {
@@ -76,7 +83,31 @@ export function validateProject(config, root = process.cwd()) {
     }
 
     const scriptPath = path.resolve(root, "src/scripts", `${key}.${scriptStack.extension}`);
-    if (!fs.existsSync(scriptPath)) continue;
+    const conflictingScriptPaths = SCRIPT_EXTENSIONS
+      .filter((extension) => extension !== scriptStack.extension)
+      .map((extension) => path.resolve(root, "src/scripts", `${key}.${extension}`))
+      .filter((candidate) => fs.existsSync(candidate));
+    if (conflictingScriptPaths.length) {
+      const conflictingEntries = conflictingScriptPaths
+        .map((candidate) => path.relative(root, candidate))
+        .join(", ");
+      throw new Error(
+        `Script entry for block ${key} conflicts with stack.script=${JSON.stringify(config.stack.script)}: ` +
+        `${conflictingEntries}. Change stack.script or rename/remove the conflicting entry.`
+      );
+    }
+    const hasInitializer = fs.existsSync(scriptPath);
+    if (hasInitializer && staticBlocks.has(key)) {
+      throw new Error(`Block ${key} is declared static but has initializer src/scripts/${key}.${scriptStack.extension}`);
+    }
+    if (!hasInitializer && strict && !staticBlocks.has(key)) {
+      throw new Error(
+        `Block ${key} has no initializer. Add src/scripts/${key}.${scriptStack.extension} ` +
+        `or declare it in blocks.static.`
+      );
+    }
+    blockDetails.push({key, markup: true, styles: true, initializer: hasInitializer, static: staticBlocks.has(key)});
+    if (!hasInitializer) continue;
     const source = fs.readFileSync(scriptPath, "utf8");
     if (!hasDefaultInitializer({source, filePath: scriptPath, extension: scriptStack.extension, root})) {
       throw new Error(
@@ -85,6 +116,10 @@ export function validateProject(config, root = process.cwd()) {
     }
   }
 
+  for (const key of staticBlocks) {
+    if (!seen.has(key)) throw new Error(`Unknown block in blocks.static: ${key}`);
+  }
+
   validateLocalDependencies(config, root);
-  return {folder: order.folder, blocks: [...order.blocks]};
+  return {folder: order.folder, blocks: [...order.blocks], blockDetails};
 }

package/src/lib/build-cms.mjs

@@ -131,7 +131,7 @@ async function buildBlock(key, stack) {
   const markup = stack.markup === "pug"
     ? renderPugFile(markupPath)
     : normalizeHtml(fs.readFileSync(markupPath, "utf8"));
-  const html = processMarkup(markup);
+  const html = processMarkup(markup, {filePath: markupPath});
 
   const configuredCssPath = path.join(STYLES_DIR, `${key}.${stack.styles}`);
   const cssPath = existsFile(configuredCssPath) ? configuredCssPath : null;
@@ -155,7 +155,10 @@ async function buildBlock(key, stack) {
 
   if (js) parts.push(`<script>\n${js}\n</script>`);
 
-  return parts.join("\n\n") + "\n";
+  return {
+    content: parts.join("\n\n") + "\n",
+    composition: {markup: Boolean(html), styles: Boolean(mergedCss), initializer: Boolean(js)},
+  };
 }
 
 // ---------- run ----------
@@ -178,8 +181,13 @@ export async function buildCms({config}) {
     }
 
     const outFile = path.join(OUT_DIR, `${key}.html`);
-    fs.writeFileSync(outFile, result);
+    fs.writeFileSync(outFile, result.content);
     console.log(`[CMS] wrote @CMS/${key}.html`);
+    console.log(
+      `[CMS] block ${key}: markup=${result.composition.markup ? "yes" : "no"} ` +
+      `styles=${result.composition.styles ? "yes" : "no"} ` +
+      `initializer=${result.composition.initializer ? "yes" : "no"}`
+    );
   }
 
   console.log("[CMS] done");

package/src/lib/landingBlocksPlugin.mjs

@@ -100,7 +100,10 @@ export function landingBlocksPlugin({root = process.cwd(), stack} = {}) {
         const source = stack.markup === "pug"
           ? renderPugFile(markupPath)
           : normalizeHtml(fs.readFileSync(markupPath, "utf8"));
-        const html = processMarkup(source);
+        const html = processMarkup(source, {
+          filePath: markupPath,
+          onInclude: (includePath) => this.addWatchFile(includePath),
+        });
         entries.push(`{ key: ${JSON.stringify(key)}, html: ${JSON.stringify(html)}, init: ${init} }`);
       });
 

package/src/lib/processMarkup.mjs

@@ -1,3 +1,6 @@
+import fs from "node:fs";
+import path from "node:path";
+
 import Typograf from "typograf";
 
 const typograf = new Typograf({
@@ -5,10 +8,60 @@ const typograf = new Typograf({
 });
 
 const PROTECTED_TAGS = /<(script|style|pre|code|textarea)\b[^>]*>[\s\S]*?<\/\1>/gi;
+const HTML_INCLUDE = /<include\s+[^>]*\bsrc\s*=\s*(["'])([^"']+)\1[^>]*>(?:\s*<\/include\s*>)?/gi;
+
+function protectContents(source) {
+  const contents = [];
+  const protectedSource = source.replace(PROTECTED_TAGS, (fragment) => {
+    const index = contents.push(fragment) - 1;
+    return `<b2c-markup-protected data-index="${index}"></b2c-markup-protected>`;
+  });
+  return {
+    source: protectedSource,
+    restore(value) {
+      return value.replace(
+        /<b2c-markup-protected data-index="(\d+)"><\/b2c-markup-protected>/g,
+        (_, index) => contents[Number(index)]
+      );
+    },
+  };
+}
+
+function expandHtmlIncludes(source, {filePath, onInclude, chain = []}) {
+  const absolutePath = path.resolve(filePath);
+  if (chain.includes(absolutePath)) {
+    const cycle = [...chain, absolutePath].map((item) => path.relative(process.cwd(), item)).join(" -> ");
+    throw new Error(`Recursive HTML include detected: ${cycle}`);
+  }
+
+  const protectedMarkup = protectContents(source);
+  const expanded = protectedMarkup.source.replace(HTML_INCLUDE, (_match, _quote, includeSource) => {
+    const includePath = path.resolve(path.dirname(absolutePath), includeSource);
+    let includeMarkup;
+    try {
+      includeMarkup = fs.readFileSync(includePath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`HTML include not found: ${includePath} (included from ${absolutePath})`, {cause: error});
+      }
+      throw error;
+    }
+    onInclude?.(includePath);
+    return expandHtmlIncludes(includeMarkup, {
+      filePath: includePath,
+      onInclude,
+      chain: [...chain, absolutePath],
+    });
+  });
+  return protectedMarkup.restore(expanded);
+}
 
-export function processMarkup(html) {
+export function processMarkup(html, {filePath, onInclude} = {}) {
   const protectedContents = [];
-  const source = String(html || "").replace(PROTECTED_TAGS, (fragment) => {
+  const markup = filePath
+    ? expandHtmlIncludes(String(html || ""), {filePath, onInclude})
+    : String(html || "");
+  const source = markup.replace(PROTECTED_TAGS, (fragment) => {
     const index = protectedContents.push(fragment) - 1;
     return `<b2c-typograf-protected data-index="${index}"></b2c-typograf-protected>`;
   });

package/src/vite/config.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import path from "node:path";
 import {fileURLToPath} from "node:url";
 
 import {createServer} from "vite";
@@ -19,10 +20,27 @@ export function toViteFsUrl(filePath) {
 const clientEntryUrl = toViteFsUrl(clientEntry);
 let monkeyPlugin;
 
-export function resolveDevServerPort(env = process.env) {
+const DEFAULT_DEV_PORT = 5173;
+
+function devPortPath(root) {
+  return path.join(root, ".b2c", "dev-port");
+}
+
+export function resolveDevServerPort(env = process.env, root = process.cwd()) {
   const explicitPort = env.B2C_PORT;
   if (explicitPort === undefined || explicitPort === "") {
-    return {port: 5173, strictPort: false};
+    let savedPort;
+    try {
+      savedPort = fs.readFileSync(devPortPath(root), "utf8").trim();
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (!savedPort) return {port: DEFAULT_DEV_PORT, strictPort: false};
+    const port = Number(savedPort);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      throw new Error(`Invalid saved dev port in ${devPortPath(root)}. Remove the file or set B2C_PORT.`);
+    }
+    return {port, strictPort: true};
   }
   const port = Number(explicitPort);
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
@@ -31,6 +49,12 @@ export function resolveDevServerPort(env = process.env) {
   return {port, strictPort: true};
 }
 
+export function saveDevServerPort(root, port) {
+  const filePath = devPortPath(root);
+  fs.mkdirSync(path.dirname(filePath), {recursive: true});
+  fs.writeFileSync(filePath, `${port}\n`);
+}
+
 export function createTargetUrl(preset) {
   return `https://${preset.domain}/monkey/`;
 }
@@ -71,7 +95,7 @@ export async function createViteConfig(root = process.cwd(), options = {}) {
   const preset = options.preset || resolvePreset(config.site.preset);
   const monkey = await loadMonkeyPlugin();
   const shouldOpen = process.env.B2C_NO_OPEN !== "1";
-  const devPort = resolveDevServerPort();
+  const devPort = resolveDevServerPort(process.env, root);
   const vue = resolveScriptStack(config.stack.script).vue
     ? await loadProjectVuePlugin(root)
     : null;
@@ -111,8 +135,22 @@ export async function startDevServer(root = process.cwd()) {
   const config = await loadConfig(root);
   const preset = resolvePreset(config.site.preset);
   const shouldOpen = process.env.B2C_NO_OPEN !== "1";
-  const server = await createServer(await createViteConfig(root, {config, preset}));
-  await server.listen();
+  const viteConfig = await createViteConfig(root, {config, preset});
+  const server = await createServer(viteConfig);
+  try {
+    await server.listen();
+  } catch (error) {
+    if (viteConfig.server.strictPort && /port .*already in use/i.test(error.message)) {
+      throw new Error(
+        `${error.message}. Stop the process using this project's port or choose and save another one with ` +
+        `B2C_PORT=<free-port> npm run dev.`,
+        {cause: error}
+      );
+    }
+    throw error;
+  }
+  const address = server.httpServer?.address();
+  if (address && typeof address === "object") saveDevServerPort(root, address.port);
   server.printUrls();
   await presentTargetPage({preset, shouldOpen});
   return server;