arcadible 0.0.1 → 0.1.0

package/src/util/git.js

@@ -0,0 +1,23 @@
+"use strict";
+
+// [import]
+
+const execFile = require("node:child_process").execFile;
+
+// [function]
+
+const isDirty = function (root, cb) {
+  execFile("git", ["-C", root, "diff", "--quiet"], (err) => {
+    if (err) {
+      cb(true);
+      return;
+    }
+    execFile("git", ["-C", root, "diff", "--cached", "--quiet"], (err) => {
+      cb(Boolean(err));
+    });
+  });
+};
+
+// [export]
+
+module.exports = { isDirty };

package/src/util/log.js

@@ -0,0 +1,99 @@
+"use strict";
+
+// [import]
+
+const chalk = require("chalk");
+
+// [function]
+
+const log = function (
+  out,
+  message,
+  { bold = false, color = "white", nl = false } = {},
+) {
+  let text = message;
+  if (Array.isArray(text)) {
+    text = text.join("\n");
+  }
+  let marker = chalk;
+  if (bold) {
+    marker = chalk.bold;
+  }
+  out(marker[color](text.trim().concat(nl ? "\n" : "")));
+};
+
+// [function]
+
+const h = function (message) {
+  log(console.log, message, { bold: true });
+};
+
+// [function]
+
+const hnl = function (message) {
+  log(console.log, message, { bold: true, nl: true });
+};
+
+// [function]
+
+const p = function (message) {
+  log(console.log, message);
+};
+
+// [function]
+
+const pnl = function (message) {
+  log(console.log, message, { nl: true });
+};
+
+// [function]
+
+const hd = function (message) {
+  log(console.error, message, { bold: true, color: "red" });
+};
+
+// [function]
+
+const hdnl = function (message) {
+  log(console.error, message, { bold: true, color: "red", nl: true });
+};
+
+// [function]
+
+const pd = function (message) {
+  log(console.error, message, { color: "white" });
+};
+
+// [function]
+
+const pdnl = function (message) {
+  log(console.error, message, { color: "white", nl: true });
+};
+
+// [function]
+
+const hs = function (message) {
+  log(console.log, message, { bold: true, color: "green" });
+};
+
+// [function]
+
+const hsnl = function (message) {
+  log(console.log, message, { bold: true, color: "green", nl: true });
+};
+
+// [function]
+
+const ps = function (message) {
+  log(console.log, message, { color: "green" });
+};
+
+// [function]
+
+const psnl = function (message) {
+  log(console.log, message, { color: "green", nl: true });
+};
+
+// [export]
+
+module.exports = { h, hd, hdnl, hnl, hs, hsnl, p, pd, pdnl, pnl, ps, psnl };

package/src/util/md.js

@@ -0,0 +1,24 @@
+"use strict";
+
+// [import]
+
+const marked = require("marked");
+
+// [import]
+
+const dom = require("./dom");
+const strs = require("./strs");
+
+// [use]
+
+const stripLeadingInvisible = strs.stripLeadingInvisible;
+
+// [function]
+
+const parse = function (buf) {
+  return dom.sanitize(marked.parse(stripLeadingInvisible(buf)));
+};
+
+// [export]
+
+module.exports = { parse };

package/src/util/objs.js

@@ -0,0 +1,26 @@
+"use strict";
+
+// [function]
+
+const pruneEmpty = function (value) {
+  /* eslint-disable no-undefined */
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    const cleaned = value.map(pruneEmpty).filter((v) => v !== undefined);
+    return cleaned.length ? cleaned : undefined;
+  }
+  if (typeof value === "object") {
+    const cleaned = Object.fromEntries(
+      Object.entries(value)
+        .map(([k, v]) => [k, pruneEmpty(v)])
+        .filter(([, v]) => v !== undefined),
+    );
+    return Object.keys(cleaned).length ? cleaned : undefined;
+  }
+  return value;
+  /* eslint-enable no-undefined */
+};
+// [export];
+module.exports = { pruneEmpty };

package/src/util/promise.js

@@ -0,0 +1,29 @@
+"use strict";
+
+// [function]
+
+const aConcat = function (ls) {
+  return Array.prototype.concat.bind(ls);
+};
+
+// [function]
+
+const pConcat = function (fn) {
+  return (ls) => fn(ls).then(aConcat(ls));
+};
+
+// [function]
+
+const pReduce = function (p, fn) {
+  return p.then(pConcat(fn));
+};
+
+// [function]
+
+const serial = function (fns) {
+  return fns.reduce(pReduce, Promise.resolve([]));
+};
+
+// [export]
+
+module.exports = { serial };

package/src/util/rc.js

@@ -0,0 +1,41 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const rc = require("rc");
+
+// [use]
+
+const join = path.join;
+const resolve = path.resolve;
+
+// [function]
+
+const cwd = function (argv, option) {
+  let dir = ".";
+  const idx = argv.findIndex((arg) => option.includes(arg));
+  if (idx !== -1 && argv[idx + 1] && !argv[idx + 1].startsWith("-")) {
+    dir = argv[idx + 1];
+  }
+  return dir;
+};
+
+// [function]
+
+const config = function (cmd, argv, option) {
+  return join(resolve(process.cwd(), cwd(argv, option)), `.${cmd}rc`);
+};
+
+// [function]
+
+const findRc = function (cmd, subcmd, argv, option) {
+  return rc(cmd, {}, { config: config(cmd, argv, option) })[subcmd] || {};
+};
+
+// [export]
+
+module.exports = { findRc };

package/src/util/strs.js

@@ -0,0 +1,21 @@
+"use strict";
+
+// [function]
+
+const stripLeadingInvisible = function (str) {
+  return String(str).replace(
+    // eslint-disable-next-line no-misleading-character-class
+    /^[\u200B\u200C\u200D\u2060\u2061\u2062\u2063\uFEFF]+/u,
+    "",
+  );
+};
+
+// [function]
+
+const trimWhitespace = function (str) {
+  return String(str).trim();
+};
+
+// [export]
+
+module.exports = { stripLeadingInvisible, trimWhitespace };

package/src/util/zip.js

@@ -0,0 +1,59 @@
+"use strict";
+
+// [import]
+
+const crypto = require("node:crypto");
+const path = require("node:path");
+
+// [import]
+
+const AdmZip = require("adm-zip");
+
+// [use]
+
+const createHash = crypto.createHash;
+const join = path.join;
+
+// [class]
+
+const Main = class {
+
+  // [constructor]
+
+  constructor(prefix) {
+    this.prefix = prefix;
+    this.zip = new AdmZip();
+  }
+
+  // [method]
+
+  addDir(dir, name = "") {
+    this.zip.addLocalFolder(dir, name ? join(this.prefix, name) : this.prefix);
+  }
+
+  // [method]
+
+  addJson(name, value) {
+    const entry = join(this.prefix, name);
+    const content = Buffer.from(JSON.stringify(value, null, 2), "utf8");
+    this.zip.addFile(entry, content);
+  }
+
+  // [method]
+
+  stat() {
+    const buffer = this.zip.toBuffer();
+    const hash = createHash("sha256").update(buffer).digest("hex");
+    return { sha256: hash, size: buffer.length };
+  }
+
+  // [method]
+
+  write(outPath) {
+    this.zip.writeZip(outPath);
+  }
+};
+
+// [export]
+
+module.exports = Main;