arcadible 0.0.1 → 0.1.0

package/src/readme.js

@@ -0,0 +1,144 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const fs = require("fs-extra");
+
+// [import]
+
+const dom = require("./util/dom");
+const MD = require("./util/md");
+const objs = require("./util/objs");
+const strs = require("./util/strs");
+
+// [use]
+
+const join = path.join;
+const pruneEmpty = objs.pruneEmpty;
+const readFile = fs.readFile;
+const trimWhitespace = strs.trimWhitespace;
+
+// [declare]
+
+const README = "README.md";
+
+// [function]
+
+const splitTitle = function (str) {
+  let title = "";
+  let shortTitle = "";
+  const m = str.match(/^(?<title>\S.*?)(?:\s*\((?<shortTitle>[^)]*)\))?$/u);
+  if (m && m.groups.title) {
+    title = m.groups.title.trim();
+  }
+  if (m && m.groups.shortTitle) {
+    shortTitle = m.groups.shortTitle.trim();
+  }
+  return [title, shortTitle];
+};
+
+// [function]
+
+const extractTitle = function (doc) {
+  const elTitle = doc.querySelector("h1");
+  let title = "";
+  let shortTitle = "";
+  if (elTitle) {
+    if (elTitle.textContent) {
+      [title, shortTitle] = splitTitle(elTitle.textContent);
+    }
+  }
+  return [title, shortTitle].map(trimWhitespace);
+};
+
+// [function]
+
+const extractTagline = function (doc) {
+  const elTagline = doc.querySelector("h2");
+  let tagline = "";
+  if (elTagline) {
+    if (elTagline.textContent) {
+      tagline = elTagline.textContent;
+    }
+  }
+  return trimWhitespace(tagline);
+};
+
+// [function]
+
+const extractBio = function (doc) {
+  const elBio = doc.querySelector("h2 + p");
+  let bio = "";
+  if (elBio) {
+    if (elBio.textContent) {
+      bio = elBio.textContent;
+    }
+  }
+  return trimWhitespace(bio);
+};
+
+// [function]
+
+const extractDescription = function (doc) {
+  const hrs = doc.querySelectorAll("hr");
+  if (hrs.length < 2) {
+    return "";
+  }
+  const first = hrs[0];
+  const last = hrs[hrs.length - 1];
+  const parts = [];
+  let node = first.nextSibling;
+  while (node && node !== last) {
+    parts.push(node.outerHTML || node.textContent);
+    node = node.nextSibling;
+  }
+  return trimWhitespace(parts.join(""));
+};
+
+// [function]
+
+const extract = function (html) {
+  const doc = new dom.DOM(html).window.document;
+  // eslint-disable-next-line camelcase
+  const [title, short_title] = extractTitle(doc);
+  const tagline = extractTagline(doc);
+  const bio = extractBio(doc);
+  const description = extractDescription(doc);
+  return Object.fromEntries(
+    // eslint-disable-next-line camelcase
+    Object.entries({ bio, description, short_title, tagline, title }).map(
+      ([k, v]) => [k, v || null],
+    ),
+  );
+};
+
+// [function]
+
+const parseReadme = function (buf) {
+  try {
+    return extract(MD.parse(buf));
+  } catch (ex) {
+    throw new Error(`Unable to parse ${README}: ${ex.message}`, { cause: ex });
+  }
+};
+
+// [function]
+
+const parse = function (root) {
+  return new Promise((resolve, reject) => {
+    readFile(join(root, README), "utf8")
+      .then(parseReadme)
+      .then(pruneEmpty)
+      .then((game) => ({ game }))
+      .then(resolve)
+      .catch(reject);
+  });
+};
+
+// [export]
+
+module.exports = { parse };

package/src/schema/game.js

@@ -0,0 +1,319 @@
+"use strict";
+
+// [import]
+
+const chalk = require("chalk");
+const z = require("zod");
+
+// [import]
+
+const audience = require("../config/audience");
+const dom = require("../util/dom");
+const genre = require("../config/genre");
+const input = require("../config/input");
+const orientation = require("../config/orientation");
+const visibility = require("../config/visibility");
+
+// [function]
+
+const reference = function (field) {
+  return chalk.cyan.underline(
+    `https://developer.arcadible.com/references/arcadible-manifest#${field}`,
+  );
+};
+
+// [function]
+
+const indent = function (text, spaces = 2) {
+  const pad = " ".repeat(spaces);
+  return text
+    .split("\n")
+    .map((line) => pad + line)
+    .join("\n");
+};
+
+// [function]
+
+const message = function (field, msg) {
+  return { message: [msg, indent(reference(field))].join("\n") };
+};
+
+// [function]
+
+const zText = function (field, { max, min }) {
+  return z
+    .string()
+    .min(min)
+    .max(max)
+    .regex(
+      /^[\p{L}0-9 .,!?'"():;-]+$/u,
+      message(field, "Contains invalid characters."),
+    );
+};
+
+// [function]
+
+const zPng = function () {
+  return z.string();
+};
+
+// [function]
+
+const zSvg = function () {
+  return z.string();
+};
+
+// [function]
+
+const zMp4 = function () {
+  return z.string();
+};
+
+// [function]
+
+const zVimeo = function () {
+  return z
+    .string()
+    .regex(
+      /^https:\/\/(?:www\.)?(?:vimeo\.com|player\.vimeo\.com\/video)\/([0-9]+)(?:[/?#].*)?$/iu,
+    );
+};
+
+// [function]
+
+const zYouTube = function () {
+  return z
+    .string()
+    .regex(
+      /^https:\/\/(?:www\.)?(?:youtube\.com\/(?:watch\?v=|embed\/)|youtu\.be\/)([A-Za-z0-9_-]{11})(?:[?&#].*)?$/iu,
+    );
+};
+
+// [function]
+
+const zAudience = function () {
+  // const field = "game.audience";
+  return z.optional(z.enum(audience));
+};
+
+// [function]
+
+const zBanner = function () {
+  // const field = "game.banner";
+  return z.optional(zPng());
+};
+
+// [function]
+
+const zBannerVideo = function () {
+  // const field = "game.banner_video";
+  return z.optional(zMp4());
+};
+
+// [function]
+
+const zBio = function () {
+  const field = "game.bio";
+  return z.optional(zText(field, { max: 192, min: 1 }));
+};
+
+// [function]
+
+const zCover = function () {
+  // const field = "game.cover";
+  return z.optional(zPng());
+};
+
+// [function]
+
+const zCoverVideo = function () {
+  // const field = "game.cover_video";
+  return z.optional(zMp4());
+};
+
+// [function]
+
+const zDescription = function () {
+  const field = "game.description";
+  return z.optional(
+    z
+      .string()
+      .min(1)
+      .max(4000)
+      .refine(
+        (html) => html === dom.sanitizeAfm(html),
+        message(field, "Contains invalid elements."),
+      ),
+  );
+};
+
+// [function]
+
+const zGallery = function () {
+  // const field = "game.gallery";
+  return z.optional(z.array(zPng()).min(1).max(12));
+};
+
+// [function]
+
+const zGenres = function () {
+  // const field = "game.genres";
+  return z.optional(z.array(z.enum(genre)).max(3));
+};
+
+// [function]
+
+const zHandle = function () {
+  const field = "game.handle";
+  return z.optional(
+    z
+      .string()
+      .regex(
+        /^[a-z0-9](?:(?![-]{2})[a-z0-9-]){1,22}[a-z0-9]$/u,
+        message(field, "Contains invalid characters."),
+      ),
+  );
+};
+
+// [function]
+
+const zIcon = function () {
+  // const field = "game.icon";
+  return z.optional(zPng());
+};
+
+// [function]
+
+const zIconVideo = function () {
+  // const field = "game.icon_video";
+  return z.optional(zMp4());
+};
+
+// [function]
+
+const zInputs = function () {
+  // const field = "game.inputs";
+  return z.optional(z.array(z.enum(input)).max(3));
+};
+
+// [function]
+
+const zOrientation = function () {
+  // const field = "game.orientation";
+  return z.optional(z.enum(orientation));
+};
+
+// [function]
+
+const zPoster = function () {
+  // const field = "game.poster";
+  return z.optional(zPng());
+};
+
+// [function]
+
+const zPosterVideo = function () {
+  // const field = "game.poster_video";
+  return z.optional(zMp4());
+};
+
+// [function]
+
+const zPrice = function () {
+  // const field = "game.price";
+  return z.optional(z.int().min(0).max(25));
+};
+
+// [function]
+
+const zShortTitle = function () {
+  const field = "game.short_title";
+  return z.optional(zText(field, { max: 16, min: 1 }));
+};
+
+// [function]
+
+const zTagline = function () {
+  const field = "game.tagline";
+  return z.optional(zText(field, { max: 96, min: 1 }));
+};
+
+// [function]
+
+const zTitle = function () {
+  const field = "game.title";
+  return z.optional(zText(field, { max: 64, min: 1 }));
+};
+
+// [function]
+
+const zTrailer = function () {
+  const field = "game.trailer";
+  return z
+    .string()
+    .max(255)
+    .refine(
+      (url) =>
+        zVimeo().safeParse(url).success || zYouTube().safeParse(url).success,
+      message(field, "Must be a YouTube (or Viemo) URL."),
+    )
+    .optional();
+};
+
+// [function]
+
+const zVisibility = function () {
+  // const field = "game.visibility";
+  return z.optional(z.enum(visibility));
+};
+
+// [function]
+
+const zWordmark = function () {
+  // const field = "game.wordmark";
+  return z.optional(zSvg());
+};
+
+// [function]
+
+const zWordmarkAnimated = function () {
+  // const field = "game.wordmark_animated";
+  return z.optional(zSvg());
+};
+
+// [function]
+
+const main = function (root) {
+  /* eslint-disable camelcase */
+  return z.object({
+    audience: zAudience(),
+    banner: zBanner(root),
+    banner_video: zBannerVideo(root),
+    bio: zBio(),
+    cover: zCover(root),
+    cover_video: zCoverVideo(root),
+    description: zDescription(),
+    gallery: zGallery(root),
+    genres: zGenres(),
+    handle: zHandle(),
+    icon: zIcon(root),
+    icon_video: zIconVideo(root),
+    inputs: zInputs(),
+    orientation: zOrientation(),
+    poster: zPoster(root),
+    poster_video: zPosterVideo(root),
+    price: zPrice(),
+    short_title: zShortTitle(),
+    tagline: zTagline(),
+    title: zTitle(),
+    trailer: zTrailer(),
+    visibility: zVisibility(),
+    wordmark: zWordmark(root),
+    wordmark_animated: zWordmarkAnimated(root),
+  });
+  /* eslint-enable camelcase */
+};
+
+// [export]
+
+module.exports = main;

package/src/schema/workflow.js

@@ -0,0 +1,117 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const z = require("zod");
+
+// [use]
+
+const isAbsolute = path.isAbsolute;
+const join = path.join;
+const pathExistsSync = fs.pathExistsSync; // eslint-disable-line no-sync
+const resolve = path.resolve;
+
+// [declare]
+
+const MEDIA = ".arcadible";
+
+// [function]
+
+const reference = function (field) {
+  return chalk.cyan.underline(
+    `https://developer.arcadible.com/references/arcadible-manifest#${field}`,
+  );
+};
+
+// [function]
+
+const indent = function (text, spaces = 2) {
+  const pad = " ".repeat(spaces);
+  return text
+    .split("\n")
+    .map((line) => pad + line)
+    .join("\n");
+};
+
+// [function]
+
+const message = function (field, msg) {
+  return { message: [msg, indent(reference(field))].join("\n") };
+};
+
+// [function]
+
+const isOutPath = function (root, dir) {
+  const resolvedRoot = resolve(root);
+  const resolvedTarget = resolve(root, dir);
+  const outside =
+    resolvedTarget !== resolvedRoot &&
+    !resolvedTarget.startsWith(resolvedRoot + path.sep);
+  return outside;
+};
+
+// [function]
+
+const isMediaPath = function (root, dir) {
+  const resolvedTarget = resolve(root, dir);
+  const containsMedia = resolvedTarget.split(path.sep).includes(MEDIA);
+  return containsMedia;
+};
+
+// [function]
+
+const isRealPath = function (root, dir) {
+  return pathExistsSync(join(root, dir));
+};
+
+// [function]
+
+const zDeployDir = function (root, { skip_build: skipBuild }) {
+  const field = "workflow.deploy_dir";
+  let zz = z
+    .string()
+    .min(1)
+    .refine((dir) => !isAbsolute(dir), message(field, "Must be relative."))
+    .refine(
+      (dir) => !isOutPath(root, dir),
+      message(field, "Must be within the project."),
+    )
+    .refine(
+      (dir) => !isMediaPath(root, dir),
+      message(field, "Must not contain reserved names."),
+    );
+  if (skipBuild) {
+    zz = zz.refine(
+      (dir) => isRealPath(root, dir),
+      message(field, "Must exist."),
+    );
+  }
+  return zz;
+};
+
+// [function]
+
+const zSkipBuild = function () {
+  return z.boolean();
+};
+
+// [function]
+
+const main = function (root, workflow) {
+  /* eslint-disable camelcase */
+  return z.object({
+    deploy_dir: zDeployDir(root, workflow),
+    skip_build: zSkipBuild(),
+  });
+  /* eslint-enable camelcase */
+};
+
+// [export]
+
+module.exports = main;

package/src/util/arc.js

@@ -0,0 +1,74 @@
+"use strict";
+
+// [import]
+
+const execFile = require("node:child_process").execFile;
+
+// [import]
+
+const strs = require("./strs");
+
+// [use]
+
+const trimWhitespace = strs.trimWhitespace;
+
+// [declare]
+
+const RE_TAG_EXISTS = /tag\s+'([^']+)'\s+already\s+exists/iu;
+
+// [function]
+
+const knownErr = function (stdErr) {
+  const tagExists = stdErr.match(RE_TAG_EXISTS);
+  if (tagExists) {
+    return [
+      `Git tag exists: ${tagExists[1]}`,
+      "The package version has been synchronized.",
+      "Try again.",
+    ].join("\n");
+  }
+  return stdErr;
+};
+
+// [function]
+
+const npm = function (root, pre, preId) {
+  return [
+    "--prefix",
+    root,
+    "version",
+    pre ? "prerelease" : "patch",
+    "--preid",
+    preId,
+    "-m",
+    pre ? "Prerelease v%s" : "Release v%s",
+  ];
+};
+
+// [function]
+
+const git = function (root) {
+  return ["-C", root, "push", "--follow-tags"];
+};
+
+// [function]
+
+const deploy = function (root, { pre, preId }, cb) {
+  execFile("npm", npm(root, pre, preId), (err, stdOut, stdErr) => {
+    if (err) {
+      cb(new Error(knownErr(stdErr), { cause: err }));
+      return;
+    }
+    execFile("git", git(root), (err) => {
+      if (err) {
+        cb(new Error(knownErr(stdErr), { cause: err }));
+        return;
+      }
+      cb(null, trimWhitespace(stdOut));
+    });
+  });
+};
+
+// [export]
+
+module.exports = { deploy };

package/src/util/dom.js

@@ -0,0 +1,53 @@
+"use strict";
+
+// [import]
+
+const dompurify = require("dompurify");
+const jsdom = require("jsdom");
+
+// [use]
+
+const DOM = jsdom.JSDOM;
+
+// [declare]
+
+const AFM_ATTR_WHITELIST = ["href", "target", "rel", "src", "alt", "title"];
+const AFM_TAG_WHITELIST = [
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "hr",
+  "p",
+  "ul",
+  "ol",
+  "li",
+  "pre",
+  "img",
+  "a",
+  "code",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "br",
+];
+
+// [function]
+
+const sanitize = function (html) {
+  return dompurify(new DOM().window).sanitize(html);
+};
+
+// [function]
+
+const sanitizeAfm = function (html) {
+  return dompurify(new DOM().window).sanitize(html, {
+    ALLOWED_ATTR: AFM_ATTR_WHITELIST,
+    ALLOWED_TAGS: AFM_TAG_WHITELIST,
+  });
+};
+
+// [export]
+
+module.exports = { DOM, sanitize, sanitizeAfm };