@forwardimpact/pathway 0.1.0 → 0.2.0

package/app/formatters/behaviour/microdata.js

@@ -0,0 +1,106 @@
+/**
+ * Behaviour formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with behaviour.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  propRaw,
+  metaTag,
+  section,
+  dl,
+  ul,
+  escapeHtml,
+  formatLevelName,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareBehavioursList, prepareBehaviourDetail } from "./shared.js";
+
+/**
+ * Format behaviour list as microdata HTML
+ * @param {Array} behaviours - Raw behaviour entities
+ * @returns {string} HTML with microdata
+ */
+export function behaviourListToMicrodata(behaviours) {
+  const { items } = prepareBehavioursList(behaviours);
+
+  const content = items
+    .map(
+      (
+        behaviour,
+      ) => `${openTag("article", { itemtype: "Behaviour", itemid: `#${behaviour.id}` })}
+${prop("h2", "name", behaviour.name)}
+${prop("p", "description", behaviour.truncatedDescription)}
+</article>`,
+    )
+    .join("\n");
+
+  return htmlDocument(
+    "Behaviours",
+    `<main>
+<h1>Behaviours</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format behaviour detail as microdata HTML
+ * @param {Object} behaviour - Raw behaviour entity
+ * @param {Object} context - Additional context
+ * @param {Array} context.drivers - All drivers
+ * @returns {string} HTML with microdata
+ */
+export function behaviourToMicrodata(behaviour, { drivers }) {
+  const view = prepareBehaviourDetail(behaviour, { drivers });
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Maturity descriptions - uses MaturityDescriptions itemtype
+  const maturityPairs = Object.entries(view.maturityDescriptions).map(
+    ([maturity, desc]) => ({
+      term: formatLevelName(maturity),
+      definition: desc,
+      itemprop: `${maturity.replace(/_([a-z])/g, (_, c) => c.toUpperCase())}Description`,
+    }),
+  );
+  sections.push(
+    section(
+      "Maturity Levels",
+      `${openTag("div", { itemtype: "MaturityDescriptions", itemprop: "maturityDescriptions" })}
+${dl(maturityPairs)}
+</div>`,
+      2,
+    ),
+  );
+
+  // Related drivers
+  if (view.relatedDrivers.length > 0) {
+    const driverItems = view.relatedDrivers.map(
+      (d) => `<a href="#${escapeHtml(d.id)}">${escapeHtml(d.name)}</a>`,
+    );
+    sections.push(section("Linked to Drivers", ul(driverItems), 2));
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Behaviour", itemid: `#${view.id}` })}
+${prop("h1", "name", view.name)}
+${metaTag("id", view.id)}
+${propRaw(
+  "div",
+  "human",
+  `${openTag("div", { itemtype: "BehaviourHumanSection" })}
+${prop("p", "description", view.description)}
+${sections.join("\n")}
+</div>`,
+)}
+</article>
+</main>`;
+
+  return htmlDocument(view.name, body);
+}

package/app/formatters/discipline/dom.js

@@ -20,6 +20,24 @@ import {
 } from "../../components/action-buttons.js";
 import { getConceptEmoji } from "../../model/levels.js";
 import { prepareDisciplineDetail } from "./shared.js";
+import { createJsonLdScript, disciplineToJsonLd } from "../json-ld.js";
+import { createBadge } from "../../components/card.js";
+
+/**
+ * Get type badges for discipline (Management/Professional)
+ * @param {Object} discipline - Raw discipline entity
+ * @returns {HTMLElement[]}
+ */
+function getDisciplineTypeBadges(discipline) {
+  const badges = [];
+  if (discipline.isProfessional) {
+    badges.push(createBadge("Professional", "secondary"));
+  }
+  if (discipline.isManagement) {
+    badges.push(createBadge("Management", "primary"));
+  }
+  return badges;
+}
 
 /**
  * Format discipline detail as DOM elements
@@ -44,15 +62,24 @@ export function disciplineToDOM(
 ) {
   const view = prepareDisciplineDetail(discipline, { skills, behaviours });
   const emoji = getConceptEmoji(framework, "discipline");
+  const typeBadges = getDisciplineTypeBadges(discipline);
   return div(
     { className: "detail-page discipline-detail" },
+    // JSON-LD structured data
+    createJsonLdScript(disciplineToJsonLd(discipline, { skills })),
     // Header
     div(
       { className: "page-header" },
       showBackLink
         ? createBackLink("/discipline", "← Back to Disciplines")
         : null,
-      heading1({ className: "page-title" }, `${emoji} `, view.name),
+      div(
+        { className: "page-title-row" },
+        heading1({ className: "page-title" }, `${emoji} `, view.name),
+        typeBadges.length > 0
+          ? div({ className: "page-title-badges" }, ...typeBadges)
+          : null,
+      ),
       p({ className: "page-description" }, view.description),
       showBackLink
         ? div(

package/app/formatters/discipline/microdata.js

@@ -0,0 +1,117 @@
+/**
+ * Discipline formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with discipline.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  linkTag,
+  section,
+  ul,
+  escapeHtml,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareDisciplinesList, prepareDisciplineDetail } from "./shared.js";
+
+/**
+ * Format discipline list as microdata HTML
+ * @param {Array} disciplines - Raw discipline entities
+ * @returns {string} HTML with microdata
+ */
+export function disciplineListToMicrodata(disciplines) {
+  const { items } = prepareDisciplinesList(disciplines);
+
+  const content = items
+    .map(
+      (
+        d,
+      ) => `${openTag("article", { itemtype: "Discipline", itemid: `#${d.id}` })}
+${prop("h2", "specialization", d.name)}
+<p>Core: ${d.coreSkillsCount} | Supporting: ${d.supportingSkillsCount} | Broad: ${d.broadSkillsCount}</p>
+</article>`,
+    )
+    .join("\n");
+
+  return htmlDocument(
+    "Disciplines",
+    `<main>
+<h1>Disciplines</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format discipline detail as microdata HTML
+ * @param {Object} discipline - Raw discipline entity
+ * @param {Object} context - Additional context
+ * @param {Array} context.skills - All skills
+ * @param {Array} context.behaviours - All behaviours
+ * @param {boolean} [context.showBehaviourModifiers=true] - Whether to show behaviour modifiers section
+ * @returns {string} HTML with microdata
+ */
+export function disciplineToMicrodata(
+  discipline,
+  { skills, behaviours, showBehaviourModifiers = true } = {},
+) {
+  const view = prepareDisciplineDetail(discipline, { skills, behaviours });
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Core skills - using coreSkills property
+  if (view.coreSkills.length > 0) {
+    const skillLinks = view.coreSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "coreSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Core Skills", ul(skillLinks), 2));
+  }
+
+  // Supporting skills - using supportingSkills property
+  if (view.supportingSkills.length > 0) {
+    const skillLinks = view.supportingSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "supportingSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Supporting Skills", ul(skillLinks), 2));
+  }
+
+  // Broad skills - using broadSkills property
+  if (view.broadSkills.length > 0) {
+    const skillLinks = view.broadSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "broadSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Broad Skills", ul(skillLinks), 2));
+  }
+
+  // Behaviour modifiers - using BehaviourModifier itemtype
+  if (showBehaviourModifiers && view.behaviourModifiers.length > 0) {
+    const modifierItems = view.behaviourModifiers.map((b) => {
+      const modifierStr = b.modifier > 0 ? `+${b.modifier}` : `${b.modifier}`;
+      return `${openTag("span", { itemtype: "BehaviourModifier", itemprop: "behaviourModifiers" })}
+${linkTag("targetBehaviour", `#${b.id}`)}
+<a href="#${escapeHtml(b.id)}">${escapeHtml(b.name)}</a>: ${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>
+</span>`;
+    });
+    sections.push(section("Behaviour Modifiers", ul(modifierItems), 2));
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Discipline", itemid: `#${view.id}` })}
+${prop("h1", "specialization", view.name)}
+${metaTag("id", view.id)}
+${discipline.roleTitle ? prop("p", "roleTitle", discipline.roleTitle) : ""}
+${prop("p", "description", view.description)}
+${sections.join("\n")}
+</article>
+</main>`;
+
+  return htmlDocument(view.name, body);
+}

package/app/formatters/discipline/shared.js

@@ -35,16 +35,18 @@ export function getDisciplineDisplayName(discipline) {
  * @property {number} coreSkillsCount
  * @property {number} supportingSkillsCount
  * @property {number} broadSkillsCount
+ * @property {boolean} isProfessional
+ * @property {boolean} isManagement
  */
 
 /**
- * Transform disciplines for list view
- * @param {Array} disciplines - Raw discipline entities
- * @param {number} [descriptionLimit=120] - Maximum description length
- * @returns {{ items: DisciplineListItem[] }}
+ * Transform a single discipline to list item format
+ * @param {Object} discipline - Raw discipline entity
+ * @param {number} descriptionLimit - Maximum description length
+ * @returns {DisciplineListItem}
  */
-export function prepareDisciplinesList(disciplines, descriptionLimit = 120) {
-  const items = disciplines.map((discipline) => ({
+function disciplineToListItem(discipline, descriptionLimit) {
+  return {
     id: discipline.id,
     name: getDisciplineDisplayName(discipline),
     description: discipline.description,
@@ -52,9 +54,48 @@ export function prepareDisciplinesList(disciplines, descriptionLimit = 120) {
     coreSkillsCount: discipline.coreSkills?.length || 0,
     supportingSkillsCount: discipline.supportingSkills?.length || 0,
     broadSkillsCount: discipline.broadSkills?.length || 0,
-  }));
+    isProfessional: discipline.isProfessional || false,
+    isManagement: discipline.isManagement || false,
+  };
+}
+
+/**
+ * Transform disciplines for list view, grouped by type (professional/management)
+ * @param {Array} disciplines - Raw discipline entities
+ * @param {number} [descriptionLimit=120] - Maximum description length
+ * @returns {{ items: DisciplineListItem[], groups: Object<string, DisciplineListItem[]>, groupOrder: string[] }}
+ */
+export function prepareDisciplinesList(disciplines, descriptionLimit = 120) {
+  const professional = [];
+  const management = [];
+
+  for (const discipline of disciplines) {
+    const item = disciplineToListItem(discipline, descriptionLimit);
+    if (discipline.isManagement) {
+      management.push(item);
+    } else {
+      // Default to professional if not explicitly management
+      professional.push(item);
+    }
+  }
+
+  // Groups in display order: professional first, then management
+  const groups = {};
+  const groupOrder = [];
+
+  if (professional.length > 0) {
+    groups.professional = professional;
+    groupOrder.push("professional");
+  }
+  if (management.length > 0) {
+    groups.management = management;
+    groupOrder.push("management");
+  }
+
+  // items maintains backward compatibility (professional first, then management)
+  const items = [...professional, ...management];
 
-  return { items };
+  return { items, groups, groupOrder };
 }
 
 /**

package/app/formatters/driver/dom.js

@@ -6,6 +6,7 @@ import { div, heading1, heading2, p, a, span } from "../../lib/render.js";
 import { createBackLink } from "../../components/nav.js";
 import { prepareDriverDetail } from "./shared.js";
 import { getConceptEmoji } from "../../model/levels.js";
+import { createJsonLdScript, driverToJsonLd } from "../json-ld.js";
 
 /**
  * Format driver detail as DOM elements
@@ -25,6 +26,8 @@ export function driverToDOM(
   const emoji = framework ? getConceptEmoji(framework, "driver") : "🎯";
   return div(
     { className: "detail-page driver-detail" },
+    // JSON-LD structured data
+    createJsonLdScript(driverToJsonLd(driver, { skills, behaviours })),
     // Header
     div(
       { className: "page-header" },

package/app/formatters/driver/microdata.js

@@ -0,0 +1,91 @@
+/**
+ * Driver formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with drivers.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  section,
+  ul,
+  escapeHtml,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareDriversList, prepareDriverDetail } from "./shared.js";
+
+/**
+ * Format driver list as microdata HTML
+ * @param {Array} drivers - Raw driver entities
+ * @returns {string} HTML with microdata
+ */
+export function driverListToMicrodata(drivers) {
+  const { items } = prepareDriversList(drivers);
+
+  const content = items
+    .map(
+      (
+        driver,
+      ) => `${openTag("article", { itemtype: "Driver", itemid: `#${driver.id}` })}
+${prop("h2", "name", driver.name)}
+${prop("p", "description", driver.truncatedDescription)}
+<p>Skills: ${driver.contributingSkillsCount} | Behaviours: ${driver.contributingBehavioursCount}</p>
+</article>`,
+    )
+    .join("\n");
+
+  return htmlDocument(
+    "Drivers",
+    `<main>
+<h1>Drivers</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format driver detail as microdata HTML
+ * @param {Object} driver - Raw driver entity
+ * @param {Object} context - Additional context
+ * @param {Array} context.skills - All skills
+ * @param {Array} context.behaviours - All behaviours
+ * @returns {string} HTML with microdata
+ */
+export function driverToMicrodata(driver, { skills, behaviours }) {
+  const view = prepareDriverDetail(driver, { skills, behaviours });
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Contributing skills - using contributingSkills property
+  if (view.contributingSkills.length > 0) {
+    const skillLinks = view.contributingSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "contributingSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Contributing Skills", ul(skillLinks), 2));
+  }
+
+  // Contributing behaviours - using contributingBehaviours property
+  if (view.contributingBehaviours.length > 0) {
+    const behaviourLinks = view.contributingBehaviours.map(
+      (b) =>
+        `${openTag("span", { itemprop: "contributingBehaviours" })}<a href="#${escapeHtml(b.id)}">${escapeHtml(b.name)}</a></span>`,
+    );
+    sections.push(section("Contributing Behaviours", ul(behaviourLinks), 2));
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Driver", itemid: `#${view.id}` })}
+${prop("h1", "name", view.name)}
+${metaTag("id", view.id)}
+${prop("p", "description", view.description)}
+${sections.join("\n")}
+</article>
+</main>`;
+
+  return htmlDocument(view.name, body);
+}

package/app/formatters/grade/dom.js

@@ -24,6 +24,7 @@ import {
 } from "../../model/levels.js";
 import { createJobBuilderButton } from "../../components/action-buttons.js";
 import { prepareGradeDetail } from "./shared.js";
+import { createJsonLdScript, gradeToJsonLd } from "../json-ld.js";
 
 /**
  * Format grade detail as DOM elements
@@ -38,6 +39,8 @@ export function gradeToDOM(grade, { framework, showBackLink = true } = {}) {
   const emoji = framework ? getConceptEmoji(framework, "grade") : "📊";
   return div(
     { className: "detail-page grade-detail" },
+    // JSON-LD structured data
+    createJsonLdScript(gradeToJsonLd(grade)),
     // Header
     div(
       { className: "page-header" },

package/app/formatters/grade/microdata.js

@@ -0,0 +1,151 @@
+/**
+ * Grade formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with grades.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  linkTag,
+  section,
+  dl,
+  escapeHtml,
+  formatLevelName,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareGradesList, prepareGradeDetail } from "./shared.js";
+
+/**
+ * Format grade list as microdata HTML
+ * @param {Array} grades - Raw grade entities
+ * @returns {string} HTML with microdata
+ */
+export function gradeListToMicrodata(grades) {
+  const { items } = prepareGradesList(grades);
+
+  const content = items
+    .map(
+      (g) => `${openTag("article", { itemtype: "Grade", itemid: `#${g.id}` })}
+${prop("h2", "id", g.id)}
+<p>${escapeHtml(g.displayName)}</p>
+${g.typicalExperienceRange ? prop("p", "typicalExperienceRange", g.typicalExperienceRange) : ""}
+${metaTag("ordinalRank", String(g.ordinalRank))}
+</article>`,
+    )
+    .join("\n");
+
+  return htmlDocument(
+    "Grades",
+    `<main>
+<h1>Grades</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format grade detail as microdata HTML
+ * @param {Object} grade - Raw grade entity
+ * @returns {string} HTML with microdata
+ */
+export function gradeToMicrodata(grade) {
+  const view = prepareGradeDetail(grade);
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Titles section
+  if (view.professionalTitle || view.managementTitle) {
+    const titlePairs = [];
+    if (view.professionalTitle) {
+      titlePairs.push({
+        term: "Professional Track",
+        definition: view.professionalTitle,
+        itemprop: "professionalTitle",
+      });
+    }
+    if (view.managementTitle) {
+      titlePairs.push({
+        term: "Management Track",
+        definition: view.managementTitle,
+        itemprop: "managementTitle",
+      });
+    }
+    sections.push(section("Titles", dl(titlePairs), 2));
+  }
+
+  // Base skill levels - using BaseSkillLevels itemtype
+  if (view.baseSkillLevels && Object.keys(view.baseSkillLevels).length > 0) {
+    const levelPairs = Object.entries(view.baseSkillLevels).map(
+      ([type, level]) => ({
+        term: formatLevelName(type),
+        definition: formatLevelName(level),
+        itemprop: type,
+      }),
+    );
+    sections.push(
+      section(
+        "Base Skill Levels",
+        `${openTag("div", { itemtype: "BaseSkillLevels", itemprop: "baseSkillLevels" })}
+${dl(levelPairs)}
+</div>`,
+        2,
+      ),
+    );
+  }
+
+  // Base behaviour maturity - link to BehaviourMaturity
+  if (
+    view.baseBehaviourMaturity &&
+    Object.keys(view.baseBehaviourMaturity).length > 0
+  ) {
+    const maturityPairs = Object.entries(view.baseBehaviourMaturity).map(
+      ([type, maturity]) => ({
+        term: formatLevelName(type),
+        definition: formatLevelName(maturity),
+      }),
+    );
+    // Handle both single value and object cases
+    const maturityContent =
+      typeof grade.baseBehaviourMaturity === "string"
+        ? `${linkTag("baseBehaviourMaturity", `#${grade.baseBehaviourMaturity}`)}
+<p>${formatLevelName(grade.baseBehaviourMaturity)}</p>`
+        : dl(maturityPairs);
+    sections.push(section("Base Behaviour Maturity", maturityContent, 2));
+  }
+
+  // Expectations - using GradeExpectations itemtype
+  if (view.expectations && Object.keys(view.expectations).length > 0) {
+    const expectationPairs = Object.entries(view.expectations).map(
+      ([key, value]) => ({
+        term: formatLevelName(key),
+        definition: value,
+        itemprop: key,
+      }),
+    );
+    sections.push(
+      section(
+        "Expectations",
+        `${openTag("div", { itemtype: "GradeExpectations", itemprop: "expectations" })}
+${dl(expectationPairs)}
+</div>`,
+        2,
+      ),
+    );
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Grade", itemid: `#${view.id}` })}
+<h1>${prop("span", "id", view.id)} — ${escapeHtml(view.displayName)}</h1>
+${metaTag("ordinalRank", String(view.ordinalRank))}
+${view.typicalExperienceRange ? prop("p", "typicalExperienceRange", `Experience: ${view.typicalExperienceRange}`) : ""}
+${sections.join("\n")}
+</article>
+</main>`;
+
+  return htmlDocument(`${view.id} - ${view.displayName}`, body);
+}