jops-core 1.0.14 → 1.1.0

package/bin/init.js

@@ -1,23 +1,79 @@
 #!/usr/bin/env node
 import fs from "fs";
+import https from "https";
 import path from "path";
 import readline from "readline";
+import { spawnSync } from "child_process";
 import { fileURLToPath } from "url";
 
 const [,, command, ...flags] = process.argv;
 
 if (command !== "init" && command !== "build" && command !== "update") {
   console.log("Usage:");
-  console.log("  npx jops-core init    — vendor library and configure index.html");
-  console.log("  npx jops-core update  — copy the latest jops-core.min.js to lib/");
+  console.log("  npx jops-core init    — vendor library and configure index.html, or create a template project");
+  console.log("  npx jops-core update  — copy the latest jops-core.min.js to lib/ (public/lib/ in a Next.js project)");
   console.log("  npx jops-core build   — generate production-ready dist/ folder");
   console.log("");
   console.log("Options (init, update):");
   console.log("  --cordova | --capacitor | --web   override the detected project type");
+  console.log("Options (all commands):");
+  console.log("  --no-update-check                 skip the check for a newer jops-core version");
   process.exit(0);
 }
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"), "utf8"));
+
+// ─── update check ────────────────────────────────────────────────────────────
+// Started now, awaited at the end, so it runs in parallel with the command.
+// Any failure (offline, timeout, Node without fetch) prints nothing.
+
+const skipUpdateCheck =
+  process.env.CI ||
+  process.env.JOPS_NO_UPDATE_CHECK ||
+  process.env.NO_UPDATE_NOTIFIER ||
+  flags.includes("--no-update-check");
+
+// https.get rather than fetch: destroying the request closes the socket at once,
+// whereas an aborted fetch keeps the process alive until its 10 s connect timeout.
+function fetchLatestVersion() {
+  return new Promise((resolve) => {
+    const req = https.get("https://registry.npmjs.org/jops-core/latest", (res) => {
+      if (res.statusCode !== 200) {
+        clearTimeout(timer);
+        res.resume();
+        return resolve(null);
+      }
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => (body += chunk));
+      res.on("end", () => {
+        clearTimeout(timer);
+        try {
+          resolve(JSON.parse(body).version ?? null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    const timer = setTimeout(() => req.destroy(), 1500);
+    req.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
+}
+
+const latestVersion = skipUpdateCheck ? Promise.resolve(null) : fetchLatestVersion();
+
+function isNewer(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
+  }
+  return false;
+}
 
 // ─── project detection ───────────────────────────────────────────────────────
 // projectRoot: package.json, .vscode/   webRoot: index.html, lib/, src/
@@ -88,6 +144,133 @@ function copyDir(src, dest) {
   }
 }
 
+// A Next.js project: the library is served from public/lib/.
+function isNextProject(dir) {
+  return ["next.config.ts", "next.config.js", "next.config.mjs"].some((f) => fs.existsSync(path.join(dir, f)));
+}
+
+// Copies a template project into dest (README.md included, unlike copyDir()).
+// package.json is merged separately; existing files are never overwritten.
+// npm drops .gitignore files from published packages, so the template stores
+// it as "gitignore".
+function copyTemplateProject(src, dest, root = dest) {
+  const SKIP = new Set(["node_modules", ".next", ".DS_Store", "package.json"]);
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (dest === root && SKIP.has(entry.name)) continue;
+    if (entry.name === ".DS_Store") continue;
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name === "gitignore" ? ".gitignore" : entry.name);
+    if (entry.isDirectory()) copyTemplateProject(srcPath, destPath, root);
+    else if (fs.existsSync(destPath)) console.log(`[jops-core] Kept the existing ${path.relative(root, destPath)}`);
+    else fs.copyFileSync(srcPath, destPath);
+  }
+}
+
+// Creates the template's package.json, or merges its dependencies and scripts
+// into an existing one: existing entries (e.g. an installed jops-core) are kept.
+function mergeTemplatePackageJson(templatePath, targetPath) {
+  const template = JSON.parse(fs.readFileSync(templatePath, "utf8"));
+  if (!fs.existsSync(targetPath)) {
+    fs.writeFileSync(targetPath, JSON.stringify(template, null, 2) + "\n", "utf8");
+    console.log("[jops-core] Created package.json");
+    return;
+  }
+  const pkg = JSON.parse(fs.readFileSync(targetPath, "utf8"));
+  pkg.private ??= true;
+  // `npm init -y` writes "type": "commonjs", which makes Next.js (Turbopack)
+  // reject the project's ES module sources; Next.js projects have no "type".
+  if (pkg.type === "commonjs") {
+    delete pkg.type;
+    console.log('[jops-core] Removed "type": "commonjs" from package.json (Next.js uses ES modules)');
+  }
+  for (const section of ["dependencies", "devDependencies"]) {
+    for (const [name, spec] of Object.entries(template[section] ?? {})) {
+      const existing = pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
+      if (existing) {
+        if (name === "jops-core") console.log(`[jops-core] Kept the installed jops-core (${existing})`);
+        continue;
+      }
+      pkg[section] = { ...pkg[section], [name]: spec };
+    }
+  }
+  for (const [name, command] of Object.entries(template.scripts ?? {})) {
+    const existing = pkg.scripts?.[name];
+    if (existing && existing !== command) {
+      console.log(`[jops-core] Kept the existing "${name}" script (${existing}); the template uses "${command}"`);
+      continue;
+    }
+    pkg.scripts = { ...pkg.scripts, [name]: command };
+  }
+  fs.writeFileSync(targetPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  console.log("[jops-core] Added the Next.js dependencies and scripts to package.json");
+}
+
+// ─── template selection ──────────────────────────────────────────────────────
+// Asked before init writes anything, because the Next.js template creates its
+// own project folder instead of configuring the current one.
+
+async function askTemplate() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => rl.question(
+    "\nCreate JOPS project from existing templates:\n" +
+    "  1. Empty JOPS project (basic skeleton for JOPS project architecture)\n" +
+    "  2. Hello World JOPS project (an example project utilizing all features)\n" +
+    "  3. Next.js JOPS Embedded SPA (a Next.js project hosting a JOPS SPA)\n" +
+    "  4. None (I'll create my own architecture)\n" +
+    "Enter choice (1-4): ",
+    resolve,
+  ));
+  rl.close();
+  return answer.trim();
+}
+
+const choice = command === "init" ? await askTemplate() : null;
+
+// ─── init: Next.js JOPS Embedded SPA (template 3) ────────────────────────────
+
+if (command === "init" && choice === "3") {
+  const cwd = process.cwd();
+  const templateDir = path.join(__dirname, "../templates/nextjs-jops-spa");
+  // Paths that would clash with an existing project: nothing is written then.
+  const conflicts = [
+    "next.config.ts", "next.config.js", "next.config.mjs",
+    "tsconfig.json", "src/app", "public/jops-spa", "data/quotes.json",
+  ].filter((p) => fs.existsSync(path.join(cwd, p)));
+
+  if (isHybrid) {
+    console.error(`[jops-core] This is a ${type} project; create the Next.js project in another folder.`);
+    process.exitCode = 1;
+  } else if (conflicts.length) {
+    console.error(`[jops-core] This folder already has ${conflicts.join(", ")}. Nothing was changed.`);
+    console.error("            Run init in an empty folder (or a fresh npm project) to create the Next.js project.");
+    process.exitCode = 1;
+  } else {
+    copyTemplateProject(templateDir, cwd);
+    mergeTemplatePackageJson(path.join(templateDir, "package.json"), path.join(cwd, "package.json"));
+    console.log("[jops-core] Created the Next.js JOPS Embedded SPA project in this folder.");
+
+    const libDir = path.join(cwd, "public", "lib");
+    fs.mkdirSync(libDir, { recursive: true });
+    fs.copyFileSync(path.join(__dirname, "../lib/jops-core.min.js"), path.join(libDir, "jops-core.min.js"));
+    console.log("[jops-core] Vendored jops-core.min.js → public/lib/jops-core.min.js");
+
+    console.log("[jops-core] Installing dependencies (npm install)…");
+    const install = spawnSync("npm", ["install"], {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32",
+    });
+    if (install.status !== 0) {
+      console.warn("[jops-core] npm install did not complete. Run it yourself: npm install");
+    }
+    console.log("");
+    console.log("[jops-core] Next steps:");
+    console.log("            npm run dev");
+    console.log("            open http://localhost:3000/about and http://localhost:3000/jops-spa");
+  }
+}
+
 // ─── index.html helpers (hybrid projects) ────────────────────────────────────
 
 // Same policy as Cordova's default, plus 'unsafe-inline' for the inline import map
@@ -187,7 +370,7 @@ function schemeWarnings(xml) {
 
 // ─── init ────────────────────────────────────────────────────────────────────
 
-if (command === "init") {
+if (command === "init" && choice !== "3") {
   fs.mkdirSync(webRoot, { recursive: true });
   if (isHybrid) {
     console.log(`[jops-core] ${forced ? "Using" : "Detected"} ${type} project → web folder: ${rel(webRoot)}/`);
@@ -350,22 +533,10 @@ ${cordovaBody}${MODULE_SCRIPT}
     if (changed) fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
   }
 
-  // Template selection
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const ask = (q) => new Promise(resolve => rl.question(q, resolve));
-
-  const choice = await ask(
-    "\nCreate JOPS project from existing templates:\n" +
-    "  1. Empty JOPS project (basic skeleton for JOPS project architecture)\n" +
-    "  2. Hello World JOPS project (an example project utilizing all features)\n" +
-    "  3. None (I'll create my own architecture)\n" +
-    "Enter choice (1-3): "
-  );
-  rl.close();
-
+  // Template choice: asked at the start (see askTemplate()).
   // Cordova's sample page (css/index.css, js/index.js, #deviceready) conflicts with a JOPS
   // template: back it up and start from the JOPS Cordova index.html instead.
-  if (type === "cordova" && ["1", "2"].includes(choice.trim()) &&
+  if (type === "cordova" && ["1", "2"].includes(choice) &&
       fs.readFileSync(indexPath, "utf8").includes('id="deviceready"')) {
     let backup = path.join(webRoot, "index.cordova.html");
     for (let n = 1; fs.existsSync(backup); n++) backup = path.join(webRoot, `index.cordova-${n}.html`);
@@ -375,7 +546,7 @@ ${cordovaBody}${MODULE_SCRIPT}
   }
 
   const templateSrc = path.join(__dirname, "../templates");
-  if (choice.trim() === "1") {
+  if (choice === "1") {
     copyDir(path.join(templateSrc, "empty"), webRoot);
     // Add data-app to the module script in index.html
     let html = fs.readFileSync(indexPath, "utf8");
@@ -385,7 +556,7 @@ ${cordovaBody}${MODULE_SCRIPT}
     );
     fs.writeFileSync(indexPath, html, "utf8");
     console.log("[jops-core] Created empty JOPS project skeleton.");
-  } else if (choice.trim() === "2") {
+  } else if (choice === "2") {
     copyDir(path.join(templateSrc, "hello-world"), webRoot);
     let html = fs.readFileSync(indexPath, "utf8");
     html = html.replace(
@@ -402,7 +573,9 @@ ${cordovaBody}${MODULE_SCRIPT}
 // ─── update ──────────────────────────────────────────────────────────────────
 
 if (command === "update") {
-  const libDir = path.join(webRoot, "lib");
+  // A Next.js project serves the library from public/lib/.
+  const libRoot = type === "web" && isNextProject(projectRoot) ? path.join(projectRoot, "public") : webRoot;
+  const libDir = path.join(libRoot, "lib");
   const vendorDest = path.join(libDir, "jops-core.min.js");
   const vendorSrc = path.join(__dirname, "../lib/jops-core.min.js");
 
@@ -413,7 +586,6 @@ if (command === "update") {
 
   fs.copyFileSync(vendorSrc, vendorDest);
 
-  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"), "utf8"));
   console.log(`[jops-core] Updated ${rel(vendorDest)} to v${pkg.version}`);
 }
 
@@ -446,8 +618,29 @@ if (command === "build") {
     }
   }
 
+  const vendored = path.join(webRoot, "lib", "jops-core.min.js");
+  const installed = path.join(__dirname, "../lib/jops-core.min.js");
+  if (fs.existsSync(vendored) && !fs.readFileSync(vendored).equals(fs.readFileSync(installed))) {
+    console.warn(`[jops-core] ${rel(vendored)} differs from the installed v${pkg.version} — run \`npx jops-core update\` before building.`);
+  }
+
   const distDir = path.join(webRoot, "dist");
   if (fs.existsSync(distDir)) fs.rmSync(distDir, { recursive: true, force: true });
   buildCopyDir(webRoot, distDir);
   console.log("[jops-core] Built → dist/");
 }
+
+// ─── update notice ───────────────────────────────────────────────────────────
+
+const latest = await latestVersion;
+if (latest && isNewer(latest, pkg.version)) {
+  console.log("");
+  if (command === "update") {
+    console.log(`[jops-core] Copied v${pkg.version} from node_modules, but v${latest} is available.`);
+    console.log("            Run `npm i jops-core@latest` first, then `npx jops-core update` again.");
+  } else {
+    console.log(`[jops-core] Update available: ${pkg.version} → ${latest}`);
+    console.log("            npm i jops-core@latest && npx jops-core update");
+  }
+  console.log("            What's new: https://github.com/uidb-dev/jops-core/blob/main/CHANGELOG.md");
+}