@glyphjs/compiler 0.1.0

package/dist/index.js

@@ -0,0 +1,794 @@
+import { parseGlyphMarkdown } from '@glyphjs/parser';
+import { generateBlockId, generateDocumentId, resolveBlockIdCollisions } from '@glyphjs/ir';
+import { parse } from 'yaml';
+import { componentSchemas } from '@glyphjs/schemas';
+
+// src/compile.ts
+
+// src/inline.ts
+function convertPhrasingContent(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    const converted = convertSingleNode(node);
+    if (converted) {
+      result.push(converted);
+    }
+  }
+  return result;
+}
+function convertSingleNode(node) {
+  switch (node.type) {
+    case "text":
+      return { type: "text", value: node.value };
+    case "strong":
+      return {
+        type: "strong",
+        children: convertPhrasingContent(node.children)
+      };
+    case "emphasis":
+      return {
+        type: "emphasis",
+        children: convertPhrasingContent(node.children)
+      };
+    case "delete":
+      return {
+        type: "delete",
+        children: convertPhrasingContent(node.children)
+      };
+    case "inlineCode":
+      return { type: "inlineCode", value: node.value };
+    case "link": {
+      const linkNode = {
+        type: "link",
+        url: node.url,
+        children: convertPhrasingContent(node.children)
+      };
+      if (node.title != null) {
+        linkNode.title = node.title;
+      }
+      return linkNode;
+    }
+    case "image": {
+      const imgNode = {
+        type: "image",
+        src: node.url
+      };
+      if (node.alt != null) {
+        imgNode.alt = node.alt;
+      }
+      if (node.title != null) {
+        imgNode.title = node.title;
+      }
+      return imgNode;
+    }
+    case "break":
+      return { type: "break" };
+    default: {
+      const unknown = node;
+      if (typeof unknown["value"] === "string") {
+        return { type: "text", value: unknown["value"] };
+      }
+      return null;
+    }
+  }
+}
+
+// src/diagnostics.ts
+function createDiagnostic(source, severity, code, message, position, details) {
+  const diag = { severity, code, message, source };
+  if (position) {
+    diag.position = position;
+  }
+  if (details !== void 0) {
+    diag.details = details;
+  }
+  return diag;
+}
+function createSchemaError(componentType, message, position, details) {
+  return createDiagnostic(
+    "schema",
+    "error",
+    "SCHEMA_VALIDATION_FAILED",
+    `Schema validation failed for ui:${componentType}: ${message}`,
+    position,
+    details
+  );
+}
+function createUnknownComponentInfo(componentType, position) {
+  return createDiagnostic(
+    "compiler",
+    "info",
+    "UNKNOWN_COMPONENT_TYPE",
+    `Unknown component type "ui:${componentType}". Block preserved as-is.`,
+    position
+  );
+}
+function createYamlError(componentType, yamlError, position) {
+  return createDiagnostic(
+    "parser",
+    "error",
+    "YAML_PARSE_ERROR",
+    `YAML parse error in ui:${componentType}: ${yamlError}`,
+    position
+  );
+}
+
+// src/ast-to-ir.ts
+var DEFAULT_POSITION = {
+  start: { line: 0, column: 0 },
+  end: { line: 0, column: 0 }
+};
+function isGlyphUIBlock(node) {
+  return node.type === "glyphUIBlock";
+}
+function translateNode(node, ctx) {
+  if (isGlyphUIBlock(node)) {
+    return translateGlyphUIBlock(node, ctx);
+  }
+  return translateMdastNode(node, ctx);
+}
+function translateGlyphUIBlock(node, ctx) {
+  const componentType = node.componentType;
+  const blockType = `ui:${componentType}`;
+  const position = node.position ?? DEFAULT_POSITION;
+  const blockDiagnostics = [];
+  const blockId = node.glyphId ? node.glyphId : generateBlockId(ctx.documentId, blockType, node.rawYaml);
+  if (node.glyphId) {
+    ctx.blockIdMap.set(node.glyphId, blockId);
+  }
+  if (node.yamlError) {
+    const diag = createYamlError(componentType, node.yamlError, position);
+    blockDiagnostics.push(diag);
+    ctx.diagnostics.push(diag);
+  }
+  let data = node.parsedData ?? {};
+  if (node.parsedData) {
+    const schema = componentSchemas.get(componentType);
+    if (schema) {
+      const result = schema.safeParse(node.parsedData);
+      if (!result.success) {
+        const zodErrors = result.error.issues.map(
+          (issue) => `${issue.path.join(".")}: ${issue.message}`
+        ).join("; ");
+        const diag = createSchemaError(componentType, zodErrors, position, result.error.issues);
+        blockDiagnostics.push(diag);
+        ctx.diagnostics.push(diag);
+        data = node.parsedData;
+      } else {
+        data = result.data;
+      }
+    } else {
+      const diag = createUnknownComponentInfo(componentType, position);
+      blockDiagnostics.push(diag);
+      ctx.diagnostics.push(diag);
+    }
+  }
+  if (node.refs && node.refs.length > 0) {
+    processRefs(node.refs, blockId, ctx);
+  }
+  const block = {
+    id: blockId,
+    type: blockType,
+    data,
+    position
+  };
+  if (blockDiagnostics.length > 0) {
+    block.diagnostics = blockDiagnostics;
+  }
+  return block;
+}
+function processRefs(refs, sourceBlockId, ctx) {
+  for (const ref of refs) {
+    const reference = {
+      id: generateBlockId(ctx.documentId, "ref", `${sourceBlockId}->${ref.target}`),
+      type: ref.type ?? "navigates-to",
+      sourceBlockId,
+      targetBlockId: ref.target
+    };
+    if (ref.label) {
+      reference.label = ref.label;
+    }
+    if (ref.sourceAnchor) {
+      reference.sourceAnchor = ref.sourceAnchor;
+    }
+    if (ref.targetAnchor) {
+      reference.targetAnchor = ref.targetAnchor;
+    }
+    if (ref.bidirectional) {
+      reference.bidirectional = ref.bidirectional;
+    }
+    reference.unresolved = true;
+    ctx.references.push(reference);
+  }
+}
+function translateMdastNode(node, ctx) {
+  const position = node.position ?? DEFAULT_POSITION;
+  switch (node.type) {
+    case "heading":
+      return translateHeading(node, position, ctx);
+    case "paragraph":
+      return translateParagraph(node, position, ctx);
+    case "list":
+      return translateList(node, position, ctx);
+    case "code":
+      return translateCode(node, position, ctx);
+    case "blockquote":
+      return translateBlockquote(node, position, ctx);
+    case "image":
+      return translateImage(node, position, ctx);
+    case "thematicBreak":
+      return translateThematicBreak(position, ctx);
+    case "html":
+      return translateHtml(node, position, ctx);
+    case "yaml":
+      return null;
+    default:
+      return null;
+  }
+}
+function translateHeading(node, position, ctx) {
+  const depth = node["depth"] ?? 1;
+  const children = convertPhrasingContent(node.children ?? []);
+  const content = inlineNodesToText(children);
+  return {
+    id: generateBlockId(ctx.documentId, "heading", content),
+    type: "heading",
+    data: { depth, children },
+    position
+  };
+}
+function translateParagraph(node, position, ctx) {
+  const children = convertPhrasingContent(node.children ?? []);
+  const content = inlineNodesToText(children);
+  return {
+    id: generateBlockId(ctx.documentId, "paragraph", content),
+    type: "paragraph",
+    data: { children },
+    position
+  };
+}
+function translateList(node, position, ctx) {
+  const ordered = node["ordered"] ?? false;
+  const start = ordered ? node["start"] ?? 1 : void 0;
+  const items = translateListItems(node.children ?? []);
+  const content = listDataToText({ items });
+  const data = { ordered, items };
+  if (start !== void 0) {
+    data.start = start;
+  }
+  return {
+    id: generateBlockId(ctx.documentId, "list", content),
+    type: "list",
+    data,
+    position
+  };
+}
+function translateListItems(listItemNodes) {
+  const items = [];
+  for (const itemNode of listItemNodes) {
+    if (itemNode.type !== "listItem") continue;
+    const itemChildren = itemNode.children ?? [];
+    let inlineChildren = [];
+    let subList;
+    for (const child of itemChildren) {
+      if (child.type === "paragraph") {
+        inlineChildren = convertPhrasingContent(child.children ?? []);
+      } else if (child.type === "list") {
+        const subOrdered = child["ordered"] ?? false;
+        const subStart = subOrdered ? child["start"] ?? 1 : void 0;
+        const subItems = translateListItems(child.children ?? []);
+        subList = { ordered: subOrdered, items: subItems };
+        if (subStart !== void 0) {
+          subList.start = subStart;
+        }
+      }
+    }
+    const item = { children: inlineChildren };
+    if (subList) {
+      item.subList = subList;
+    }
+    items.push(item);
+  }
+  return items;
+}
+function translateCode(node, position, ctx) {
+  const value = node.value ?? "";
+  const language = node["lang"] ?? void 0;
+  const meta = node["meta"] ?? void 0;
+  const data = { value };
+  if (language) {
+    data["language"] = language;
+  }
+  if (meta) {
+    data["meta"] = meta;
+  }
+  return {
+    id: generateBlockId(ctx.documentId, "code", value),
+    type: "code",
+    data,
+    position
+  };
+}
+function translateBlockquote(node, position, ctx) {
+  const allInlineNodes = [];
+  for (const child of node.children ?? []) {
+    if (child.type === "paragraph") {
+      const inlines = convertPhrasingContent(child.children ?? []);
+      allInlineNodes.push(...inlines);
+    }
+  }
+  const content = inlineNodesToText(allInlineNodes);
+  return {
+    id: generateBlockId(ctx.documentId, "blockquote", content),
+    type: "blockquote",
+    data: { children: allInlineNodes },
+    position
+  };
+}
+function translateImage(node, position, ctx) {
+  const src = node["url"] ?? "";
+  const alt = node["alt"] ?? void 0;
+  const title = node["title"] ?? void 0;
+  const data = { src };
+  if (alt) {
+    data["alt"] = alt;
+  }
+  if (title) {
+    data["title"] = title;
+  }
+  return {
+    id: generateBlockId(ctx.documentId, "image", src),
+    type: "image",
+    data,
+    position
+  };
+}
+function translateThematicBreak(position, ctx) {
+  return {
+    id: generateBlockId(ctx.documentId, "thematic-break", "---"),
+    type: "thematic-break",
+    data: {},
+    position
+  };
+}
+function translateHtml(node, position, ctx) {
+  const value = node.value ?? "";
+  return {
+    id: generateBlockId(ctx.documentId, "html", value),
+    type: "html",
+    data: { value },
+    position
+  };
+}
+function inlineNodesToText(nodes) {
+  return nodes.map((node) => {
+    switch (node.type) {
+      case "text":
+        return node.value;
+      case "inlineCode":
+        return node.value;
+      case "strong":
+      case "emphasis":
+      case "delete":
+        return inlineNodesToText(node.children);
+      case "link":
+        return inlineNodesToText(node.children);
+      case "image":
+        return node.alt ?? "";
+      case "break":
+        return "\n";
+      default:
+        return "";
+    }
+  }).join("");
+}
+function listDataToText(data) {
+  return data.items.map((item) => {
+    let text = inlineNodesToText(item.children);
+    if (item.subList) {
+      text += "\n" + listDataToText(item.subList);
+    }
+    return text;
+  }).join("\n");
+}
+var GLYPH_LINK_PREFIX = "#glyph:";
+function extractInlineReferences(block, documentId) {
+  const references = [];
+  const inlineNodes = extractInlineNodes(block);
+  for (const node of inlineNodes) {
+    if (node.type === "link" && node.url.startsWith(GLYPH_LINK_PREFIX)) {
+      const targetBlockId = node.url.slice(GLYPH_LINK_PREFIX.length);
+      if (!targetBlockId) continue;
+      const label = inlineNodesToPlainText(node.children);
+      const reference = {
+        id: generateBlockId(documentId, "ref", `${block.id}->${targetBlockId}`),
+        type: "navigates-to",
+        sourceBlockId: block.id,
+        targetBlockId,
+        unresolved: true
+      };
+      if (label) {
+        reference.label = label;
+      }
+      references.push(reference);
+    }
+  }
+  return references;
+}
+function extractAllInlineReferences(blocks, documentId) {
+  const references = [];
+  for (const block of blocks) {
+    const blockRefs = extractInlineReferences(block, documentId);
+    references.push(...blockRefs);
+    if (block.children) {
+      const childRefs = extractAllInlineReferences(block.children, documentId);
+      references.push(...childRefs);
+    }
+  }
+  return references;
+}
+function resolveReferences(references, blocks, diagnostics) {
+  const blockIdSet = collectAllBlockIds(blocks);
+  for (const ref of references) {
+    if (blockIdSet.has(ref.targetBlockId)) {
+      ref.unresolved = false;
+    } else {
+      ref.unresolved = true;
+      diagnostics.push(
+        createDiagnostic(
+          "compiler",
+          "warning",
+          "UNRESOLVED_REFERENCE",
+          `Reference target "${ref.targetBlockId}" was not found in the document.`
+        )
+      );
+    }
+  }
+}
+function collectAllBlockIds(blocks) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    ids.add(block.id);
+    if (block.children) {
+      for (const id of collectAllBlockIds(block.children)) {
+        ids.add(id);
+      }
+    }
+  }
+  return ids;
+}
+function validateGlyphIdUniqueness(blockIdMap, blocks, diagnostics) {
+  const glyphIdOccurrences = /* @__PURE__ */ new Map();
+  for (const glyphId of blockIdMap.keys()) {
+    const count = countBlocksWithGlyphId(blocks, glyphId);
+    glyphIdOccurrences.set(glyphId, count);
+  }
+  for (const [glyphId, count] of glyphIdOccurrences) {
+    if (count > 1) {
+      diagnostics.push(
+        createDiagnostic(
+          "compiler",
+          "error",
+          "DUPLICATE_GLYPH_ID",
+          `Duplicate glyph-id "${glyphId}" found on ${String(count)} blocks. Block IDs must be unique within a document.`
+        )
+      );
+    }
+  }
+}
+function countBlocksWithGlyphId(blocks, glyphId) {
+  let count = 0;
+  for (const block of blocks) {
+    if (block.id === glyphId) {
+      count++;
+    }
+  }
+  return count;
+}
+function extractInlineNodes(block) {
+  const data = block.data;
+  const nodes = [];
+  if (Array.isArray(data["children"])) {
+    nodes.push(...data["children"]);
+  }
+  if (Array.isArray(data["items"])) {
+    for (const item of data["items"]) {
+      if (Array.isArray(item.children)) {
+        nodes.push(...item.children);
+      }
+    }
+  }
+  return nodes;
+}
+function inlineNodesToPlainText(nodes) {
+  return nodes.map((node) => {
+    switch (node.type) {
+      case "text":
+        return node.value;
+      case "inlineCode":
+        return node.value;
+      case "strong":
+      case "emphasis":
+      case "delete":
+        return inlineNodesToPlainText(node.children);
+      case "link":
+        return inlineNodesToPlainText(node.children);
+      case "image":
+        return node.alt ?? "";
+      case "break":
+        return "\n";
+      default:
+        return "";
+    }
+  }).join("");
+}
+function compileContainerBlocks(blocks, ctx) {
+  for (const block of blocks) {
+    if (block.type === "ui:tabs") {
+      compileTabsBlock(block, ctx);
+    } else if (block.type === "ui:steps") {
+      compileStepsBlock(block, ctx);
+    }
+  }
+}
+function compileTabsBlock(block, ctx) {
+  const data = block.data;
+  const tabs = data["tabs"];
+  if (!Array.isArray(tabs)) return;
+  const allChildren = [];
+  for (const tab of tabs) {
+    if (typeof tab.content !== "string") continue;
+    const childBlocks = parseContentToBlocks(tab.content, block, ctx);
+    allChildren.push(...childBlocks);
+  }
+  if (allChildren.length > 0) {
+    block.children = allChildren;
+  }
+}
+function compileStepsBlock(block, ctx) {
+  const data = block.data;
+  const steps = data["steps"];
+  if (!Array.isArray(steps)) return;
+  const allChildren = [];
+  for (const step of steps) {
+    if (typeof step.content !== "string") continue;
+    const childBlocks = parseContentToBlocks(step.content, block, ctx);
+    allChildren.push(...childBlocks);
+  }
+  if (allChildren.length > 0) {
+    block.children = allChildren;
+  }
+}
+function parseContentToBlocks(content, parentBlock, ctx) {
+  const ast = parseGlyphMarkdown(content);
+  const blocks = [];
+  for (const child of ast.children) {
+    if (child.type === "glyphUIBlock") {
+      ctx.diagnostics.push(
+        createDiagnostic(
+          "compiler",
+          "warning",
+          "NESTED_UI_COMPONENT",
+          `Nested ui: component found inside container block "${parentBlock.id}". Nested ui: components inside tabs/steps are not supported in v1 and will be ignored.`,
+          child.position
+        )
+      );
+      continue;
+    }
+    const block = translateNode(child, ctx);
+    if (block) {
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+function hasNestedUiBlocks(content) {
+  return /```ui:/m.test(content);
+}
+function validateContainerBlocks(blocks, diagnostics) {
+  for (const block of blocks) {
+    if (block.type === "ui:tabs") {
+      validateTabsData(block, diagnostics);
+    } else if (block.type === "ui:steps") {
+      validateStepsData(block, diagnostics);
+    }
+  }
+}
+function validateTabsData(block, _diagnostics) {
+  const data = block.data;
+  const tabs = data["tabs"];
+  if (!Array.isArray(tabs) || tabs.length === 0) {
+    return;
+  }
+  for (const tab of tabs) {
+    if (!tab.label) {
+      _diagnostics.push(
+        createDiagnostic(
+          "compiler",
+          "warning",
+          "MISSING_TAB_LABEL",
+          `A tab in block "${block.id}" is missing a label.`,
+          block.position
+        )
+      );
+    }
+  }
+}
+function validateStepsData(block, _diagnostics) {
+  const data = block.data;
+  const steps = data["steps"];
+  if (!Array.isArray(steps) || steps.length === 0) {
+    return;
+  }
+  for (const step of steps) {
+    if (!step.title) {
+      _diagnostics.push(
+        createDiagnostic(
+          "compiler",
+          "warning",
+          "MISSING_STEP_TITLE",
+          `A step in block "${block.id}" is missing a title.`,
+          block.position
+        )
+      );
+    }
+  }
+}
+
+// src/compile.ts
+function compile(markdown, options) {
+  const diagnostics = [];
+  const ast = parseGlyphMarkdown(markdown);
+  const { metadata, layout, frontmatterGlyphId } = extractFrontmatter(ast.children, diagnostics);
+  const documentId = options?.documentId ?? generateDocumentId({
+    glyphId: frontmatterGlyphId,
+    filePath: options?.filePath,
+    content: markdown
+  });
+  if (options?.filePath && !metadata.sourceFile) {
+    metadata.sourceFile = options.filePath;
+  }
+  const references = [];
+  const ctx = {
+    documentId,
+    diagnostics,
+    references,
+    blockIdMap: /* @__PURE__ */ new Map()
+  };
+  const blocks = [];
+  for (const child of ast.children) {
+    const block = translateNode(child, ctx);
+    if (block) {
+      blocks.push(block);
+    }
+  }
+  compileContainerBlocks(blocks, ctx);
+  validateContainerBlocks(blocks, diagnostics);
+  inferMetadata(metadata, blocks);
+  const blockIds = blocks.map((b) => b.id);
+  const resolvedIds = resolveBlockIdCollisions(blockIds);
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const resolvedId = resolvedIds[i];
+    if (block && resolvedId) {
+      block.id = resolvedId;
+    }
+  }
+  validateGlyphIdUniqueness(ctx.blockIdMap, blocks, diagnostics);
+  const inlineRefs = extractAllInlineReferences(blocks, documentId);
+  references.push(...inlineRefs);
+  resolveReferences(references, blocks, diagnostics);
+  const ir = {
+    version: "1.0.0",
+    id: documentId,
+    metadata,
+    blocks,
+    references,
+    layout
+  };
+  const hasErrors = diagnostics.some((d) => d.severity === "error");
+  return { ir, diagnostics, hasErrors };
+}
+function extractFrontmatter(children, diagnostics) {
+  const metadata = {};
+  let layout = { mode: "document", spacing: "normal" };
+  let frontmatterGlyphId;
+  const firstChild = children[0];
+  if (firstChild && firstChild.type === "yaml" && typeof firstChild.value === "string") {
+    try {
+      const parsed = parse(firstChild.value);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const fm = parsed;
+        if (typeof fm["glyph-id"] === "string") {
+          frontmatterGlyphId = fm["glyph-id"];
+        }
+        if (typeof fm["title"] === "string") {
+          metadata.title = fm["title"];
+        }
+        if (typeof fm["description"] === "string") {
+          metadata.description = fm["description"];
+        }
+        if (Array.isArray(fm["authors"])) {
+          metadata.authors = fm["authors"].filter(
+            (a) => typeof a === "string"
+          );
+        }
+        if (typeof fm["createdAt"] === "string") {
+          metadata.createdAt = fm["createdAt"];
+        }
+        if (Array.isArray(fm["tags"])) {
+          metadata.tags = fm["tags"].filter(
+            (t) => typeof t === "string"
+          );
+        }
+        if (fm["layout"] && typeof fm["layout"] === "object" && !Array.isArray(fm["layout"])) {
+          const rawLayout = fm["layout"];
+          layout = {
+            mode: isLayoutMode(rawLayout["mode"]) ? rawLayout["mode"] : "document",
+            spacing: isLayoutSpacing(rawLayout["spacing"]) ? rawLayout["spacing"] : "normal"
+          };
+          if (typeof rawLayout["columns"] === "number") {
+            layout.columns = rawLayout["columns"];
+          }
+          if (typeof rawLayout["maxWidth"] === "string") {
+            layout.maxWidth = rawLayout["maxWidth"];
+          }
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      diagnostics.push(
+        createDiagnostic(
+          "parser",
+          "error",
+          "FRONTMATTER_PARSE_ERROR",
+          `Failed to parse frontmatter YAML: ${message}`,
+          firstChild.position
+        )
+      );
+    }
+  }
+  return { metadata, layout, frontmatterGlyphId };
+}
+function isLayoutMode(value) {
+  return value === "document" || value === "dashboard" || value === "presentation";
+}
+function isLayoutSpacing(value) {
+  return value === "compact" || value === "normal" || value === "relaxed";
+}
+function inferMetadata(metadata, blocks) {
+  if (!metadata.title) {
+    const firstHeading = blocks.find(
+      (b) => b.type === "heading" && b.data["depth"] === 1
+    );
+    if (firstHeading) {
+      const data = firstHeading.data;
+      if (data.children) {
+        metadata.title = data.children.map((node) => {
+          if ("value" in node && typeof node.value === "string") {
+            return node.value;
+          }
+          return "";
+        }).join("");
+      }
+    }
+  }
+  if (!metadata.description) {
+    const firstParagraph = blocks.find((b) => b.type === "paragraph");
+    if (firstParagraph) {
+      const data = firstParagraph.data;
+      if (data.children) {
+        metadata.description = data.children.map((node) => {
+          if ("value" in node && typeof node.value === "string") {
+            return node.value;
+          }
+          return "";
+        }).join("");
+      }
+    }
+  }
+}
+
+export { compile, compileContainerBlocks, convertPhrasingContent, createDiagnostic, createSchemaError, createUnknownComponentInfo, createYamlError, extractAllInlineReferences, extractInlineReferences, hasNestedUiBlocks, resolveReferences, translateNode, validateContainerBlocks, validateGlyphIdUniqueness };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map