dh-remixer-sdk 0.0.31-cfbcd84 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dh-remixer-sdk",
-  "version": "0.0.31-cfbcd84",
+  "version": "0.0.31",
   "type": "module",
   "files": [
     "templates",

package/scripts/sdk-rewrite/index.mjs

@@ -1,35 +1,150 @@
 #!/usr/bin/env node
 import fs from "node:fs/promises";
+import fssync from "node:fs";
 import path from "node:path";
-import {
-  extractFile,
-  extractJsonFile,
-  getTargetPackageJson,
-} from "../sdk-update/fs-utils.mjs";
-import {
-  getDeletionList,
-  getExtractionList,
-} from "../sdk-update/sdk-utils.mjs";
-import { PROJECT_ROOT, SDK_ROOT } from "../sdk-update/vars.mjs";
+import { fileURLToPath } from "node:url";
+
+// SDK_ROOT is the dh-remixer-sdk package that provides the canonical template
+// files and the version to pin. It defaults to this package's own root, but can
+// be pointed at a different dh-remixer-sdk
+const SDK_ROOT = process.env.REMIXER_SDK_ROOT
+  ? path.resolve(process.env.REMIXER_SDK_ROOT)
+  : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const PROJECT_ROOT = path.resolve(process.env.INIT_CWD ?? process.cwd());
+const BASE_ROOT = path.join(SDK_ROOT, "templates", "base");
+
+function isObj(x) {
+  return x != null && typeof x === "object" && !Array.isArray(x);
+}
+
+function jsonMerge(low, high) {
+  if (Array.isArray(low) && Array.isArray(high)) {
+    return [...low, ...high];
+  }
+
+  if (!isObj(low) || !isObj(high)) {
+    return high === undefined ? low : high;
+  }
+
+  return Object.fromEntries(
+    Object.keys({ ...low, ...high }).map((key) => {
+      const lv = low[key];
+      const hv = high[key];
+
+      if (hv === undefined) return [key, lv];
+      if (Array.isArray(lv) && Array.isArray(hv)) return [key, [...lv, ...hv]];
+      if (Array.isArray(lv) || Array.isArray(hv)) return [key, hv];
+      if (isObj(lv) && isObj(hv)) return [key, jsonMerge(lv, hv)];
+      return [key, hv];
+    }),
+  );
+}
+
+function assertTemplateExists(templateType) {
+  if (templateType === "base") return;
+  const templateRoot = path.join(SDK_ROOT, "templates", templateType);
+  if (!fssync.existsSync(templateRoot)) {
+    throw new Error(
+      `Template "${templateType}" not found in dh-remixer-sdk (${templateRoot}).`,
+    );
+  }
+}
+
+// Merges a base + template-specific JSON list/map (cleanup.json / filemap.json).
+async function getMergedTemplateJson(templateType, fileName) {
+  assertTemplateExists(templateType);
+  const basePath = path.join(BASE_ROOT, fileName);
+  const templatePath = path.join(SDK_ROOT, "templates", templateType, fileName);
+  let merged = JSON.parse(await fs.readFile(basePath, "utf8"));
+  if (templateType !== "base" && fssync.existsSync(templatePath)) {
+    merged = jsonMerge(merged, JSON.parse(await fs.readFile(templatePath, "utf8")));
+  }
+  return merged;
+}
+
+function getDeletionList(templateType) {
+  return getMergedTemplateJson(templateType, "cleanup.json");
+}
+
+function getExtractionList(templateType) {
+  return getMergedTemplateJson(templateType, "filemap.json");
+}
+
+async function extractFile(fileName, target, templateType) {
+  const targetPath = path.join(PROJECT_ROOT, target);
+  const templateRoot = path.join(SDK_ROOT, "templates", templateType);
+  const baseFileName = path.join(BASE_ROOT, fileName);
+  const tmplFileName = path.join(templateRoot, fileName);
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+
+  if (fssync.existsSync(tmplFileName)) {
+    await fs.copyFile(tmplFileName, targetPath);
+    return;
+  }
+
+  if (fssync.existsSync(baseFileName)) {
+    await fs.copyFile(baseFileName, targetPath);
+  }
+}
+
+async function extractJsonFile(fileName, target, templateType) {
+  const targetPath = path.join(PROJECT_ROOT, target);
+  const templateRoot = path.join(SDK_ROOT, "templates", templateType);
+  const baseFileName = path.join(BASE_ROOT, fileName);
+  const tmplFileName = path.join(templateRoot, fileName);
+  const baseExists = fssync.existsSync(baseFileName);
+  const templateExists = fssync.existsSync(tmplFileName);
+
+  if (!baseExists && !templateExists) {
+    return;
+  }
+
+  let jsonContents = {};
+
+  if (baseExists) {
+    jsonContents = jsonMerge(
+      jsonContents,
+      JSON.parse(await fs.readFile(baseFileName, "utf8")),
+    );
+  }
+
+  if (templateExists) {
+    jsonContents = jsonMerge(
+      jsonContents,
+      JSON.parse(await fs.readFile(tmplFileName, "utf8")),
+    );
+  }
+
+  const stringContents = JSON.stringify(jsonContents, null, 2) + "\n";
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+  await fs.writeFile(targetPath, stringContents, "utf8");
+}
 
 async function main() {
-  const projectRoot = path.resolve(process.env.INIT_CWD ?? process.cwd());
-  const projPkgPath = path.join(projectRoot, "package.json");
-  const targetPackageJson = await getTargetPackageJson();
+  const projPkgPath = path.join(PROJECT_ROOT, "package.json");
 
-  if (!targetPackageJson) {
+  let targetPackageJson;
+  try {
+    targetPackageJson = JSON.parse(await fs.readFile(projPkgPath, "utf8"));
+  } catch {
+    console.error(`[sdk-rewrite] Cannot read package.json at ${projPkgPath}`);
+    process.exit(1);
+  }
+
+  const templateType = targetPackageJson.remixerMetadata?.template;
+
+  if (!templateType) {
     console.error(
-      `Cannot find package.json\nContents: ${JSON.stringify(targetPackageJson)}`,
+      "[sdk-rewrite] Missing remixerMetadata.template in package.json. " +
+        "Cannot determine which template to apply; aborting rewrite.",
     );
-    return;
+    process.exit(1);
   }
 
   const sdkPkgPath = path.join(SDK_ROOT, "package.json");
   const sdkPkg = JSON.parse(await fs.readFile(sdkPkgPath, "utf8"));
   const currentVersion = sdkPkg.version;
 
-  const templateType = targetPackageJson.remixerMetadata?.template;
-
   const deletionList = await getDeletionList(templateType);
   const extractionList = await getExtractionList(templateType);
 
@@ -45,17 +160,18 @@ async function main() {
     ),
   );
 
-  // Extract new files
-  await Promise.all([
-    ...Object.entries(extractionList).map(([fileName, target]) => {
+  // Extract canonical files from the SDK templates
+  await Promise.all(
+    Object.entries(extractionList).map(([fileName, target]) => {
       console.log(`Extracting ${fileName}`);
       if (fileName.endsWith(".json")) {
         return extractJsonFile(fileName, target, templateType);
       }
       return extractFile(fileName, target, templateType);
     }),
-  ]);
+  );
 
+  // Re-pin dh-remixer-sdk to the SDK_ROOT version (the templates' source version)
   const projPkg = JSON.parse(await fs.readFile(projPkgPath, "utf8"));
   const newPkg = JSON.stringify(
     {
@@ -72,4 +188,7 @@ async function main() {
   await fs.writeFile(projPkgPath, newPkg);
 }
 
-main();
+main().catch((e) => {
+  console.error(`[sdk-rewrite] ${e?.message ?? e}`);
+  process.exit(1);
+});

package/templates/base/vite.config.ts

@@ -47,13 +47,12 @@ function injectRemixerBadgePlugin(): Plugin {
 
     transformIndexHtml(html) {
       try {
-        const IS_SHOW_REMIXER_BADGE = process.env.IS_SHOW_REMIXER_BADGE === 'true';
         const REMIXER_BADGE_TYPE: string = process.env.REMIXER_BADGE_TYPE || 'DEFAULT';
 
         const domain = process.env.NEXT_PUBLIC_DOMAIN || '';
         const isPreviewService = PREVIEW_DOMAINS.some(pd => domain.endsWith(pd));
 
-        if (!IS_SHOW_REMIXER_BADGE && !isPreviewService) return html
+        if (!isPreviewService) return html
 
         const DICTIONARY: Record<string, string> = {
           UPGRADE_PLAN: 'https://unpkg.com/dh-remixer-badge@latest/dist/upgradeBadge.js',