jsonresume-theme-signal 1.0.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "jsonresume-theme-signal",
+  "version": "1.0.0",
+  "description": "High-signal, print-ready JSON Resume theme with multi-role company grouping and career partitioning",
+  "type": "module",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./types.ts": "./src/types.ts"
+  },
+  "files": ["index.js", "index.d.ts", "src/", "README.md"],
+  "keywords": ["jsonresume", "jsonresume-theme", "resume", "cv", "pdf"],
+  "author": "Meni Livne",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/menil/jsonresume-theme-signal.git"
+  },
+  "bugs": {
+    "url": "https://github.com/menil/jsonresume-theme-signal/issues"
+  },
+  "homepage": "https://github.com/menil/jsonresume-theme-signal#readme",
+  "scripts": {
+    "build": "bun build src/index.ts --outfile index.js --target node --format esm --packages=bundle && bun run scripts/build-declarations.ts",
+    "prepublishOnly": "bun run build",
+    "prepack": "bun run build",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "check-format": "biome format ."
+  },
+  "trustedDependencies": ["@biomejs/biome"],
+  "dependencies": {
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "^1.3.13",
+    "@types/handlebars": "^4.1.0",
+    "puppeteer": "^24.4.0",
+    "resumed": "^7.0.0",
+    "typescript": "^5.7.3"
+  }
+}

package/src/declarations.d.ts

@@ -0,0 +1,9 @@
+declare module "*.hbs" {
+  const content: string;
+  export default content;
+}
+
+declare module "*.css" {
+  const content: string;
+  export default content;
+}

package/src/helpers.ts

@@ -0,0 +1,196 @@
+import type {
+  EarlyCareerItem,
+  PreparedResumeData,
+  ResumeData,
+  ResumeProfile,
+  ResumeWork,
+  ThemeFitOptions,
+  ThemeOptions,
+} from "./types.ts";
+
+/**
+ * Extracts a profile URL matching a given network name (case-insensitive).
+ */
+export function getProfile(profiles: ResumeProfile[] | undefined, network: string): string {
+  if (!profiles || !Array.isArray(profiles)) return "";
+  const match = profiles.find((p) => p.network?.toLowerCase() === network.toLowerCase());
+  return match?.url || "";
+}
+
+export function getLinkedIn(profiles: ResumeProfile[] | undefined): string {
+  return getProfile(profiles, "linkedin");
+}
+
+export function getGitHub(profiles: ResumeProfile[] | undefined): string {
+  return getProfile(profiles, "github");
+}
+
+/**
+ * Extracts the 4-digit ending year from a date string.
+ */
+export function getEndYear(dateStr?: string): number | null {
+  if (!dateStr || typeof dateStr !== "string") return null;
+  const match = dateStr.match(/\b(19\d{2}|20\d{2})\b/);
+  return match ? Number.parseInt(match[1], 10) : null;
+}
+
+/**
+ * Formats start and end dates cleanly (e.g., "2020 - Present", "2018 - 2020").
+ * Note: Uses standard hyphen instead of en-dash to avoid font glyph stretching
+ * and excessive spacing under bold weights in PDF print renderers.
+ */
+export function formatDates(startDate?: string, endDate?: string): string {
+  if (startDate && endDate) {
+    return `${startDate} - ${endDate}`;
+  }
+  if (startDate && !endDate) {
+    return `${startDate} - Present`;
+  }
+  if (!startDate && endDate) {
+    return endDate;
+  }
+  return "";
+}
+
+/**
+ * Strips protocol and leading 'www.' from URLs for clean print rendering.
+ */
+export function stripUrl(url?: string): string {
+  if (!url) return "";
+  return url.replace(/^https?:\/\//, "").replace(/^www\./, "");
+}
+
+/**
+ * Groups consecutive roles at the same company together.
+ */
+export function groupWork(workList: ResumeWork[]): ResumeWork[] {
+  if (!workList || workList.length === 0) return [];
+
+  const grouped: ResumeWork[] = [];
+
+  for (const item of workList) {
+    const role = {
+      position: item.position || "",
+      startDate: item.startDate,
+      endDate: item.endDate,
+      dates: formatDates(item.startDate, item.endDate),
+      summary: item.summary,
+      highlights: item.highlights || [],
+    };
+
+    const prev = grouped[grouped.length - 1];
+    if (prev?.name && item.name && prev.name.trim() === item.name.trim()) {
+      prev.roles = prev.roles || [];
+      prev.roles.push(role);
+    } else {
+      grouped.push({
+        name: item.name,
+        url: item.url,
+        description: item.description || item.summary,
+        roles: [role],
+      });
+    }
+  }
+
+  return grouped;
+}
+
+/**
+ * Prepares resume data:
+ * - Partitions work experience older than 10 years into early career summary items.
+ * - Extracts social links into basics.
+ * - Groups multiple roles under the same company.
+ */
+export function prepareResume(
+  data: ResumeData,
+  optionsOrAsOfYear?: ThemeOptions | number,
+): PreparedResumeData {
+  const options: ThemeOptions =
+    typeof optionsOrAsOfYear === "number"
+      ? { asOfYear: optionsOrAsOfYear }
+      : (optionsOrAsOfYear ?? {});
+
+  const metaOptions = (data.meta?.themeOptions as ThemeFitOptions | undefined) || {};
+
+  const currentYear = options.asOfYear ?? new Date().getFullYear();
+  const cutoffYear = currentYear - 10;
+
+  const rawWork = data.work || [];
+  const professionalWork: ResumeWork[] = [];
+  const earlyCareerList: EarlyCareerItem[] = [];
+
+  for (const w of rawWork) {
+    const endYr = getEndYear(w.endDate);
+    const isOngoing = !w.endDate;
+    const isEarly = !isOngoing && endYr !== null && endYr < cutoffYear;
+
+    if (isEarly) {
+      const dates = formatDates(w.startDate, w.endDate);
+      const company = w.name || "";
+      const position = w.position || "";
+      const details = position && company ? `${position}, ${company}` : position || company;
+
+      earlyCareerList.push({
+        dates,
+        details,
+      });
+    } else {
+      professionalWork.push(w);
+    }
+  }
+
+  const groupedWork = groupWork(professionalWork);
+
+  const basics = data.basics ? { ...data.basics } : {};
+  if (!basics.linkedin) {
+    basics.linkedin = getLinkedIn(basics.profiles);
+  }
+  if (!basics.github) {
+    basics.github = getGitHub(basics.profiles);
+  }
+  if (!basics.pdf_url && basics.name) {
+    const slug = basics.name.toLowerCase().replace(/[^a-z0-9_-]+/g, "_");
+    basics.pdf_url = `${slug}_resume.pdf`;
+  }
+
+  const fit_pages = options.fitPages ?? metaOptions.fitPages ?? "off";
+  const fit_tolerance = options.fitTolerance ?? metaOptions.fitTolerance ?? 0.28;
+  const density = options.density ?? metaOptions.density ?? "normal";
+
+  return {
+    ...data,
+    basics,
+    work: groupedWork,
+    early_career: earlyCareerList.length > 0 ? earlyCareerList : data.early_career,
+    fit_pages,
+    fit_tolerance,
+    density,
+  };
+}
+
+/**
+ * Registers all custom helpers onto a Handlebars instance.
+ */
+export function registerHelpers(hbs: typeof import("handlebars")): void {
+  hbs.registerHelper("formatDates", (startDate: string, endDate: string) =>
+    formatDates(startDate, endDate),
+  );
+  hbs.registerHelper("stripUrl", (url: string) => stripUrl(url));
+  hbs.registerHelper("join", (arr: string[] | undefined, separator: string) => {
+    if (!Array.isArray(arr)) return "";
+    return arr.join(typeof separator === "string" ? separator : ", ");
+  });
+  hbs.registerHelper("eq", (a: unknown, b: unknown) => a === b);
+  hbs.registerHelper("contains", (str: unknown, substr: unknown) => {
+    if (typeof str !== "string" || typeof substr !== "string") return false;
+    return str.includes(substr);
+  });
+  hbs.registerHelper("or", (...args: unknown[]) => {
+    const items = args.slice(0, -1);
+    return items.some((item) => Boolean(item));
+  });
+  hbs.registerHelper("and", (...args: unknown[]) => {
+    const items = args.slice(0, -1);
+    return items.every((item) => Boolean(item));
+  });
+}

package/src/index.ts

@@ -0,0 +1,92 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import Handlebars from "handlebars";
+import { prepareResume, registerHelpers } from "./helpers.ts";
+import styleCss from "./style.css" with { type: "text" };
+import templateSource from "./template.hbs" with { type: "text" };
+import type { ResumeData, ThemeOptions } from "./types.ts";
+
+const hbs = Handlebars.create();
+registerHelpers(hbs);
+
+const compiledTemplate = hbs.compile(templateSource);
+
+/**
+ * Default Puppeteer PDF rendering options for the resumed CLI.
+ */
+export const pdfRenderOptions = {
+  format: "Letter",
+  printBackground: true,
+  preferCSSPageSize: true,
+} as const;
+
+/**
+ * Renders a JSON Resume object to an HTML string.
+ */
+export function render(resume: ResumeData = {}, options: ThemeOptions = {}): string {
+  const prepared = prepareResume(resume, options);
+  const metaOptions = (resume.meta?.themeOptions || {}) as ThemeOptions;
+  prepared.is_pdf = options.is_pdf ?? metaOptions.is_pdf ?? false;
+
+  return compiledTemplate({
+    ...prepared,
+    css: styleCss,
+  });
+}
+
+/**
+ * Builds an HTML file from a JSON Resume JSON file on disk.
+ */
+export function buildHtml(
+  inputJsonPath: string,
+  outputPath?: string,
+  options: ThemeOptions = {},
+): string {
+  let data: ResumeData;
+  try {
+    const raw = readFileSync(inputJsonPath, "utf-8");
+    data = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Failed to read or parse JSON Resume file at "${inputJsonPath}": ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  let targetPath = outputPath;
+  if (!targetPath) {
+    const name = data.basics?.name || "resume";
+    const slug = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "_");
+    targetPath = join(dirname(inputJsonPath), `${slug}_resume.html`);
+  }
+
+  mkdirSync(dirname(targetPath), { recursive: true });
+  const html = render(data, options);
+  writeFileSync(targetPath, html, "utf-8");
+  return targetPath;
+}
+
+// CLI usage: bun src/index.ts <input.json> [output.html]
+const isCliEntrypoint =
+  typeof process !== "undefined" &&
+  process.argv[1] !== undefined &&
+  fileURLToPath(import.meta.url) === process.argv[1];
+
+if (isCliEntrypoint) {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error("Usage: bun src/index.ts <input.json> [output.html]");
+    process.exit(1);
+  }
+
+  const inputFile = args[0];
+  const outputFile = args[1];
+
+  try {
+    const createdPath = buildHtml(inputFile, outputFile);
+    console.log(`Success! Created ${createdPath}`);
+  } catch (err) {
+    console.error("Error generating HTML:", err);
+    process.exit(1);
+  }
+}