@coraltravelcenter/b2c-landing-builder 2.0.0-next.0

package/README.md

@@ -0,0 +1,180 @@
+# @coraltravelcenter/b2c-landing-builder
+
+Глобальный CLI для разработки B2C-лендингов через Tampermonkey и сборки
+CMS-готовых HTML-файлов.
+
+## Установка
+
+Требуется Node.js 20.19 или новее.
+
+```bash
+npm install --global @coraltravelcenter/b2c-landing-builder
+```
+
+Builder устанавливается один раз и не копируется в проекты лендингов.
+
+## Команды
+
+Команды выполняются из корня проекта:
+
+```bash
+b2c-landing check
+b2c-landing dev
+b2c-landing build
+b2c-landing block:add hero
+b2c-landing block:rename hero main-hero
+b2c-landing update
+```
+
+- `check` проверяет конфигурацию, `order.json` и контракт JS-блоков.
+- `dev` запускает Vite и userscript для Tampermonkey.
+- `build` создаёт CMS-файлы в `@CMS/` и переписывает пути ассетов на CDN.
+- `block:add` создаёт файлы в выбранных форматах разметки и стилей.
+- `block:rename` атомарно переименовывает все файлы блока и обновляет порядок.
+- `update` проверяет npm registry и показывает команду ручного обновления.
+
+Builder никогда не обновляется автоматически:
+
+```bash
+b2c-landing update
+# Update manually: npm install --global @coraltravelcenter/b2c-landing-builder@latest
+```
+
+## Создание проекта
+
+Новые проекты создаются отдельным пакетом:
+
+```bash
+npm create @coraltravelcenter/b2c-landing-vite
+```
+
+Репозиторий генератора:
+[CoralTravelCenter/create-b2c-landing-vite](https://github.com/CoralTravelCenter/create-b2c-landing-vite).
+
+## Конфигурация
+
+В корне каждого проекта находится `landing.config.mjs`:
+
+```js
+export default {
+  schemaVersion: 1,
+  project: {
+    name: "uae-promo",
+  },
+  site: {
+    preset: "coral",
+  },
+  stack: {
+    script: "vue",
+    markup: "pug",
+    styles: "less",
+  },
+};
+```
+
+Имя проекта должно соответствовать `^[a-z0-9][a-z0-9-]*$`.
+
+Поддерживаются:
+
+- JavaScript: `vanilla`, `vue`;
+- разметка: `html`, `pug`;
+- стили: `css`, `scss`, `less`;
+- сайты: `coral`, `sunmar`.
+
+Monkey URL, контейнер и CDN prefix не задаются вручную:
+
+- URL: `https://<домен-пресета>/monkey/*`;
+- контейнер: `#monkey-app`;
+- CDN prefix: `landing-pages/<project.name>`.
+
+Production CDN Sunmar пока не настроен. `dev` и `check` доступны, но `build`
+завершается понятной ошибкой до добавления CDN в preset.
+
+## Структура проекта
+
+```text
+src/
+  order.json
+  markup/
+    welcome.html | welcome.pug
+  styles/
+    welcome.css | welcome.scss | welcome.less
+  scripts/
+    welcome.js
+  components/       # только для Vue
+public/
+pug.rc               # только для Pug
+landing.config.mjs
+package.json
+```
+
+В проекте не нужны `vite.config.js`, исходники builder или локальные build-скрипты.
+
+## Порядок блоков
+
+`src/order.json` является единственным источником порядка:
+
+```json
+{
+  "blocks": ["hero", "welcome"]
+}
+```
+
+Для каждого ключа builder ищет разметку, стиль и необязательный JS-файл с тем
+же именем. Форматы определяются `landing.config.mjs`.
+
+## Контракт JavaScript
+
+Если у блока есть `src/scripts/<key>.js`, файл обязан экспортировать функцию
+инициализации по умолчанию:
+
+```js
+export default function hero(container) {
+  const block = container.querySelector(".hero");
+  if (!block) return;
+
+  // Инициализация блока.
+}
+```
+
+Builder вставляет разметку, затем вызывает функцию. Этот контракт одинаков для
+dev, HMR и CMS build. Блок без JS допустим.
+
+## Ассеты
+
+Файлы хранятся в `public/` и используются от корня:
+
+```html
+<img src="/hero.webp" alt="">
+```
+
+```css
+.hero {
+  background-image: url("/hero.webp");
+}
+```
+
+В dev пути направляются на `http://127.0.0.1:5173`. При production build они
+преобразуются в `<assetsBase>/landing-pages/<project.name>/...`.
+
+## Совместимость
+
+Builder проверяет `schemaVersion` до запуска команд. Несовместимая версия схемы
+блокирует работу. Для аварийной сборки старого проекта можно использовать:
+
+```bash
+npx @coraltravelcenter/b2c-landing-builder@<version> build
+```
+
+## Разработка пакета
+
+```bash
+npm ci
+npm test
+npm run check
+npm run build
+npm pack --dry-run
+```
+
+Pull request проверяется на Node.js 20.19 и 22. Prerelease публикуется с npm
+dist-tag `next`, стабильная версия — с `latest`.

package/bin/b2c-landing.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import {runCli} from "../src/cli/index.mjs";
+
+runCli(process.argv.slice(2)).catch((error) => {
+  console.error(`[b2c-landing] ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@coraltravelcenter/b2c-landing-builder",
+  "version": "2.0.0-next.0",
+  "description": "CLI and build toolkit for B2C landing projects",
+  "type": "module",
+  "bin": {
+    "b2c-landing": "bin/b2c-landing.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/blocks/",
+    "src/cli/",
+    "src/config/",
+    "src/lib/",
+    "src/presets/",
+    "src/update/",
+    "src/vite/"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "dev": "node scripts/run-fixture.mjs dev",
+    "check": "node scripts/run-fixture.mjs check",
+    "build": "node scripts/run-fixture.mjs build",
+    "test": "node --test test/*.test.mjs",
+    "test:dev": "node scripts/smoke-dev.mjs",
+    "pack:check": "npm pack --dry-run"
+  },
+  "dependencies": {
+    "@vitejs/plugin-vue": "^6.0.7",
+    "less": "^4.6.7",
+    "pug": "^3.0.4",
+    "sass": "^1.101.0",
+    "typograf": "^7.7.0",
+    "vite": "^8.1.4",
+    "vite-plugin-monkey": "^8.0.6",
+    "vue": "^3.5.39"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CoralTravelCenter/b2c-landing-vite.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/src/blocks/add.mjs

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {assertBlockKey, readOrder, writeOrder} from "./utils.mjs";
+
+function markupTemplate(key, format) {
+  return format === "pug" ? `section.${key}\n` : `<section class="${key}">\n</section>\n`;
+}
+
+function styleTemplate(key) {
+  return `.${key} {\n}\n`;
+}
+
+function scriptTemplate(key) {
+  const functionName = key.replace(/-+/g, "_");
+  return `export default function ${functionName}(container) {\n  const block = container.querySelector(".${key}");\n  if (!block) return;\n}\n`;
+}
+
+export function addBlock(key, config, root = process.cwd()) {
+  assertBlockKey(key);
+  const {order, orderPath} = readOrder(root);
+  if (order.blocks.includes(key)) throw new Error(`Block already exists in src/order.json: ${key}`);
+
+  const files = [
+    [path.resolve(root, "src/markup", `${key}.${config.stack.markup}`), markupTemplate(key, config.stack.markup)],
+    [path.resolve(root, "src/styles", `${key}.${config.stack.styles}`), styleTemplate(key)],
+    [path.resolve(root, "src/scripts", `${key}.js`), scriptTemplate(key)],
+  ];
+  const collision = files.find(([filePath]) => fs.existsSync(filePath));
+  if (collision) throw new Error(`Cannot add block; target already exists: ${path.relative(root, collision[0])}`);
+
+  for (const [filePath, source] of files) {
+    fs.mkdirSync(path.dirname(filePath), {recursive: true});
+    fs.writeFileSync(filePath, source);
+    console.log(`[block:add] created: ${path.relative(root, filePath)}`);
+  }
+  order.blocks.push(key);
+  writeOrder(orderPath, order);
+  console.log(`[block:add] order.json updated (+${key})`);
+}

package/src/blocks/rename.mjs

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {assertBlockKey, readOrder, writeOrder} from "./utils.mjs";
+
+const FILES = {markup: ["html", "pug"], styles: ["css", "scss", "less"], scripts: ["js"]};
+
+export function renameBlock(fromKey, toKey, root = process.cwd()) {
+  assertBlockKey(fromKey, "source block key");
+  assertBlockKey(toKey, "target block key");
+  if (fromKey === toKey) throw new Error("Source and target block keys are identical");
+
+  const {order, orderPath} = readOrder(root);
+  if (!order.blocks.includes(fromKey)) throw new Error(`Block is absent from src/order.json: ${fromKey}`);
+  if (order.blocks.includes(toKey)) throw new Error(`Target block already exists in src/order.json: ${toKey}`);
+
+  const moves = [];
+  for (const [directory, extensions] of Object.entries(FILES)) {
+    for (const extension of extensions) {
+      const source = path.resolve(root, "src", directory, `${fromKey}.${extension}`);
+      if (!fs.existsSync(source)) continue;
+      moves.push({source, target: path.resolve(root, "src", directory, `${toKey}.${extension}`)});
+    }
+  }
+  if (!moves.length) throw new Error(`No files found for block: ${fromKey}`);
+  const collision = moves.find(({target}) => fs.existsSync(target));
+  if (collision) throw new Error(`Cannot rename block; target already exists: ${path.relative(root, collision.target)}`);
+
+  for (const {source, target} of moves) {
+    fs.renameSync(source, target);
+    console.log(`[block:rename] renamed: ${path.relative(root, source)} → ${path.relative(root, target)}`);
+  }
+  order.blocks = order.blocks.map((key) => key === fromKey ? toKey : key);
+  writeOrder(orderPath, order);
+  console.log(`[block:rename] order.json updated (${fromKey} → ${toKey})`);
+}

package/src/blocks/utils.mjs

@@ -0,0 +1,26 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const BLOCK_KEY_RE = /^[a-z0-9][a-z0-9-_]*$/i;
+
+export function assertBlockKey(key, label = "block key") {
+  if (!BLOCK_KEY_RE.test(key || "")) {
+    throw new Error(`Invalid ${label}: ${JSON.stringify(key)}`);
+  }
+}
+
+export function readOrder(root) {
+  const orderPath = path.resolve(root, "src/order.json");
+  let order;
+  try {
+    order = JSON.parse(fs.readFileSync(orderPath, "utf8"));
+  } catch (error) {
+    throw new Error(`Cannot read src/order.json: ${error.message}`, {cause: error});
+  }
+  if (!Array.isArray(order.blocks)) throw new Error("src/order.json must contain a blocks array");
+  return {order, orderPath};
+}
+
+export function writeOrder(orderPath, order) {
+  fs.writeFileSync(orderPath, `${JSON.stringify(order, null, 2)}\n`);
+}

package/src/cli/index.mjs

@@ -0,0 +1,71 @@
+import {loadConfig} from "../config/load-config.mjs";
+import {resolvePreset} from "../config/resolve-preset.mjs";
+import {validateProject} from "../config/validate-project.mjs";
+
+const usage = `Usage: b2c-landing <command>
+
+Commands:
+  dev                       Start the Vite development server
+  build                     Build CMS-ready HTML files
+  check                     Validate project configuration
+  block:add <key>           Create a block
+  block:rename <old> <new>  Rename a block
+  update                    Show the manual update command`;
+
+async function check() {
+  const config = await loadConfig();
+  const preset = resolvePreset(config.site.preset);
+  const project = validateProject(config);
+  console.log(`[check] project: ${config.project.name}`);
+  console.log(`[check] schemaVersion: ${config.schemaVersion}`);
+  console.log(`[check] site: ${preset.id} (${preset.domain})`);
+  if (preset.assetsBase) {
+    console.log(`[check] assets: ${preset.assetsBase}/landing-pages/${config.project.name}`);
+  } else {
+    console.log(`[check] assets: not configured for ${preset.id} (production build unavailable)`);
+  }
+  console.log(`[check] blocks: ${project.blocks.length}`);
+}
+
+export async function runCli(args) {
+  const [command, ...rest] = args;
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    console.log(usage);
+    return;
+  }
+
+  if (command === "check") return check();
+  if (command === "dev") {
+    await loadConfig();
+    const {startDevServer} = await import("../vite/config.mjs");
+    return startDevServer();
+  }
+  if (command === "build") {
+    const config = await loadConfig();
+    const preset = resolvePreset(config.site.preset, {requireAssets: true});
+    const {buildCms} = await import("../lib/build-cms.mjs");
+    await buildCms({config});
+    process.env.B2C_ASSETS_BASE = preset.assetsBase;
+    process.env.B2C_ASSETS_PREFIX = `landing-pages/${config.project.name}`;
+    await import(`../lib/rewriteAssetsBuild.mjs?t=${Date.now()}`);
+    return;
+  }
+  if (command === "block:add" || command === "block:rename") {
+    const config = await loadConfig();
+    if (command === "block:add") {
+      if (rest.length !== 1) throw new Error("Usage: b2c-landing block:add <key>");
+      const {addBlock} = await import("../blocks/add.mjs");
+      return addBlock(rest[0], config);
+    }
+    if (rest.length !== 2) throw new Error("Usage: b2c-landing block:rename <old> <new>");
+    const {renameBlock} = await import("../blocks/rename.mjs");
+    return renameBlock(rest[0], rest[1]);
+  }
+  if (command === "update") {
+    const {printUpdateStatus} = await import("../update/check-update.mjs");
+    return printUpdateStatus();
+  }
+
+  throw new Error(`Unknown command ${JSON.stringify(command)}\n\n${usage}`);
+}

package/src/config/load-config.mjs

@@ -0,0 +1,20 @@
+import path from "node:path";
+import {pathToFileURL} from "node:url";
+
+import {validateConfig} from "./validate-config.mjs";
+
+export async function loadConfig(root = process.cwd()) {
+  const configPath = path.resolve(root, "landing.config.mjs");
+  let module;
+
+  try {
+    module = await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
+  } catch (error) {
+    if (error?.code === "ERR_MODULE_NOT_FOUND" && error?.url?.startsWith(pathToFileURL(configPath).href)) {
+      throw new Error(`landing.config.mjs not found in ${root}`, {cause: error});
+    }
+    throw new Error(`Cannot load landing.config.mjs: ${error.message}`, {cause: error});
+  }
+
+  return validateConfig(module.default);
+}

package/src/config/resolve-preset.mjs

@@ -0,0 +1,13 @@
+import coral from "../presets/coral.mjs";
+import sunmar from "../presets/sunmar.mjs";
+
+const presets = {coral, sunmar};
+
+export function resolvePreset(id, {requireAssets = false} = {}) {
+  const preset = presets[id];
+  if (!preset) throw new Error(`Unknown site preset: ${JSON.stringify(id)}`);
+  if (requireAssets && !preset.assetsBase) {
+    throw new Error(`Production CDN is not configured for site preset ${JSON.stringify(id)}`);
+  }
+  return preset;
+}

package/src/config/validate-config.mjs

@@ -0,0 +1,32 @@
+const PROJECT_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+const SUPPORTED_SCHEMA_VERSIONS = new Set([1]);
+const STACK_VALUES = {
+  script: new Set(["vanilla", "vue"]),
+  markup: new Set(["html", "pug"]),
+  styles: new Set(["css", "scss", "less"]),
+};
+const SITE_PRESETS = new Set(["coral", "sunmar"]);
+
+export function validateConfig(config) {
+  if (!config || Array.isArray(config) || typeof config !== "object") {
+    throw new Error("landing.config.mjs must export an object by default");
+  }
+  if (!SUPPORTED_SCHEMA_VERSIONS.has(config.schemaVersion)) {
+    throw new Error(
+      `Unsupported schemaVersion ${JSON.stringify(config.schemaVersion)}. ` +
+      "This builder supports schemaVersion 1."
+    );
+  }
+  if (!PROJECT_NAME_RE.test(config.project?.name || "")) {
+    throw new Error("project.name must match ^[a-z0-9][a-z0-9-]*$");
+  }
+  if (!SITE_PRESETS.has(config.site?.preset)) {
+    throw new Error(`Unknown site preset: ${JSON.stringify(config.site?.preset)}`);
+  }
+  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])}`);
+    }
+  }
+  return config;
+}

package/src/config/validate-project.mjs

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const BLOCK_KEY_RE = /^[a-z0-9][a-z0-9-_]*$/i;
+const DEFAULT_EXPORT_RE = /\bexport\s+default\s+(?:async\s+)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>|[A-Za-z_$][\w$]*\s*;?)/;
+
+function readJson(filePath, label) {
+  let source;
+  try {
+    source = fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new Error(`${label} not found: ${filePath}`, {cause: error});
+  }
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    throw new Error(`Invalid ${label}: ${error.message}`, {cause: error});
+  }
+}
+
+export function validateProject(config, root = process.cwd()) {
+  const orderPath = path.resolve(root, "src/order.json");
+  const order = readJson(orderPath, "src/order.json");
+  if (!Array.isArray(order.blocks)) {
+    throw new Error("src/order.json must contain a blocks array");
+  }
+
+  const seen = new Set();
+  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)}`);
+    }
+    if (seen.has(key)) throw new Error(`Duplicate block key in src/order.json: ${key}`);
+    seen.add(key);
+
+    const markupPath = path.resolve(root, "src/markup", `${key}.${config.stack.markup}`);
+    if (!fs.existsSync(markupPath)) {
+      throw new Error(`Missing configured markup for block ${key}: src/markup/${key}.${config.stack.markup}`);
+    }
+
+    const scriptPath = path.resolve(root, "src/scripts", `${key}.js`);
+    if (!fs.existsSync(scriptPath)) continue;
+    const source = fs.readFileSync(scriptPath, "utf8");
+    if (!DEFAULT_EXPORT_RE.test(source)) {
+      throw new Error(
+        `src/scripts/${key}.js must export its initializer as default function`
+      );
+    }
+  }
+
+  return {blocks: [...order.blocks]};
+}

package/src/lib/_utils.mjs

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** project root = process.cwd() */
+export const ROOT = process.cwd();
+
+/** resolve from ROOT */
+export function r(...parts) {
+  return path.resolve(ROOT, ...parts);
+}
+
+export function readJsonSafe(filePath, fallback = null) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+export function readBlocks(orderFilePath) {
+  const json = readJsonSafe(orderFilePath, null);
+  const blocks = json?.blocks;
+  return Array.isArray(blocks) ? blocks.filter(Boolean) : [];
+}
+
+export function existsFile(p) {
+  try {
+    return fs.existsSync(p) && fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+export function ensureDir(p) {
+  fs.mkdirSync(p, {recursive: true});
+}
+
+export function cleanDir(p) {
+  if (!fs.existsSync(p)) return;
+  for (const name of fs.readdirSync(p)) {
+    fs.rmSync(path.join(p, name), {recursive: true, force: true});
+  }
+}
+
+/** write only if content differs */
+export function writeIfChanged(filePath, next, logLabel = "") {
+  const prev = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+  if (prev !== next) {
+    fs.writeFileSync(filePath, next);
+    if (logLabel) console.log(logLabel);
+    return true;
+  }
+  return false;
+}
+
+export function normalizeHtml(html) {
+  return String(html || "").replace(/\r\n/g, "\n").trim();
+}
+
+export function absEq(a, b) {
+  return path.resolve(a) === path.resolve(b);
+}