@vnejs/build 0.0.1

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@vnejs/build",
+  "version": "0.0.1",
+  "description": "Build tools for @vnejs",
+  "source": "src/index.js",
+  "main": "dist/index.js",
+  "bin": {
+    "@vnejs/tools": "./src/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "publish:major": "npm version major && npm publish --access public",
+    "publish:minor": "npm version minor && npm publish --access public",
+    "publish:patch": "npm version patch && npm publish --access public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "lodash.merge": "4.6.2"
+  }
+}

package/src/data/index.js

@@ -0,0 +1,27 @@
+const fs = require("fs");
+const path = require("path");
+const merge = require("lodash.merge");
+const { runBuildData } = require("./utils");
+
+let result = {};
+
+const gameDir = path.join(process.env.PWD, "game");
+const distDir = path.join(process.env.PWD, "dist");
+
+module.exports = (options) => {
+  !options.watch && fs.rmSync(distDir, { recursive: true, force: true });
+  !options.watch && fs.mkdirSync(distDir);
+
+  fs.readdirSync(gameDir).forEach((modDir) => {
+    const newData = runBuildData({ modDir: path.join(gameDir, modDir) });
+    result = merge(result, newData);
+
+    fs.writeFileSync(path.join(distDir, `media.${modDir}.json`), JSON.stringify(newData.data.media));
+  });
+
+  Object.keys(result.label).forEach((label) => {
+    fs.writeFileSync(path.join(distDir, `label.${label}.json`), JSON.stringify(result.label[label]));
+  });
+
+  fs.writeFileSync(path.join(distDir, "mods.json"), JSON.stringify(fs.readdirSync(gameDir)));
+};

package/src/data/utils.js

@@ -0,0 +1,151 @@
+const fs = require("fs");
+const path = require("path");
+
+const labelReg = /^label (?<name>[a-zA-Z0-9А-Яа-я_-]+?):?$/;
+const importReg = /^import (?<filename>[a-zA-Z0-9_/]+?)$/;
+const keyValueReg = /(?<key>[a-zA-Z0-9_-]+): (?<value>.+)$/;
+const keyReg = /(?<key>[a-zA-Z0-9_-]+):$/;
+
+const rawValueReg = /^(\d+|\d+[.]\d+|["].*["]|true|false)$/;
+
+const commentStartChars = ["//", "#"];
+
+const mapValue = (value) => JSON.parse(rawValueReg.test(value) ? value : `"${value}"`);
+
+const readScenarioFile = (filename) => fs.readFileSync(`${filename}.vne`).toString().replace(/\r/g, "").split("\n");
+
+const getFilesInDir = (dirPath, prefix = "") => {
+  let result = fs.readdirSync(dirPath);
+
+  while (!result.every((dirOrFile) => fs.lstatSync(path.join(dirPath, dirOrFile)).isFile())) {
+    const dirs = result.filter((i) => fs.lstatSync(path.join(dirPath, i)).isDirectory());
+    result = result.filter((i) => !dirs.includes(i));
+
+    dirs.forEach((dir) => {
+      result.push(...getFilesInDir(path.join(dirPath, dir), dir));
+    });
+  }
+
+  return prefix ? result.map((filename) => `${prefix}/${filename}`) : result;
+};
+
+const prepareMediaInfo = (mediaDir, mediaSubType = null) =>
+  getFilesInDir(path.join(mediaDir, mediaSubType)).reduce((acc, file) => {
+    acc[file.slice(0, -path.parse(file).ext.length)] = `/media/${mediaSubType}/${file}`;
+
+    return acc;
+  }, {});
+
+const parseLines = (lines) => {
+  const realLines = [];
+  let curKeys = [];
+
+  lines
+    .filter((value) => {
+      const kek = value.trim();
+
+      return !commentStartChars.some((char) => kek.startsWith(char));
+    })
+    .map((line) => (line.endsWith(":") && !line.startsWith(" ") ? line.slice(0, line.length - 1) : line))
+    .forEach((line) => {
+      if (keyReg.test(line)) {
+        const { key } = line.match(keyReg).groups;
+        return curKeys.push({ key, indent: line.length - line.trim().length });
+      } else if (keyValueReg.test(line)) {
+        const { key, value } = line.match(keyValueReg).groups;
+
+        curKeys = curKeys.filter(({ indent } = {}) => indent < line.length - line.trim().length);
+
+        const args = curKeys.reduce((acc, { key }) => {
+          if (!acc[key]) {
+            acc[key] = {};
+          }
+          return acc[key];
+        }, realLines[realLines.length - 1].args);
+
+        args[key] = mapValue(value);
+      } else {
+        curKeys = [];
+        const realLine = line.trim();
+        realLines.push({
+          line: realLine,
+          indent: line.length - realLine.length,
+          args: {},
+        });
+      }
+    });
+
+  return realLines;
+};
+
+const runBuildData = ({ modDir } = {}) => {
+  const result = { data: {}, label: {} };
+  const mediaDir = path.join(modDir, "media");
+  const scenarioDir = path.join(modDir, "scenario");
+
+  if (fs.existsSync(mediaDir)) {
+    const media = fs.readdirSync(mediaDir).reduce((acc, mediaSubDir) => {
+      acc[mediaSubDir] = prepareMediaInfo(mediaDir, mediaSubDir);
+
+      return acc;
+    }, {});
+    result.data = { media };
+  }
+
+  if (fs.existsSync(scenarioDir)) {
+    const lines = readScenarioFile(`${scenarioDir}/index`);
+    let [curLine, curLabel, curIndent] = [0, null, 0];
+
+    while (curLine < lines.length) {
+      const line = lines[curLine];
+
+      if (line.trim().length) {
+        if (importReg.test(line)) {
+          let { filename } = line.match(importReg).groups;
+          lines.splice(curLine, 1, ...readScenarioFile(path.join(scenarioDir, filename)));
+          continue;
+        } else if (labelReg.test(line)) {
+          const nextLine = lines[curLine + 1];
+
+          let { name } = line.match(labelReg).groups;
+
+          curLabel = name;
+          curIndent = nextLine.length - nextLine.trim().length;
+        }
+      }
+
+      curLine++;
+    }
+
+    // fs.writeFileSync(path.join(rootDir, "dist", "data.json"), JSON.stringify({ media }));
+
+    let curLabel2 = null;
+
+    const kek = lines.reduce((acc, line) => {
+      if (labelReg.test(line)) {
+        let { name } = line.match(labelReg).groups;
+
+        curLabel2 = name;
+        acc[name] = [];
+      } else {
+        acc[curLabel2].push(line);
+      }
+
+      return acc;
+    }, {});
+
+    Object.keys(kek).map(async (label) => {
+      const minIndent = kek[label].reduce(
+        (acc, k) => Math.min(acc, k.length ? k.length - k.trim().length : 9999),
+        9999
+      );
+      // const maxIndent = kek[label].reduce((acc, k) => Math.max(acc, k.length - k.trim().length), -9999);
+      const lines = kek[label].map((a) => a.slice(minIndent)).filter(Boolean);
+      result.label[label] = { lines: parseLines(lines) };
+    });
+  }
+
+  return result;
+};
+
+module.exports = { runBuildData };

package/src/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+
+const dataAction = require("./data");
+
+const packageJson = require("../package.json");
+
+const program = new Command();
+
+program.name(packageJson.name).description(packageJson.description).version(packageJson.version);
+
+program
+  .command("data")
+  .option("-w, --watch", "watch mode", false)
+  .option("-q, --quiet", "no console mode", false)
+  .action(dataAction);
+
+program
+  .command("bundle")
+  .option("-w, --watch", "watch mode", false)
+  .option("-q, --quiet", "no console mode", false)
+  .action(dataAction);
+
+program.parse();