@forwardimpact/pathway 0.25.15 → 0.25.21

package/src/formatters/behaviour/microdata.js

@@ -1,106 +0,0 @@
-/**
- * Behaviour formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with behaviour.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/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/src/formatters/discipline/microdata.js

@@ -1,117 +0,0 @@
-/**
- * Discipline formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with discipline.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/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/src/formatters/driver/microdata.js

@@ -1,91 +0,0 @@
-/**
- * Driver formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with drivers.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/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/src/formatters/level/microdata.js

@@ -1,141 +0,0 @@
-/**
- * Level formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with levels.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  metaTag,
-  linkTag,
-  section,
-  dl,
-  escapeHtml,
-  formatLevelName,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareLevelsList, prepareLevelDetail } from "./shared.js";
-
-/**
- * Format level list as microdata HTML
- * @param {Array} levels - Raw level entities
- * @returns {string} HTML with microdata
- */
-export function levelListToMicrodata(levels) {
-  const { items } = prepareLevelsList(levels);
-
-  const content = items
-    .map(
-      (g) => `${openTag("article", { itemtype: "Level", 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(
-    "Levels",
-    `<main>
-<h1>Levels</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format level detail as microdata HTML
- * @param {Object} level - Raw level entity
- * @returns {string} HTML with microdata
- */
-export function levelToMicrodata(level) {
-  const view = prepareLevelDetail(level);
-
-  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 proficiencies - using BaseSkillProficiencies itemtype
-  if (
-    view.baseSkillProficiencies &&
-    Object.keys(view.baseSkillProficiencies).length > 0
-  ) {
-    const levelPairs = Object.entries(view.baseSkillProficiencies).map(
-      ([type, level]) => ({
-        term: formatLevelName(type),
-        definition: formatLevelName(level),
-        itemprop: type,
-      }),
-    );
-    sections.push(
-      section(
-        "Base Skill Proficiencies",
-        `${openTag("div", { itemtype: "BaseSkillProficiencies", itemprop: "baseSkillProficiencies" })}
-${dl(levelPairs)}
-</div>`,
-        2,
-      ),
-    );
-  }
-
-  // Base behaviour maturity - link to BehaviourMaturity
-  if (view.baseBehaviourMaturity) {
-    const maturityContent = `${linkTag("baseBehaviourMaturity", `#${level.baseBehaviourMaturity}`)}
-<p>${formatLevelName(level.baseBehaviourMaturity)}</p>`;
-    sections.push(section("Base Behaviour Maturity", maturityContent, 2));
-  }
-
-  // Expectations - using LevelExpectations 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: "LevelExpectations", itemprop: "expectations" })}
-${dl(expectationPairs)}
-</div>`,
-        2,
-      ),
-    );
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Level", 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);
-}

package/src/formatters/microdata-shared.js

@@ -1,184 +0,0 @@
-/**
- * Shared microdata HTML utilities
- *
- * Helper functions for generating clean, class-less HTML with microdata attributes
- * aligned with the RDF schema at https://www.forwardimpact.team/schema/rdf/
- */
-
-const VOCAB_BASE = "https://www.forwardimpact.team/schema/rdf/";
-
-/**
- * Create an opening tag with microdata attributes
- * @param {string} tag - HTML tag name
- * @param {Object} [attrs] - Optional attributes
- * @param {string} [attrs.itemtype] - Microdata type (without vocab prefix)
- * @param {string} [attrs.itemprop] - Microdata property name
- * @param {string} [attrs.itemid] - Microdata item ID
- * @returns {string}
- */
-export function openTag(tag, attrs = {}) {
-  const parts = [tag];
-
-  if (attrs.itemtype) {
-    parts.push(`itemscope`);
-    parts.push(`itemtype="${VOCAB_BASE}${attrs.itemtype}"`);
-  }
-
-  if (attrs.itemprop) {
-    parts.push(`itemprop="${attrs.itemprop}"`);
-  }
-
-  if (attrs.itemid) {
-    parts.push(`itemid="${attrs.itemid}"`);
-  }
-
-  return `<${parts.join(" ")}>`;
-}
-
-/**
- * Create a self-closing meta element with microdata
- * @param {string} itemprop - Property name
- * @param {string} content - Content value
- * @returns {string}
- */
-export function metaTag(itemprop, content) {
-  return `<meta itemprop="${itemprop}" content="${escapeAttr(content)}">`;
-}
-
-/**
- * Create a link element with microdata
- * @param {string} itemprop - Property name
- * @param {string} href - Link target
- * @returns {string}
- */
-export function linkTag(itemprop, href) {
-  return `<link itemprop="${itemprop}" href="${escapeAttr(href)}">`;
-}
-
-/**
- * Wrap content in an element with itemprop
- * @param {string} tag - HTML tag name
- * @param {string} itemprop - Property name
- * @param {string} content - Content to wrap
- * @returns {string}
- */
-export function prop(tag, itemprop, content) {
-  return `<${tag} itemprop="${itemprop}">${escapeHtml(content)}</${tag}>`;
-}
-
-/**
- * Wrap raw HTML content in an element with itemprop (no escaping)
- * @param {string} tag - HTML tag name
- * @param {string} itemprop - Property name
- * @param {string} html - HTML content to wrap
- * @returns {string}
- */
-export function propRaw(tag, itemprop, html) {
-  return `<${tag} itemprop="${itemprop}">${html}</${tag}>`;
-}
-
-/**
- * Create a section with optional heading
- * @param {string} heading - Section heading text
- * @param {string} content - Section content
- * @param {number} [level=2] - Heading level (2-6)
- * @returns {string}
- */
-export function section(heading, content, level = 2) {
-  const hTag = `h${Math.min(Math.max(level, 1), 6)}`;
-  return `<section>
-<${hTag}>${escapeHtml(heading)}</${hTag}>
-${content}
-</section>`;
-}
-
-/**
- * Create an unordered list
- * @param {string[]} items - List items (already HTML)
- * @param {string} [itemprop] - Optional property for list items
- * @returns {string}
- */
-export function ul(items, itemprop) {
-  if (!items.length) return "";
-  const lis = items
-    .map((item) =>
-      itemprop ? `<li itemprop="${itemprop}">${item}</li>` : `<li>${item}</li>`,
-    )
-    .join("\n");
-  return `<ul>\n${lis}\n</ul>`;
-}
-
-/**
- * Create a definition list from key-value pairs
- * @param {Array<{term: string, definition: string, itemprop?: string}>} pairs
- * @returns {string}
- */
-export function dl(pairs) {
-  if (!pairs.length) return "";
-  const content = pairs
-    .map(({ term, definition, itemprop }) => {
-      const dd = itemprop
-        ? `<dd itemprop="${itemprop}">${escapeHtml(definition)}</dd>`
-        : `<dd>${escapeHtml(definition)}</dd>`;
-      return `<dt>${escapeHtml(term)}</dt>\n${dd}`;
-    })
-    .join("\n");
-  return `<dl>\n${content}\n</dl>`;
-}
-
-/**
- * Escape HTML special characters
- * @param {string} str
- * @returns {string}
- */
-export function escapeHtml(str) {
-  if (str == null) return "";
-  return String(str)
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-/**
- * Escape attribute value
- * @param {string} str
- * @returns {string}
- */
-export function escapeAttr(str) {
-  if (str == null) return "";
-  return String(str)
-    .replace(/&/g, "&amp;")
-    .replace(/"/g, "&quot;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-/**
- * Format level name for display (capitalize, replace underscores)
- * @param {string} level
- * @returns {string}
- */
-export function formatLevelName(level) {
-  if (!level) return "";
-  return level.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-
-/**
- * Generate a full microdata HTML document
- * @param {string} title - Document title
- * @param {string} body - Body content
- * @returns {string}
- */
-export function htmlDocument(title, body) {
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>${escapeHtml(title)}</title>
-</head>
-<body>
-${body}
-</body>
-</html>`;
-}