npm - dh-remixer-sdk - Versions diffs - 0.0.17 → 0.0.18-aaf644b - Mend

dh-remixer-sdk 0.0.17 → 0.0.18-aaf644b

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/package.json +5 -2
package/scripts/{postinstall.mjs → postinstall/index.mjs} +14 -4
package/scripts/ssg-helmet/build-helmet-html.mjs +325 -0
package/scripts/ssg-helmet/build-sitemap-xml.mjs +75 -0
package/scripts/ssg-helmet/extract-routes.mjs +82 -0
package/scripts/ssg-helmet/fs-utils.mjs +26 -0
package/scripts/ssg-helmet/get-routes.mjs +52 -0
package/scripts/ssg-helmet/has-router.mjs +110 -0
package/scripts/ssg-helmet/index.mjs +74 -0
package/scripts/ssg-helmet/inject-unpack-redirect.mjs +60 -0
package/scripts/ssg-helmet/populate-sitemap.mjs +208 -0
package/scripts/ssg-helmet/prerenderer.mjs +186 -0
package/templates/base/package.json +8 -2
package/templates/ecommerce/cleanup.json +2 -1
package/templates/ecommerce/filemap.json +2 -1
package/templates/ecommerce/shipping.ts +116 -0
package/templates/ecommerce/stripe-checkout.ts +24 -1

package/package.json CHANGED Viewed

@@ -1,13 +1,16 @@
 {
   "name": "dh-remixer-sdk",
-  "version": "0.0.17",
+  "version": "0.0.18-aaf644b",
   "type": "module",
   "files": [
     "templates",
     "scripts",
     "bin"
   ],
+  "bin": {
+    "ssg-helmet": "./ssg-helmet/index.mjs"
+  },
   "scripts": {
-    "postinstall": "node scripts/postinstall.mjs"
+    "postinstall": "node scripts/postinstall/index.mjs"
   }
 }

package/scripts/{postinstall.mjs → postinstall/index.mjs} RENAMED Viewed

@@ -95,15 +95,26 @@ async function main() {
   const projectRoot = path.resolve(process.env.INIT_CWD ?? process.cwd());
   const projPkgPath = path.join(projectRoot, "package.json");
   const projPkg = JSON.parse(await fs.readFile(projPkgPath, "utf8"));
-  const templateType = projPkg?.remixerMetadata?.template;
+  if (!projPkg) {
+    console.error(
+      `Cannot find package.json at ${projPkgPath}\nContents: ${JSON.stringify(projPkg)}`,
+    );
+    return;
+  }
+  const templateType = projPkg.remixerMetadata?.template;
   if (!templateType) {
-    console.warn("Missing remixerMetadata.template in package.json");
+    console.error(
+      `Missing remixerMetadata.template in package.json\nContents: ${JSON.stringify(projPkg)}`,
+    );
     return;
   }
   const sdkRoot = path.resolve(
     path.dirname(fileURLToPath(import.meta.url)),
-    "..",
+    "../..",
   );
   const sdkPkgPath = path.join(sdkRoot, "package.json");
   const sdkVersion = JSON.parse(await fs.readFile(sdkPkgPath, "utf8")).version;
@@ -158,4 +169,3 @@ async function main() {
 }
 await main();

package/scripts/ssg-helmet/build-helmet-html.mjs ADDED Viewed

@@ -0,0 +1,325 @@
+/**
+ * Simplified redirect-helmet builder:
+ * - Extracts metadata from prerenderedHtml (<title>, <meta>, <link>, <base>, ld+json)
+ * - Normalizes into a single "meta bag" with common SEO keys
+ * - Fills missing fields from available data (og/title/twitter propagation, canonical, og:url, etc.)
+ * - Preserves existing application/ld+json scripts; if none exist AND indexable, emits fallback WebPage JSON-LD
+ * - Forces robots to "noindex, follow" when isIndexable=false
+ * - Ensures <html lang="en">
+ * - Canonical is DOMAIN + route (3rd param), not window.location
+ * - Avoids double-escaping (&amp;amp;) by decoding extracted text before output
+ * - Ensures JSON-LD contains real characters (e.g. "&" not "&amp;")
+ */
+const DOMAIN = "example.com";
+export function buildRedirectHelmetHtml(
+  prerenderedHtml,
+  route = "/",
+  isIndexable = true,
+) {
+  if (typeof prerenderedHtml !== "string") {
+    throw new TypeError("prerenderedHtml must be a string");
+  }
+  // --- helpers --------------------------------------------------------------
+  const pick = (re, s) => s.match(re)?.[1] ?? "";
+  const escapeAttr = (s) =>
+    String(s)
+      .replace(/&/g, "&amp;")
+      .replace(/"/g, "&quot;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;");
+  // Decode a few common HTML entities so we don't double-escape values
+  // (We only use this on text we extracted from existing HTML.)
+  const decodeHtml = (s) =>
+    String(s ?? "")
+      .replace(/&amp;/gi, "&")
+      .replace(/&quot;/gi, '"')
+      .replace(/&#39;/gi, "'")
+      .replace(/&lt;/gi, "<")
+      .replace(/&gt;/gi, ">");
+  // Prevent JSON containing "</script>" from breaking the script tag
+  const safeJson = (obj) =>
+    JSON.stringify(obj).replace(/<\/script>/gi, "<\\/script>");
+  const parseAttrs = (tag) => {
+    const attrs = {};
+    const re = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s/>]+)))?/g;
+    let m;
+    while ((m = re.exec(tag))) {
+      const k = m[1].toLowerCase();
+      const v = m[2] ?? m[3] ?? m[4] ?? "";
+      attrs[k] = v;
+    }
+    return attrs;
+  };
+  const setFirst = (obj, k, v) => {
+    if (v == null) return;
+    const s = String(v).trim();
+    if (!s) return;
+    if (!obj[k]) obj[k] = s;
+  };
+  const setForce = (obj, k, v) => {
+    const s = String(v ?? "").trim();
+    if (!s) return;
+    obj[k] = s;
+  };
+  const normalizeDomain = (d) => {
+    const s = String(d || "").trim();
+    if (!s) return "";
+    if (/^https?:\/\//i.test(s)) return s.replace(/\/+$/, "");
+    return `https://${s.replace(/\/+$/, "")}`;
+  };
+  const normalizeRoute = (r) => {
+    let p = String(r || "/").trim();
+    if (!p) p = "/";
+    if (!p.startsWith("/")) p = "/" + p;
+    // strip query/hash, normalize trailing slash
+    p = p.split("?")[0].split("#")[0];
+    p = p.replace(/\/+$/, "") || "/";
+    return p;
+  };
+  const canonicalFromDomainRoute = () => normalizeDomain(DOMAIN) + normalizeRoute(route);
+  // --- extract head ---------------------------------------------------------
+  const lang = "en";
+  const headInner = pick(/<head\b[^>]*>([\s\S]*?)<\/head>/i, prerenderedHtml);
+  // decode to avoid double-escape on output
+  const titleText = decodeHtml(
+    pick(/<title\b[^>]*>([\s\S]*?)<\/title>/i, headInner).trim(),
+  );
+  const metaTags = headInner.match(/<meta\b[^>]*>/gi) || [];
+  const linkTags = headInner.match(/<link\b[^>]*>/gi) || [];
+  const baseTags = headInner.match(/<base\b[^>]*>/gi) || [];
+  const ldJsonScripts =
+    headInner.match(
+      /<script\b[^>]*type\s*=\s*(['"])application\/ld\+json\1[^>]*>[\s\S]*?<\/script>/gi,
+    ) || [];
+  // --- build meta bag -------------------------------------------------------
+  const meta = {
+    title: "",
+    description: "",
+    robots: "",
+    canonical: "",
+    charset: "",
+    viewport: "",
+    themeColor: "",
+    "og:title": "",
+    "og:description": "",
+    "og:image": "",
+    "og:image:alt": "",
+    "og:type": "",
+    "og:url": "",
+    "og:site_name": "",
+    "og:locale": "",
+    "twitter:card": "",
+    "twitter:title": "",
+    "twitter:description": "",
+    "twitter:image": "",
+    "twitter:image:alt": "",
+    "twitter:site": "",
+    "twitter:creator": "",
+    "application-name": "",
+    "apple-mobile-web-app-title": "",
+    "apple-mobile-web-app-capable": "",
+    "apple-mobile-web-app-status-bar-style": "",
+    "format-detection": "",
+  };
+  setFirst(meta, "title", titleText);
+  // metas
+  for (const t of metaTags) {
+    const a = parseAttrs(t);
+    if (a.charset) setFirst(meta, "charset", decodeHtml(a.charset));
+    const name = (a.name || "").toLowerCase();
+    const prop = (a.property || "").toLowerCase();
+    const httpEquiv = (a["http-equiv"] || "").toLowerCase();
+    const content = decodeHtml(a.content ?? "");
+    if (name === "description") setFirst(meta, "description", content);
+    else if (name === "robots") setFirst(meta, "robots", content);
+    else if (name === "viewport") setFirst(meta, "viewport", content);
+    else if (name === "theme-color") setFirst(meta, "themeColor", content);
+    else if (name && name in meta) setFirst(meta, name, content);
+    if (prop && prop in meta) setFirst(meta, prop, content);
+    if (httpEquiv === "content-language") setFirst(meta, "og:locale", content);
+  }
+  // canonical from <link rel="canonical"...> if present in source
+  for (const t of linkTags) {
+    const a = parseAttrs(t);
+    const rel = (a.rel || "").toLowerCase();
+    if (rel === "canonical" && a.href) setFirst(meta, "canonical", decodeHtml(a.href));
+  }
+  // --- fill fallbacks -------------------------------------------------------
+  setFirst(meta, "og:title", meta.title);
+  setFirst(meta, "og:description", meta.description);
+  // If canonical is set (or will be), use it for og:url
+  // (We'll set canonical later if missing.)
+  setFirst(meta, "twitter:title", meta["og:title"] || meta.title);
+  setFirst(meta, "twitter:description", meta["og:description"] || meta.description);
+  // image propagation
+  setFirst(meta, "twitter:image", meta["og:image"]);
+  setFirst(meta, "twitter:image:alt", meta["og:image:alt"]);
+  setFirst(meta, "og:image:alt", meta["twitter:image:alt"]);
+  // twitter card default
+  setFirst(
+    meta,
+    "twitter:card",
+    meta["twitter:image"] ? "summary_large_image" : "summary",
+  );
+  // --- canonical: always DOMAIN + route unless source provided one ----------
+  if (!meta.canonical) {
+    meta.canonical = canonicalFromDomainRoute();
+  }
+  // --- og:url: set to canonical if missing ---------------------------------
+  if (!meta["og:url"]) {
+    meta["og:url"] = meta.canonical;
+  }
+  // --- enforce indexability -------------------------------------------------
+  if (!isIndexable) {
+    setForce(meta, "robots", "noindex, follow");
+  }
+  // --- emit tags ------------------------------------------------------------
+  const out = [];
+  out.push(`<meta charset="${escapeAttr(meta.charset || "utf-8")}" />`);
+  if (meta.viewport)
+    out.push(`<meta name="viewport" content="${escapeAttr(meta.viewport)}" />`);
+  if (meta.robots)
+    out.push(`<meta name="robots" content="${escapeAttr(meta.robots)}" />`);
+  if (meta.description)
+    out.push(`<meta name="description" content="${escapeAttr(meta.description)}" />`);
+  if (meta.themeColor)
+    out.push(`<meta name="theme-color" content="${escapeAttr(meta.themeColor)}" />`);
+  if (meta["application-name"])
+    out.push(
+      `<meta name="application-name" content="${escapeAttr(meta["application-name"])}" />`,
+    );
+  if (meta.title) out.push(`<title>${escapeAttr(meta.title)}</title>`);
+  if (meta.canonical)
+    out.push(`<link rel="canonical" href="${escapeAttr(meta.canonical)}" />`);
+  for (const k of [
+    "og:title",
+    "og:description",
+    "og:image",
+    "og:image:alt",
+    "og:type",
+    "og:url",
+    "og:site_name",
+    "og:locale",
+  ]) {
+    if (meta[k]) out.push(`<meta property="${k}" content="${escapeAttr(meta[k])}" />`);
+  }
+  for (const k of [
+    "twitter:card",
+    "twitter:title",
+    "twitter:description",
+    "twitter:image",
+    "twitter:image:alt",
+    "twitter:site",
+    "twitter:creator",
+  ]) {
+    if (meta[k]) out.push(`<meta name="${k}" content="${escapeAttr(meta[k])}" />`);
+  }
+  // keep original link/base tags too (favicons, preconnect, etc.)
+  // NOTE: These tags may include &amp; already; but they're raw tags and should be kept as-is.
+  out.push(...linkTags);
+  out.push(...baseTags);
+  // --- JSON-LD: preserve existing; else generate fallback -------------------
+  if (ldJsonScripts.length) {
+    out.push(...ldJsonScripts);
+  } else if (isIndexable) {
+    // IMPORTANT: JSON-LD strings must NOT contain HTML entities.
+    const fallbackLdJson = {
+      "@context": "https://schema.org",
+      "@type": "WebPage",
+      name: meta.title || undefined,
+      description: meta.description || undefined,
+      url: meta.canonical || undefined,
+      inLanguage: "en",
+    };
+    for (const k of Object.keys(fallbackLdJson)) {
+      if (fallbackLdJson[k] === undefined) delete fallbackLdJson[k];
+    }
+    out.push(
+      `<script type="application/ld+json">${safeJson(fallbackLdJson)}</script>`,
+    );
+  }
+  // --- redirect script ------------------------------------------------------
+  out.push(
+    `<script type="text/javascript">
+(function () {
+  var botPattern =
+    "(googlebot\\\\/|bot|bingbot|slurp|DuckDuckBot|baiduspider|yandexbot|facebookexternalhit|twitterbot|linkedinbot|pinterest|slackbot|discordbot|whatsapp|telegrambot|embedly|quora link preview|applebot|semrushbot|ahrefsbot|mj12bot|dotbot)";
+  var re = new RegExp(botPattern, "i");
+  var ua = navigator.userAgent;
+  if (!re.test(ua)) {
+    var l = window.location;
+    l.replace(
+      l.protocol +
+        "//" +
+        l.hostname +
+        (l.port ? ":" + l.port : "") +
+        "/?p=/" +
+        l.pathname.slice(1).replace(/&/g, "~and~") +
+        (l.search ? "&q=" + l.search.slice(1).replace(/&/g, "~and~") : "") +
+        l.hash
+    );
+  }
+})();
+</script>`,
+  );
+  return `<!doctype html>
+<html lang="${escapeAttr(lang)}">
+<head>
+${out.filter(Boolean).join("\n")}
+</head>
+<body></body>
+</html>`;
+}

package/scripts/ssg-helmet/build-sitemap-xml.mjs ADDED Viewed

@@ -0,0 +1,75 @@
+const PRIORITY_HOME = 1.0;
+const PRIORITY_NORMAL = 0.8;
+const PRIORITY_TEMPLATED = 0.6;
+const CHANGEFREQ_HOME = "daily";
+const CHANGEFREQ_NORMAL = "weekly";
+const CHANGEFREQ_TEMPLATED = "weekly";
+export function buildSitemapXml(origin, routes) {
+  if (!/^https?:\/\//i.test(origin)) origin = "https://" + origin;
+  const cleanOrigin = origin.replace(/\/+$/, "");
+  const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+  const abs = (route) => `${cleanOrigin}${route === "/" ? "/" : route}`;
+  const esc = (s) =>
+    String(s)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&apos;");
+  const entries = [];
+  for (const item of routes) {
+    if (typeof item === "string") {
+      entries.push({ path: item, kind: item === "/" ? "home" : "normal" });
+    } else if (item && typeof item === "object") {
+      for (const concrete of Object.values(item)) {
+        if (!Array.isArray(concrete)) continue;
+        for (const r of concrete) entries.push({ path: r, kind: "templated" });
+      }
+    }
+  }
+  const rank = { home: 3, normal: 2, templated: 1 };
+  const byPath = new Map();
+  for (const e of entries) {
+    const prev = byPath.get(e.path);
+    if (!prev || rank[e.kind] > rank[prev.kind]) byPath.set(e.path, e);
+  }
+  const ordered = Array.from(byPath.values()).sort((a, b) => {
+    const rk = rank[b.kind] - rank[a.kind];
+    return rk || a.path.localeCompare(b.path);
+  });
+  const node = ({ path, kind }) => {
+    const priority =
+      kind === "home"
+        ? PRIORITY_HOME
+        : kind === "templated"
+          ? PRIORITY_TEMPLATED
+          : PRIORITY_NORMAL;
+    const changefreq =
+      kind === "home"
+        ? CHANGEFREQ_HOME
+        : kind === "templated"
+          ? CHANGEFREQ_TEMPLATED
+          : CHANGEFREQ_NORMAL;
+    return `  <url>
+    <loc>${esc(abs(path))}</loc>
+    <lastmod>${today}</lastmod>
+    <changefreq>${changefreq}</changefreq>
+    <priority>${priority.toFixed(1)}</priority>
+  </url>`;
+  };
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${ordered.map(node).join("\n")}
+</urlset>
+`;
+}

package/scripts/ssg-helmet/extract-routes.mjs ADDED Viewed

@@ -0,0 +1,82 @@
+// extract-routes.mjs
+import fs from "node:fs/promises";
+import * as acorn from "acorn";
+import jsx from "acorn-jsx";
+import { transform } from "sucrase";
+const Parser = acorn.Parser.extend(jsx());
+const tagName = (n) =>
+  n?.type === "JSXIdentifier" ? n.name : n?.type === "JSXMemberExpression" ? n.property?.name : null;
+const attrName = (a) => (a?.name?.type === "JSXIdentifier" ? a.name.name : null);
+const strVal = (v) => {
+  if (!v) return null;
+  if (v.type === "Literal" && typeof v.value === "string") return v.value;
+  if (v.type === "JSXExpressionContainer") {
+    const e = v.expression;
+    if (e?.type === "Literal" && typeof e.value === "string") return e.value;
+    if (e?.type === "TemplateLiteral" && (e.expressions?.length ?? 0) === 0)
+      return e.quasis?.[0]?.value?.cooked ?? null;
+  }
+  return null;
+};
+const walk = (n, f) => {
+  if (!n || typeof n !== "object") return;
+  f(n);
+  for (const k in n) {
+    const v = n[k];
+    if (Array.isArray(v)) v.forEach((x) => walk(x, f));
+    else if (v && typeof v.type === "string") walk(v, f);
+  }
+};
+const isTemplatedRoute = (route) => route.split("/").some((seg) => seg.startsWith(":"));
+/**
+ * Returns routes as:
+ *  - strings for normal routes
+ *  - at most ONE object collecting templated routes: { "page/:id": [], "x/:slug": [] }
+ *
+ * Examples:
+ *   ["/", "/about"]
+ *   ["/", "/about", { "product/:id": [], "blog/:slug": [] }]
+ */
+export async function extractRoutesFromRouterFile(filePath) {
+  const src = await fs.readFile(filePath, "utf8");
+  let code = src;
+  try {
+    code = transform(src, { transforms: ["typescript"] }).code;
+  } catch {}
+  const ast = Parser.parse(code, { ecmaVersion: "latest", sourceType: "module" });
+  const all = new Set();
+  walk(ast, (node) => {
+    if (node.type !== "JSXOpeningElement") return;
+    if (tagName(node.name) !== "Route") return;
+    for (const a of node.attributes ?? []) {
+      if (a.type !== "JSXAttribute") continue;
+      if (attrName(a) !== "path") continue;
+      const p = strVal(a.value);
+      if (p) all.add(p);
+    }
+  });
+  const routes = all.size ? [...all] : ["/"];
+  const normal = [];
+  const templated = {};
+  for (const r of routes) {
+    if (typeof r !== "string") continue;
+    if (isTemplatedRoute(r)) templated[r] = [];
+    else normal.push(r);
+  }
+  return Object.keys(templated).length ? [...normal, templated] : normal;
+}

package/scripts/ssg-helmet/fs-utils.mjs ADDED Viewed

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises";
+import path from "path";
+import { injectUnpackRedirectScript } from "./inject-unpack-redirect.mjs";
+import { buildRedirectHelmetHtml } from "./build-helmet-html.mjs";
+const ROOT = "/";
+const OUT = path.resolve("./out");
+async function writeFile(route, content) {
+  const productOut = path.join(OUT, route, "index.html");
+  await fs.mkdir(path.dirname(productOut), { recursive: true });
+  await fs.writeFile(productOut, content, "utf8");
+}
+export async function writeHelmetFile(html, currentRoute, isIndexable) {
+  const idxTag = isIndexable ? "indexable" : "not_indexable";
+  if (currentRoute === ROOT) {
+    await injectUnpackRedirectScript("out");
+    console.log(`[crawled][${idxTag}][edited] ${currentRoute}index.html`);
+    return;
+  }
+  const helmetHtml = buildRedirectHelmetHtml(html, currentRoute, isIndexable);
+  await writeFile(currentRoute, helmetHtml);
+  console.log(`[crawled][${idxTag}][created] ${currentRoute}/index.html`);
+}

package/scripts/ssg-helmet/get-routes.mjs ADDED Viewed

@@ -0,0 +1,52 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { hasRouter } from "./has-router.mjs";
+import { extractRoutesFromRouterFile } from "./extract-routes.mjs";
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+]);
+async function getRouterFilePath(dir = "./") {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith(".tsx")) continue;
+    const filePath = path.join(dir, e.name);
+    const content = await fs.readFile(filePath, "utf8");
+    if (hasRouter(content)) return filePath;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (SKIP_DIRS.has(e.name)) continue;
+    const filePath = await getRouterFilePath(path.join(dir, e.name));
+    if (filePath) return filePath;
+  }
+  return undefined;
+}
+export async function getRoutes() {
+  const routerFilePath = await getRouterFilePath();
+  if (!routerFilePath) return ["/"];
+  return await extractRoutesFromRouterFile(routerFilePath);
+}
+export function routeDifference(A, B) {
+  const flat = (arr) =>
+    arr.flatMap((x) => (typeof x === "string" ? x : Object.values(x).flat()));
+  const ARoutes = flat(A);
+  const BRoutes = flat(B);
+  return ARoutes.filter((route) => !BRoutes.includes(route));
+}