@vnejs/tools 0.0.28

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@vnejs/tools",
+  "version": "0.0.28",
+  "description": "CLI tools of @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"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "1.1.0",
+    "commander": "13.1.0",
+    "fluent-ffmpeg": "2.1.3",
+    "sharp": "0.33.5"
+  }
+}

package/src/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+
+const resizeAction = require("./resize");
+const locKeysAction = require("./lockeys");
+
+const packageJson = require("../package.json");
+
+const program = new Command();
+
+program.name(packageJson.name).description(packageJson.description).version(packageJson.version);
+
+program
+  .command("resize")
+  .option("-t, --target <target>", "resize target", "all")
+  .option("-w, --web", "web mode (less quality)", false)
+  .option("-q, --quiet", "no console mode", false)
+  .option("--type <type>", "resize type (image, video, audio)")
+  .option("-m, --media <media...>", "media directories")
+  .action(resizeAction);
+
+program
+  .command("lockeys")
+  .option("-m, --mode <mode>", "dirname inside dir 'game'")
+  .option("-s, --scenario <scenario>", "scenario file inside mod dir")
+  .option("-l, --langs <langs...>", "langs to create locfiles")
+  .action(locKeysAction);
+
+program.parse();

package/src/lockeys/index.js

@@ -0,0 +1,54 @@
+const path = require("path");
+const fs = require("fs");
+
+const { readFile } = require("../utils/filesystem");
+
+const gameDir = path.join(process.env.PWD, "game");
+
+const quotesRegepx = /\"(.*?)\"/g;
+
+module.exports = async (options) => {
+  if (!options.scenario || !options.langs || !options.mode) {
+    console.error(`No values for scenario file or langs or mode`);
+    console.error(`sceanrio: ${options.scenario}`);
+    console.error(`langs: ${options.langs}`);
+    console.error(`mode: ${options.mode}`);
+    return;
+  }
+
+  const lines = await readFile(path.join(gameDir, options.mode, "scenario", options.scenario));
+  const result = {};
+
+  let curLabel = "";
+
+  lines
+    .toString()
+    .split("\n")
+    .filter((line) => line.startsWith("label") || line.includes('"'))
+    .forEach((line) => {
+      if (line.startsWith("label")) {
+        curLabel = line.slice(6, line.length - (line.endsWith(":") ? 1 : 0));
+        result[curLabel] = {};
+      } else {
+        line.match(quotesRegepx).forEach((text) => {
+          const valueWithoutQuotes = text.slice(1, text.length - 1);
+          result[curLabel][valueWithoutQuotes] = valueWithoutQuotes;
+        });
+      }
+    });
+
+  Object.keys(result).forEach((labelName) => {
+    options.langs.forEach((lang) => {
+      const newContent = { ...result[labelName] };
+      const filePath = path.join(gameDir, options.mode, "media", "locs", lang, `${labelName}.json`);
+      if (fs.existsSync(filePath)) {
+        const oldContent = JSON.parse(fs.readFileSync(filePath));
+
+        Object.keys(oldContent).forEach((key) => {
+          if (newContent[key] && oldContent[key] !== key) newContent[key] = oldContent[key];
+        });
+      }
+      fs.writeFileSync(filePath, JSON.stringify(newContent, null, 2));
+    });
+  });
+};

package/src/resize/audio.js

@@ -0,0 +1,74 @@
+const path = require("path");
+
+const { createDir, getFilesInDir, readDir } = require("../utils/filesystem");
+const { clear, ffmpeg } = require("./utils");
+
+const gameDir = path.join(process.env.PWD, "game");
+
+const resizeOne = async (toDirName, mediaDir, mediaTypes, quality, fromDirName, options) => {
+  const promises = [];
+
+  await Promise.all(
+    mediaTypes.map(async (mediaType) => {
+      const files = await getFilesInDir(path.join(mediaDir, mediaType, fromDirName));
+
+      if (files.length) await createDir(path.join(mediaDir, mediaType, toDirName));
+
+      files.forEach((filename) => {
+        if (filename.startsWith(".")) return;
+
+        promises.push(async () => {
+          const fromFullName = path.join(mediaDir, mediaType, fromDirName, filename);
+          const splittedFileName = filename.split("/");
+          const toFullName = path.join(mediaDir, mediaType, toDirName, filename);
+          const toFullNameMp3 = toFullName.slice(0, toFullName.lastIndexOf(".")) + ".mp3";
+
+          await createDir(
+            path.join(mediaDir, mediaType, toDirName, ...splittedFileName.slice(0, splittedFileName.length - 1))
+          );
+
+          await new Promise((resolve) => setTimeout(resolve, 0));
+
+          return new Promise((resolve) =>
+            ffmpeg(fromFullName)
+              .inputOptions(["-re"])
+              .audioBitrate(quality)
+              .audioCodec("libmp3lame")
+              .on("start", () => !options.quiet && console.log("start resizing ", filename, quality))
+              .on("end", () => {
+                !options.quiet && console.log("finish resizing ", filename, quality);
+                resolve();
+              })
+              .save(toFullNameMp3)
+          );
+        });
+      });
+    })
+  );
+
+  await Promise.all(promises.map((i) => i()));
+};
+const resize = async (toDirName, mediaTypes, quality, fromDirName, options) => {
+  const mods = await readDir(gameDir);
+
+  return Promise.all(
+    mods.map((mod) => resizeOne(toDirName, path.join(gameDir, mod, "media"), mediaTypes, quality, fromDirName, options))
+  );
+};
+
+module.exports = async (options) => {
+  const promises = [];
+  const addPromise = (c, quality) =>
+    promises.push(async () => {
+      if (!c) return;
+
+      const dirName = `${quality}k`;
+      await clear(dirName, options.media);
+      await resize(dirName, options.media, quality, "original", options);
+    });
+
+  addPromise(["96", "all", "dev"].includes(options.target), 96);
+  addPromise(["128", "all"].includes(options.target), 128);
+
+  for (let i = 0; i < promises.length; i++) await promises[i]();
+};

package/src/resize/image.js

@@ -0,0 +1,86 @@
+const path = require("path");
+const sharp = require("sharp");
+
+const { createDir, getFilesInDir, readFile, readDir } = require("../utils/filesystem");
+const { clear } = require("./utils");
+
+const gameDir = path.join(process.env.PWD, "game");
+
+const resizeOne = async (toDirName, mediaDir, mediaTypes, getSizes, fromDirName, options) => {
+  const promises = [];
+  const quality = options.web ? 80 : 100;
+
+  await Promise.all(
+    mediaTypes.map(async (mediaType) => {
+      const files = await getFilesInDir(path.join(mediaDir, mediaType, fromDirName));
+
+      if (files.length) await createDir(path.join(mediaDir, mediaType, toDirName));
+
+      files.forEach((filename) => {
+        if (filename.startsWith(".")) return;
+
+        promises.push(async () => {
+          const img = await readFile(path.join(mediaDir, mediaType, fromDirName, filename));
+          const splittedFileName = filename.split("/");
+
+          await createDir(
+            path.join(mediaDir, mediaType, toDirName, ...splittedFileName.slice(0, splittedFileName.length - 1))
+          );
+
+          await new Promise((resolve) => setTimeout(resolve, 0));
+
+          try {
+            const isGif = filename.endsWith(".gif");
+            const image = sharp(img, { animated: isGif });
+            const resultFilename = path.join(mediaDir, mediaType, toDirName, filename);
+
+            await image
+              .clone()
+              .resize(...getSizes(await image.metadata()))
+              [isGif ? "gif" : "webp"]({ quality, alphaQuality: 100 })
+              .toFile(isGif ? resultFilename : `${resultFilename.slice(0, resultFilename.lastIndexOf("."))}.webp`);
+          } catch (e) {
+            !options.quiet && console.log("resized error", toDirName, mediaType, filename, e);
+            return;
+          }
+
+          !options.quiet && console.log("resized success", toDirName, mediaType, filename);
+        });
+      });
+    })
+  );
+
+  await Promise.all(promises.map((promiseFunc) => promiseFunc()));
+};
+const resize = async (toDirName, mediaTypes, getSizes, fromDirName, options) => {
+  const mods = await readDir(gameDir);
+
+  return Promise.all(
+    mods.map((mod) =>
+      resizeOne(toDirName, path.join(gameDir, mod, "media"), mediaTypes, getSizes, fromDirName, options)
+    )
+  );
+};
+
+module.exports = async (options) => {
+  const promises = [];
+  const addPromise = (c, height) =>
+    promises.push(async () => {
+      if (!c) return;
+      const dirName = `${height}p`;
+      await clear(dirName, options.media);
+      await Promise.all([
+        resize(dirName, options.media, (d) => [Math.round((d.width * height) / 1080)], "original", options),
+        resize(dirName, options.media, (d) => [Math.round((d.width * height) / 2160)], "original-4k", options),
+      ]);
+    });
+
+  addPromise(["all", "mobile", "360"].includes(options.target), 360);
+  addPromise(["all", "mobile", "540"].includes(options.target), 540);
+  addPromise(["all", "mobile", "desktop", "test", "720"].includes(options.target), 720);
+  addPromise(["all", "mobile", "desktop", "test", "dev", "1080"].includes(options.target), 1080);
+  addPromise(["all", "desktop", "1440"].includes(options.target), 1440);
+  addPromise(["all", "desktop", "2160"].includes(options.target), 2160);
+
+  for (let i = 0; i < promises.length; i++) await promises[i]();
+};

package/src/resize/index.js

@@ -0,0 +1,8 @@
+module.exports = (options) => {
+  if (!["image", "video", "audio"].includes(options.type))
+    return console.error("error: incorrect or missing 'type' option");
+
+  if (options.type === "audio") return require("./audio")(options);
+  if (options.type === "image") return require("./image")(options);
+  if (options.type === "video") return require("./video")(options);
+};

package/src/resize/utils.js

@@ -0,0 +1,18 @@
+const path = require("path");
+const ffmpegPath = require("@ffmpeg-installer/ffmpeg").path;
+const ffmpeg = require("fluent-ffmpeg");
+ffmpeg.setFfmpegPath(ffmpegPath);
+
+const { removeDir, readDir } = require("../utils/filesystem");
+
+const gameDir = path.join(process.env.PWD, "game");
+
+const clearOne = (dirName, mediaDir, mediaTypes) =>
+  Promise.all(mediaTypes.map((mediaType) => removeDir(path.join(mediaDir, mediaType, dirName))));
+const clear = async (dirName, mediaTypes) => {
+  const mods = await readDir(gameDir);
+
+  return Promise.all(mods.map((mod) => clearOne(dirName, path.join(gameDir, mod, "media"), mediaTypes)));
+};
+
+module.exports = { clearOne, clear, ffmpeg };

package/src/resize/video.js

@@ -0,0 +1,83 @@
+const path = require("path");
+
+const { createDir, getFilesInDir, readDir } = require("../utils/filesystem");
+const { clear, ffmpeg } = require("./utils");
+
+const gameDir = path.join(process.env.PWD, "game");
+
+const resizeOne = async (toDirName, mediaDir, mediaTypes, height, fromDirName, options) => {
+  const promises = [];
+
+  await Promise.all(
+    mediaTypes.map(async (mediaType) => {
+      const files = await getFilesInDir(path.join(mediaDir, mediaType, fromDirName));
+
+      if (files.length) await createDir(path.join(mediaDir, mediaType, toDirName));
+
+      files.forEach((filename) => {
+        if (filename.startsWith(".")) return;
+
+        promises.push(async () => {
+          const fromFullName = path.join(mediaDir, mediaType, fromDirName, filename);
+          const splittedFileName = filename.split("/");
+          const toFullName = path.join(mediaDir, mediaType, toDirName, filename);
+          const toFullNameMp4 = toFullName.slice(0, toFullName.lastIndexOf(".")) + ".mp4";
+
+          await createDir(
+            path.join(mediaDir, mediaType, toDirName, ...splittedFileName.slice(0, splittedFileName.length - 1))
+          );
+
+          await new Promise((resolve) => setTimeout(resolve, 0));
+
+          return new Promise((resolve) =>
+            ffmpeg(fromFullName)
+              .inputOptions(["-re"])
+              .size(`?x${height}`)
+              .aspect("16:9")
+              .on("start", () => !options.quiet && console.log("start resizing ", filename, height))
+              .on("end", () => {
+                !options.quiet && console.log("finish resizing ", filename, height);
+                resolve();
+              })
+              .save(toFullNameMp4)
+          );
+        });
+      });
+    })
+  );
+
+  await Promise.all(promises.map((i) => i()));
+};
+const resize = async (toDirName, mediaTypes, height, fromDirName, options) => {
+  const mods = await readDir(gameDir);
+
+  return Promise.all(
+    mods.map((mod) => resizeOne(toDirName, path.join(gameDir, mod, "media"), mediaTypes, height, fromDirName, options))
+  );
+};
+
+module.exports = async (options) => {
+  const promises = [];
+  const addPromise = (c, height) =>
+    promises.push(async () => {
+      if (!c) return;
+
+      const dirName = `${height}p`;
+      await clear(dirName, options.media);
+      await Promise.all([
+        resize(dirName, options.media, height, "original", options),
+        resize(dirName, options.media, height, "original-4k", options),
+      ]);
+    });
+
+  console.log(9999);
+
+  addPromise(["all", "mobile", "360"].includes(options.target), 360);
+  addPromise(["all", "mobile", "540"].includes(options.target), 540);
+  addPromise(["all", "mobile", "desktop", "test", "720"].includes(options.target), 720);
+  addPromise(["all", "mobile", "desktop", "test", "dev", "1080"].includes(options.target), 1080);
+  addPromise(["all", "desktop", "1440"].includes(options.target), 1440);
+  addPromise(["all", "desktop", "2160"].includes(options.target), 2160);
+
+  for (let i = 0; i < promises.length; i++) await promises[i]();
+};

package/src/utils/filesystem.js

@@ -0,0 +1,29 @@
+const fs = require("fs");
+const path = require("path");
+
+const createDir = (dirname) => new Promise((resolve) => fs.mkdir(dirname, { recursive: true }, resolve));
+const removeDir = (pathname) => new Promise((resolve) => fs.rm(pathname, { recursive: true }, resolve));
+const readFile = async (pathname) => new Promise((resolve) => fs.readFile(pathname, (err, data) => resolve(data)));
+const readDir = async (pathname) => new Promise((resolve) => fs.readdir(pathname, (err, files) => resolve(files)));
+const getLstat = async (pathname) => new Promise((resolve) => fs.lstat(pathname, (err, stats) => resolve(stats)));
+
+const getFilesInDir = async (dirPath, prefix = "") => {
+  let result = await readDir(dirPath);
+  if (!result) return [];
+  let resultInfo = await Promise.all(result.map((fileOrDirPath) => getLstat(path.join(dirPath, fileOrDirPath))));
+
+  while (!resultInfo.every((stat) => stat.isFile())) {
+    const dirs = result.filter((_, i) => resultInfo[i].isDirectory());
+    result = result.filter((i) => !dirs.includes(i));
+
+    for (let i = 0; i < dirs.length; i++) {
+      result.push(...(await getFilesInDir(path.join(dirPath, dirs[i]), dirs[i])));
+    }
+
+    resultInfo = await Promise.all(result.map((fileOrDirPath) => getLstat(path.join(dirPath, fileOrDirPath))));
+  }
+
+  return prefix ? result.map((filename) => `${prefix}/${filename}`) : result;
+};
+
+module.exports = { createDir, removeDir, readFile, readDir, getLstat, getFilesInDir };