dh-remixer-sdk 0.0.45-d202e64 → 0.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dh-remixer-sdk",
-  "version": "0.0.45-d202e64",
+  "version": "0.0.45",
   "type": "module",
   "files": [
     "templates",
@@ -29,6 +29,10 @@
     "eslint": "9.0.0",
     "eslint-plugin-import": "2.32.0",
     "eslint-plugin-n": "17.24.0",
-    "globals": "17.4.0"
+    "globals": "17.4.0",
+    "jsdom": "26.1.0",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "react-helmet-async": "3.0.0"
   }
 }

package/scripts/sdk-rewrite/index.mjs

@@ -12,6 +12,7 @@ const SDK_ROOT = 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");
+const SDK_PACKAGE_NAMES = ["dh-remixer-sdk", "@dreamhost/remixer-sdk"];
 
 function isObj(x) {
   return x != null && typeof x === "object" && !Array.isArray(x);
@@ -171,15 +172,24 @@ async function main() {
     }),
   );
 
-  // Re-pin dh-remixer-sdk to the SDK_ROOT version (the templates' source version)
+  // Re-pin the SDK under SDK_ROOT's own package name and version (the templates'
+  // source), dropping the other name so a site never carries both
+  // dh-remixer-sdk and @dreamhost/remixer-sdk
   const projPkg = JSON.parse(await fs.readFile(projPkgPath, "utf8"));
+  const dependencies = { ...(projPkg?.dependencies || {}) };
+  const devDependencies = { ...(projPkg?.devDependencies || {}) };
+  for (const name of SDK_PACKAGE_NAMES) {
+    if (name !== sdkPkg.name) {
+      delete dependencies[name];
+      delete devDependencies[name];
+    }
+  }
+  dependencies[sdkPkg.name] = currentVersion;
   const newPkg = JSON.stringify(
     {
       ...(projPkg || {}),
-      dependencies: {
-        ...(projPkg?.dependencies || {}),
-        "dh-remixer-sdk": currentVersion,
-      },
+      dependencies,
+      ...(projPkg?.devDependencies ? { devDependencies } : {}),
     },
     null,
     2,

package/scripts/sdk-update/cmd-utils.mjs

@@ -1,5 +1,10 @@
 import { spawn } from "child_process";
-import { TARGET_ENVIRONMENT } from "./vars.mjs";
+import {
+  SDK_PACKAGE,
+  SDK_REGISTRY,
+  SDK_REGISTRY_TOKEN,
+  TARGET_ENVIRONMENT,
+} from "./vars.mjs";
 
 const TAG_BY_ENV = {
   production: "latest",
@@ -17,13 +22,18 @@ export async function getSdkVersion() {
     );
   }
 
-  const res = await fetch("https://registry.npmjs.org/dh-remixer-sdk");
+  const res = await fetch(
+    `${SDK_REGISTRY}/${encodeURIComponent(SDK_PACKAGE)}`,
+    SDK_REGISTRY_TOKEN
+      ? { headers: { Authorization: `Bearer ${SDK_REGISTRY_TOKEN}` } }
+      : undefined,
+  );
   const data = await res.json();
   const sdkVersion = data["dist-tags"]?.[tag];
 
   if (!sdkVersion) {
     throw new Error(
-      `[sdk-update] No "${tag}" dist-tag published for dh-remixer-sdk on npm`,
+      `[sdk-update] No "${tag}" dist-tag published for ${SDK_PACKAGE} on ${SDK_REGISTRY}`,
     );
   }
 
@@ -46,7 +56,7 @@ export async function pullSdk() {
   await runCommand(
     "bun",
     "install",
-    `dh-remixer-sdk@${sdkVersion}`,
+    `${SDK_PACKAGE}@${sdkVersion}`,
     "--save-exact",
   );
 }

package/scripts/sdk-update/fs-utils.mjs

@@ -2,7 +2,13 @@ import path from "node:path";
 import fs from "node:fs/promises";
 import fssync from "node:fs";
 import { jsonMerge } from "./type-utils.mjs";
-import { BASE_ROOT, PROJECT_ROOT, SDK_ROOT } from "./vars.mjs";
+import {
+  BASE_ROOT,
+  LEGACY_SDK_PACKAGE,
+  PROJECT_ROOT,
+  SDK_PACKAGE,
+  SDK_ROOT,
+} from "./vars.mjs";
 import { getSdkVersion } from "./cmd-utils.mjs";
 
 export async function getTargetPackageJson() {
@@ -64,13 +70,19 @@ export async function injectSdkPackage() {
   const projPkgPath = path.join(projectRoot, "package.json");
   const projPkg = JSON.parse(await fs.readFile(projPkgPath, "utf8"));
 
+  const dependencies = { ...(projPkg?.dependencies || {}) };
+  const devDependencies = { ...(projPkg?.devDependencies || {}) };
+  if (SDK_PACKAGE !== LEGACY_SDK_PACKAGE) {
+    delete dependencies[LEGACY_SDK_PACKAGE];
+    delete devDependencies[LEGACY_SDK_PACKAGE];
+  }
+  dependencies[SDK_PACKAGE] = sdkVersion;
+
   const newPkg = JSON.stringify(
     {
       ...(projPkg || {}),
-      dependencies: {
-        ...(projPkg?.dependencies || {}),
-        "dh-remixer-sdk": sdkVersion,
-      },
+      dependencies,
+      ...(projPkg?.devDependencies ? { devDependencies } : {}),
     },
     null,
     2,

package/scripts/sdk-update/sdk-utils.mjs

@@ -10,8 +10,8 @@ function assertTemplateExists(templateType) {
   const templateRoot = path.join(SDK_ROOT, "templates", templateType);
   if (!fssync.existsSync(templateRoot)) {
     throw new Error(
-      `[sdk-update] Template "${templateType}" not found in installed dh-remixer-sdk (${templateRoot}). ` +
-        `Run: npm install dh-remixer-sdk@latest`,
+      `[sdk-update] Template "${templateType}" not found in installed SDK package (${templateRoot}). ` +
+        `Run: bun run remixer-sdk:update`,
     );
   }
 }

package/scripts/sdk-update/vars.mjs

@@ -9,3 +9,9 @@ export const SDK_ROOT = path.resolve(
 );
 export const PROJECT_ROOT = path.resolve(process.env.INIT_CWD ?? process.cwd());
 export const BASE_ROOT = path.join(SDK_ROOT, "templates", "base");
+export const LEGACY_SDK_PACKAGE = "dh-remixer-sdk";
+export const SDK_PACKAGE = process.env.REMIXER_SDK_PACKAGE || LEGACY_SDK_PACKAGE;
+export const SDK_REGISTRY = (
+  process.env.REMIXER_SDK_REGISTRY || "https://registry.npmjs.org"
+).replace(/\/$/, "");
+export const SDK_REGISTRY_TOKEN = process.env.REMIXER_SDK_REGISTRY_TOKEN;

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

@@ -1,3 +1,5 @@
+import { canonicalUrl, normalizeRoutePath } from "./seo-settings.mjs";
+
 const PRIORITY_HOME = 1.0;
 const PRIORITY_NORMAL = 0.8;
 const PRIORITY_TEMPLATED = 0.6;
@@ -6,18 +8,12 @@ const CHANGEFREQ_HOME = "daily";
 const CHANGEFREQ_NORMAL = "weekly";
 const CHANGEFREQ_TEMPLATED = "weekly";
 
-const ensureTrailingSlash = (p) => {
-  const [base, suffix] = p.split(/([?#].*)/); // keep query/hash intact
-  const normalized = base.endsWith("/") ? base : base + "/";
-  return suffix ? normalized + suffix : normalized;
-};
-
 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 loc = (route) => canonicalUrl(cleanOrigin, route);
   const esc = (s) =>
     String(s)
       .replace(/&/g, "&")
@@ -29,28 +25,28 @@ export function buildSitemapXml(origin, routes) {
   const entries = [];
   for (const item of routes) {
     if (typeof item === "string") {
-      entries.push({ path: item, kind: item === "/" ? "home" : "normal" });
+      entries.push({ url: loc(item), kind: normalizeRoutePath(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" });
+        for (const r of concrete) entries.push({ url: loc(r), kind: "templated" });
       }
     }
   }
 
   const rank = { home: 3, normal: 2, templated: 1 };
-  const byPath = new Map();
+  const byUrl = 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 prev = byUrl.get(e.url);
+    if (!prev || rank[e.kind] > rank[prev.kind]) byUrl.set(e.url, e);
   }
 
-  const ordered = Array.from(byPath.values()).sort((a, b) => {
+  const ordered = Array.from(byUrl.values()).sort((a, b) => {
     const rk = rank[b.kind] - rank[a.kind];
-    return rk || a.path.localeCompare(b.path);
+    return rk || a.url.localeCompare(b.url);
   });
 
-  const node = ({ path, kind }) => {
+  const node = ({ url, kind }) => {
     const priority =
       kind === "home"
         ? PRIORITY_HOME
@@ -66,7 +62,7 @@ export function buildSitemapXml(origin, routes) {
           : CHANGEFREQ_NORMAL;
 
     return `  <url>
-    <loc>${esc(abs(ensureTrailingSlash(path)))}</loc>
+    <loc>${esc(url)}</loc>
     <lastmod>${today}</lastmod>
     <changefreq>${changefreq}</changefreq>
     <priority>${priority.toFixed(1)}</priority>

package/scripts/ssg-helmet/build-sitemap-xml.test.mjs

@@ -0,0 +1,22 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildSitemapXml } from "./build-sitemap-xml.mjs";
+
+const ORIGIN = "https://flowremixer.dreamhosters.com";
+const locs = (xml) => [...xml.matchAll(/<loc>([^<]*)<\/loc>/g)].map(([, loc]) => loc);
+
+test("the root is listed with a slash and every other page without one", () => {
+  assert.deepEqual(locs(buildSitemapXml(ORIGIN, ["/", "/about", "/shop/", "/contact?ref=nav#form"])), [
+    `${ORIGIN}/`,
+    `${ORIGIN}/about`,
+    `${ORIGIN}/contact`,
+    `${ORIGIN}/shop`,
+  ]);
+});
+
+test("templated pages use the same canonical form and a page listed twice appears once", () => {
+  const xml = buildSitemapXml("flowremixer.dreamhosters.com/", ["/", "/about/", "/about", { "/product/:id": ["/product/nox-1/", "/product/nox-2"] }]);
+
+  assert.deepEqual(locs(xml), [`${ORIGIN}/`, `${ORIGIN}/about`, `${ORIGIN}/product/nox-1`, `${ORIGIN}/product/nox-2`]);
+  assert.match(xml, new RegExp(`<loc>${ORIGIN}/product/nox-1</loc>\\s*<lastmod>[^<]+</lastmod>\\s*<changefreq>weekly</changefreq>\\s*<priority>0.6</priority>`));
+});

package/scripts/ssg-helmet/business-hours.mjs

@@ -0,0 +1,65 @@
+const DAY_CODES = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+const DAY_NAMES = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+const DAY_ABBREVIATIONS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const OPENING_TIME_RE = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
+const CLOSING_TIME_RE = /^(?:(?:[01]\d|2[0-3]):[0-5]\d|24:00)$/;
+
+function entryProblem(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return "is not a days/opens/closes entry";
+  if (!Array.isArray(entry.days) || entry.days.length === 0) return "has no days";
+  const unknown = entry.days.find((day) => !DAY_CODES.includes(day));
+  if (unknown !== undefined) return `has an unknown day code ${JSON.stringify(unknown)}`;
+  if (typeof entry.opens !== "string" || !OPENING_TIME_RE.test(entry.opens)) {
+    return `has a bad opening time ${JSON.stringify(entry.opens ?? null)}`;
+  }
+  if (typeof entry.closes !== "string" || !CLOSING_TIME_RE.test(entry.closes)) {
+    return `has a bad closing time ${JSON.stringify(entry.closes ?? null)}`;
+  }
+  if (entry.opens === entry.closes) return "opens and closes at the same time";
+  return null;
+}
+
+export function businessHours(hours) {
+  const valid = [];
+  const invalid = [];
+  (Array.isArray(hours) ? hours : []).forEach((entry, index) => {
+    const problem = entryProblem(entry);
+    if (problem) invalid.push({ index, problem });
+    else valid.push(entry);
+  });
+  return { valid, invalid };
+}
+
+const dayIndexes = (days) =>
+  DAY_CODES.map((code, index) => (days.includes(code) ? index : -1)).filter((index) => index >= 0);
+
+const schemaClosingTime = ({ opens, closes }) => {
+  if (closes !== "24:00") return closes;
+  return opens === "00:00" ? "23:59" : "00:00";
+};
+
+export const openingHoursSpecification = (entries) =>
+  entries.map((entry) => ({
+    "@type": "OpeningHoursSpecification",
+    dayOfWeek: dayIndexes(entry.days).map((index) => DAY_NAMES[index]),
+    opens: entry.opens,
+    closes: schemaClosingTime(entry),
+  }));
+
+function dayRanges(days) {
+  const ranges = [];
+  for (const index of dayIndexes(days)) {
+    const last = ranges.at(-1);
+    if (last && index === last.end + 1) last.end = index;
+    else ranges.push({ start: index, end: index });
+  }
+  return ranges
+    .map(({ start, end }) => {
+      if (start === end) return DAY_ABBREVIATIONS[start];
+      const separator = end === start + 1 ? ", " : "–";
+      return `${DAY_ABBREVIATIONS[start]}${separator}${DAY_ABBREVIATIONS[end]}`;
+    })
+    .join(", ");
+}
+
+export const hoursLine = (entry) => `${dayRanges(entry.days)} ${entry.opens}–${entry.closes}`;

package/scripts/ssg-helmet/business-hours.test.mjs

@@ -0,0 +1,50 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { businessHours, hoursLine, openingHoursSpecification } from "./business-hours.mjs";
+
+const HOURS = [
+  { days: ["Mo", "Tu", "We", "Th"], opens: "16:00", closes: "24:00" },
+  { days: ["Sa", "Fr"], opens: "16:00", closes: "02:00" },
+  { days: ["Su"], opens: "00:00", closes: "24:00" },
+];
+
+test("structured hours become opening hours specifications as stored", () => {
+  assert.deepEqual(openingHoursSpecification(businessHours(HOURS).valid), [
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Monday", "Tuesday", "Wednesday", "Thursday"], opens: "16:00", closes: "00:00" },
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Friday", "Saturday"], opens: "16:00", closes: "02:00" },
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Sunday"], opens: "00:00", closes: "23:59" },
+  ]);
+});
+
+test("structurally invalid entries are set aside with the reason", () => {
+  const { valid, invalid } = businessHours([
+    HOURS[0],
+    { days: ["Mx"], opens: "09:00", closes: "17:00" },
+    { days: ["Mo"], opens: "9am", closes: "17:00" },
+    { days: ["Mo"], opens: "09:00", closes: "25:00" },
+    { days: [], opens: "09:00", closes: "17:00" },
+    { days: ["Mo"], opens: "09:00", closes: "09:00" },
+    "Mon–Fri 9am–5pm",
+  ]);
+
+  assert.deepEqual(valid, [HOURS[0]]);
+  assert.deepEqual(invalid, [
+    { index: 1, problem: 'has an unknown day code "Mx"' },
+    { index: 2, problem: 'has a bad opening time "9am"' },
+    { index: 3, problem: 'has a bad closing time "25:00"' },
+    { index: 4, problem: "has no days" },
+    { index: 5, problem: "opens and closes at the same time" },
+    { index: 6, problem: "is not a days/opens/closes entry" },
+  ]);
+});
+
+test("a missing or empty hours list is no hours", () => {
+  assert.deepEqual(businessHours(undefined), { valid: [], invalid: [] });
+  assert.deepEqual(businessHours([]), { valid: [], invalid: [] });
+});
+
+test("hours read as English day abbreviations for llms.txt", () => {
+  assert.equal(hoursLine(HOURS[0]), "Mon–Thu 16:00–24:00");
+  assert.equal(hoursLine(HOURS[1]), "Fri, Sat 16:00–02:00");
+  assert.equal(hoursLine({ days: ["Mo", "We", "Fr", "Sa", "Su"], opens: "09:00", closes: "17:00" }), "Mon, Wed, Fri–Sun 09:00–17:00");
+});

package/scripts/ssg-helmet/business-ld-json.mjs

@@ -0,0 +1,138 @@
+import { textValue } from "./seo-settings.mjs";
+import { businessHours, openingHoursSpecification } from "./business-hours.mjs";
+import { locatedAddress } from "./geocoded-address.mjs";
+
+const SCHEMA_CONTEXT = "https://schema.org";
+const PRICE_RANGES = new Set(["$", "$$", "$$$"]);
+const BUSINESS_SCHEMA_TYPES = {
+  restaurant: "Restaurant",
+  cafe: "CafeOrCoffeeShop",
+  bar: "BarOrPub",
+  bakery: "Bakery",
+  shop: "Store",
+  "online store": "OnlineStore",
+  florist: "Florist",
+  "salon or spa": "BeautySalon",
+  "fitness studio": "ExerciseGym",
+  "health clinic": "MedicalClinic",
+  "repair shop": "LocalBusiness",
+  "home services": "HomeAndConstructionBusiness",
+  "professional services": "ProfessionalService",
+  photographer: "ProfessionalService",
+  "event venue": "EventVenue",
+  nonprofit: "NGO",
+  "music venue": ["LocalBusiness", "MusicVenue"],
+  "service business": "ProfessionalService",
+};
+
+const typeKey = (type) =>
+  String(type ?? "")
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .trim()
+    .toLowerCase();
+
+const isEmpty = (value) =>
+  value === undefined ||
+  value === null ||
+  value === "" ||
+  (Array.isArray(value) && value.length === 0) ||
+  (typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.keys(value).every((key) => key === "@type" || isEmpty(value[key])));
+
+const compact = (node) =>
+  Object.fromEntries(Object.entries(node).filter(([, value]) => !isEmpty(value)));
+
+const httpUrls = (links) =>
+  (Array.isArray(links) ? links : [])
+    .map(textValue)
+    .filter((link) => link && /^https?:\/\//i.test(link));
+
+export function hasBusinessFacts(business) {
+  if (!business || typeof business !== "object") return false;
+  return (
+    ["name", "type", "address", "phone", "email", "hoursNote", "priceRange", "serviceArea", "siteIconUrl"].some(
+      (key) => textValue(business[key]),
+    ) ||
+    httpUrls(business.links).length > 0 ||
+    (Array.isArray(business.hours) && business.hours.length > 0)
+  );
+}
+
+export function businessSchemaType(type, { hasLocalDetails, fallback = "Organization" } = {}) {
+  const mapped = BUSINESS_SCHEMA_TYPES[typeKey(type)];
+  if (mapped) return mapped;
+  return hasLocalDetails ? "LocalBusiness" : fallback;
+}
+
+function scrapedCoordinates(scraped) {
+  const latitude = scraped?.geo?.latitude;
+  const longitude = scraped?.geo?.longitude;
+  if (latitude === undefined || longitude === undefined) return undefined;
+  return { "@type": "GeoCoordinates", latitude, longitude };
+}
+
+export function businessNode({ business, origin, scraped, geocoded, fallbackType }) {
+  const hours = openingHoursSpecification(businessHours(business.hours).valid);
+  const priceRange = PRICE_RANGES.has(business.priceRange) ? business.priceRange : undefined;
+  const address = textValue(business.address);
+  const located = locatedAddress(address, geocoded);
+  const scrapedAddress = scraped?.address ? compact(scraped.address) : undefined;
+
+  return compact({
+    "@type": businessSchemaType(business.type, {
+      hasLocalDetails: hours.length > 0 || Boolean(priceRange),
+      fallback: fallbackType,
+    }),
+    "@id": `${origin}/#business`,
+    name: textValue(business.name),
+    url: `${origin}/`,
+    logo: textValue(business.siteIconUrl),
+    telephone: textValue(business.phone) ?? scraped?.telephone,
+    email: textValue(business.email),
+    address: located.address ?? scrapedAddress,
+    geo: address ? located.geo : scrapedCoordinates(scraped),
+    areaServed: textValue(business.serviceArea) ?? scraped?.areaServed?.[0]?.name,
+    openingHoursSpecification: hours,
+    priceRange,
+    sameAs: httpUrls(business.links),
+  });
+}
+
+export function faqNode(pairs, pageUrl) {
+  return {
+    "@type": "FAQPage",
+    "@id": `${pageUrl}#faq`,
+    mainEntity: pairs.map(({ question, answer }) => ({
+      "@type": "Question",
+      name: question,
+      acceptedAnswer: { "@type": "Answer", text: answer },
+    })),
+  };
+}
+
+export function businessPageLdJson({ page, business, questions, pageUrl }) {
+  const graph = [
+    compact({
+      "@type": "WebPage",
+      "@id": `${pageUrl}#webpage`,
+      url: pageUrl,
+      name: page.name,
+      description: page.description,
+      about: { "@id": business["@id"] },
+    }),
+    business,
+  ];
+  if (questions.length) graph.push(faqNode(questions, pageUrl));
+  return { "@context": SCHEMA_CONTEXT, "@graph": graph };
+}
+
+export function withFaq(pageLdJson, questions, pageUrl) {
+  if (!questions.length) return pageLdJson;
+  const { "@context": context, ...page } = pageLdJson;
+  return {
+    "@context": context ?? SCHEMA_CONTEXT,
+    "@graph": [page, faqNode(questions, pageUrl)],
+  };
+}