arcadible 0.0.1 → 0.1.1

package/src/parser/media.js

@@ -0,0 +1,96 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const fs = require("fs-extra");
+
+// [import]
+
+const objs = require("../util/objs");
+
+// [use]
+
+const extname = path.extname;
+const join = path.join;
+const pathExists = fs.pathExists;
+const pathParse = path.parse;
+const pruneEmpty = objs.pruneEmpty;
+const readdir = fs.promises.readdir;
+
+// [declare]
+
+const ART = [
+  "banner.png",
+  "banner_video.mp4",
+  "cover.png",
+  "cover_video.mp4",
+  "icon.png",
+  "icon_video.mp4",
+  "poster.png",
+  "poster_video.mp4",
+  "wordmark.svg",
+  "wordmark_animated.svg",
+];
+
+// [declare]
+
+const MEDIA = ".arcadible";
+
+// [function]
+
+const handleArt = function (exists) {
+  return Object.fromEntries(
+    ART.map((f, i) => [pathParse(f).name, exists[i] ? join(MEDIA, f) : null]),
+  );
+};
+
+// [function]
+
+const art = function (root) {
+  return (game) =>
+    Promise.all(ART.map((value) => pathExists(join(root, MEDIA, value))))
+      .then(handleArt)
+      .then((data) => ({ ...game, ...data }));
+};
+
+// [function]
+
+const handleGallery = function (entries) {
+  return entries
+    .filter((f) => extname(f).toLowerCase() === ".png")
+    .map((f) => join(MEDIA, "gallery", f))
+    .sort();
+};
+
+// [function]
+
+const gallery = function (root) {
+  const dir = join(root, MEDIA, "gallery");
+  return (game) =>
+    pathExists(dir)
+      .then((exists) => (exists ? readdir(dir) : []))
+      .then(handleGallery)
+      .then((data) => ({ ...game, gallery: data }));
+};
+
+// [function]
+
+const parse = function (root) {
+  return new Promise((resolve, reject) => {
+    Promise.resolve({})
+      .then(art(root))
+      .then(gallery(root))
+      .then(pruneEmpty)
+      .then((game) => ({ game }))
+      .then(resolve)
+      .catch(reject);
+  });
+};
+
+// [export]
+
+module.exports = { parse };

package/src/parser/project.js

@@ -0,0 +1,55 @@
+"use strict";
+
+// [import]
+
+const cfggame = require("../config/game");
+const cfgworkflow = require("../config/workflow");
+const manifest = require("./manifest");
+const media = require("./media");
+const promise = require("../util/promise");
+const readme = require("./readme");
+
+// [function]
+
+const configGame = function (readmeGame, mediaGame, manifestGame) {
+  return {
+    ...cfggame,
+    ...(readmeGame || {}),
+    ...(mediaGame || {}),
+    ...(manifestGame || {}),
+  };
+};
+
+// [function]
+
+const configWorkflow = function (manifestWorkflow) {
+  return {
+    ...cfgworkflow,
+    ...(manifestWorkflow || {}),
+  };
+};
+
+// [function]
+
+const parse = function (root) {
+  const parsers = [
+    () => manifest.parse(root),
+    () => media.parse(root),
+    () => readme.parse(root),
+  ];
+  return promise
+    .serial(parsers)
+    .then(([manifestData, mediaData, readmeData]) => {
+      const game = configGame(
+        readmeData.game,
+        mediaData.game,
+        manifestData.game,
+      );
+      const workflow = configWorkflow(manifestData.workflow);
+      return { game, workflow };
+    });
+};
+
+// [export]
+
+module.exports = { parse };

package/src/parser/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/prompt/project.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// [export]
+
+module.exports = {
+  input: {
+    default: ".",
+    message: "Project",
+  },
+};

package/src/prompt/template.js

@@ -0,0 +1,37 @@
+"use strict";
+
+// [export]
+
+module.exports = {
+  select: {
+    choices: [
+      {
+        description: "Blank starter template.",
+        name: "Blank",
+        value: "arcadible/starter",
+      },
+      {
+        description: "Three.js starter template.",
+        name: "Three.js",
+        value: "arcadible/starter-threejs",
+      },
+      {
+        description: "Phaser starter template.",
+        name: "Phaser",
+        value: "arcadible/starter-phaser",
+      },
+      {
+        description: "PixiJS starter template.",
+        name: "PixiJS",
+        value: "arcadible/starter-pixijs",
+      },
+      {
+        description: "Babylon.js starter template.",
+        name: "Babylon.js",
+        value: "arcadible/starter-babylonjs",
+      },
+    ],
+    default: "arcadible/starter",
+    message: "Template",
+  },
+};

package/src/schema/game.js

@@ -0,0 +1,324 @@
+"use strict";
+
+// [import]
+
+const chalk = require("chalk");
+const z = require("zod");
+
+// [import]
+
+const cfgaudience = require("../config/audience");
+const cfggenre = require("../config/genre");
+const cfghtml = require("../config/html");
+const cfginput = require("../config/input");
+const cfgorientation = require("../config/orientation");
+const cfgurl = require("../config/url");
+const cfgvisibility = require("../config/visibility");
+const dom = require("../util/dom");
+
+// [function]
+
+const reference = function (field) {
+  return chalk.cyan.underline(`${cfgurl.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(cfgaudience));
+};
+
+// [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(
+        (str) =>
+          str ===
+          dom.sanitize(str, {
+            ALLOWED_ATTR: cfghtml.ALLOWED_ATTR,
+            ALLOWED_TAGS: cfghtml.ALLOWED_TAGS,
+          }),
+        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(cfggenre)).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(cfginput)).max(3));
+};
+
+// [function]
+
+const zOrientation = function () {
+  // const field = "game.orientation";
+  return z.optional(z.enum(cfgorientation));
+};
+
+// [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(cfgvisibility));
+};
+
+// [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 (value, { 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;