html2apk 0.1.0

package/src/utils/command-runner.js

@@ -0,0 +1,124 @@
+"use strict";
+
+const { spawn } = require("child_process");
+const path = require("path");
+
+function pathDelimiter() {
+  return process.platform === "win32" ? ";" : ":";
+}
+
+function packageBinPath() {
+  return path.resolve(__dirname, "..", "..", "node_modules", ".bin");
+}
+
+function withLocalBin(env) {
+  const nextEnv = { ...env };
+  const key = Object.prototype.hasOwnProperty.call(nextEnv, "Path") ? "Path" : "PATH";
+  const current = nextEnv[key] || "";
+  const localBin = packageBinPath();
+  const parts = current.split(pathDelimiter()).filter(Boolean);
+
+  if (!parts.includes(localBin)) {
+    nextEnv[key] = [localBin, ...parts].join(pathDelimiter());
+  }
+
+  return nextEnv;
+}
+
+function quoteForCmd(value) {
+  const text = String(value);
+  if (text.length === 0) {
+    return "\"\"";
+  }
+
+  if (/^[a-zA-Z0-9_@./:\\=+\-]+$/.test(text)) {
+    return text;
+  }
+
+  return `"${text.replace(/(["^&|<>])/g, "^$1")}"`;
+}
+
+function createSpawnSpec(command, args) {
+  const needsCmdShim = process.platform === "win32" && new Set(["cordova", "gradle"]).has(command);
+  if (!needsCmdShim) {
+    return { command, args };
+  }
+
+  return {
+    command: "cmd.exe",
+    args: ["/d", "/s", "/c", [command, ...args.map(quoteForCmd)].join(" ")]
+  };
+}
+
+function createCommandRunner({ logs = [], env = process.env, onLog } = {}) {
+  const baseEnv = withLocalBin(env);
+
+  function log(line) {
+    logs.push(line);
+    if (typeof onLog === "function") {
+      onLog(line);
+    }
+  }
+
+  async function run(command, args = [], options = {}) {
+    const pretty = `${command} ${args.join(" ")}`.trim();
+    log(`$ ${pretty}`);
+    const spawnSpec = createSpawnSpec(command, args);
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(spawnSpec.command, spawnSpec.args, {
+        cwd: options.cwd,
+        env: { ...baseEnv, ...(options.env || {}) },
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false
+      });
+
+      let stdout = "";
+      let stderr = "";
+
+      child.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        stdout += text;
+        if (options.pipeOutput) {
+          process.stdout.write(text);
+        }
+      });
+
+      child.stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderr += text;
+        if (options.pipeOutput) {
+          process.stderr.write(text);
+        }
+      });
+
+      child.on("error", (error) => {
+        reject(new Error(`Failed to run "${pretty}": ${error.message}`));
+      });
+
+      child.on("close", (code) => {
+        const summary = [stdout, stderr].join("\n").trim();
+        if (summary) {
+          log(summary.slice(-4000));
+        }
+
+        if (code === 0) {
+          resolve({ code, stdout, stderr });
+          return;
+        }
+
+        const error = new Error(`Command failed (${code}): ${pretty}`);
+        error.code = code;
+        error.stdout = stdout;
+        error.stderr = stderr;
+        reject(error);
+      });
+    });
+  }
+
+  return { run, logs };
+}
+
+module.exports = {
+  createCommandRunner
+};

package/src/utils/fs-extra.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const fs = require("fs/promises");
+const path = require("path");
+
+const DEFAULT_IGNORES = new Set([
+  ".git",
+  ".svn",
+  ".hg",
+  "node_modules",
+  "platforms",
+  "plugins",
+  "hooks",
+  "dist",
+  "build",
+  ".gradle",
+  "app.json",
+  "config.json"
+]);
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function removePath(targetPath) {
+  await fs.rm(targetPath, { recursive: true, force: true });
+}
+
+async function copyFile(source, destination) {
+  await ensureDir(path.dirname(destination));
+  await fs.copyFile(source, destination);
+}
+
+async function copyDirectory(source, destination, shouldIgnore) {
+  await ensureDir(destination);
+  const entries = await fs.readdir(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name);
+    const destinationPath = path.join(destination, entry.name);
+    if (shouldIgnore(sourcePath, entry)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, destinationPath, shouldIgnore);
+    } else if (entry.isFile()) {
+      await copyFile(sourcePath, destinationPath);
+    }
+  }
+}
+
+function normalizeFileMapping(item) {
+  if (typeof item === "string") {
+    return { from: item, to: item };
+  }
+
+  if (item && typeof item === "object" && item.from) {
+    return {
+      from: item.from,
+      to: item.to || item.from
+    };
+  }
+
+  throw new Error(`Invalid files entry: ${JSON.stringify(item)}`);
+}
+
+function isInside(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function copyWebAssets(webRoot, destination, options, projectRoot) {
+  await removePath(destination);
+  await ensureDir(destination);
+
+  if (Array.isArray(options.files) && options.files.length > 0) {
+    for (const item of options.files) {
+      const mapping = normalizeFileMapping(item);
+      const source = path.resolve(webRoot, mapping.from);
+      if (!isInside(projectRoot, source)) {
+        throw new Error(`File mapping leaves project root: ${mapping.from}`);
+      }
+
+      const target = path.resolve(destination, mapping.to);
+      if (!isInside(destination, target)) {
+        throw new Error(`File mapping leaves Cordova www folder: ${mapping.to}`);
+      }
+
+      const stat = await fs.stat(source);
+      if (stat.isDirectory()) {
+        await copyDirectory(source, target, () => false);
+      } else {
+        await copyFile(source, target);
+      }
+    }
+    return;
+  }
+
+  await copyDirectory(webRoot, destination, (_sourcePath, entry) => {
+    return DEFAULT_IGNORES.has(entry.name);
+  });
+}
+
+module.exports = {
+  ensureDir,
+  removePath,
+  copyFile,
+  copyDirectory,
+  copyWebAssets
+};