@jxsuite/parser 0.35.1 → 1.1.0

package/src/md-html.ts

@@ -1,49 +1,12 @@
 /**
- * Md-html — browser-safe markdown → sanitized HTML string
+ * Md-html — compatibility shim.
  *
- * Small display pipeline for rendering untrusted markdown (e.g. LLM chat output) as
- * HTML: remark-parse + remark-gfm → remark-rehype (raw HTML disabled) → rehype-sanitize
- * (default schema: strips scripts, event handlers, javascript:/data: URLs) → stringify.
- *
- * Unlike `./md.ts` this module has no node-only imports, so it is safe for the studio
- * bundle. It intentionally produces an HTML *string*, not Jx nodes — use
- * `@jxsuite/parser/markdown` for markdown → Jx document transpilation.
+ * The browser-safe markdown → sanitized HTML pipeline moved to `@jxsuite/markup/md-html`;
+ * this module re-exports it so the parser's historical `@jxsuite/parser/md-html`
+ * entrypoint keeps working for downstream consumers.
  *
  * @module @jxsuite/parser/md-html
  * @license MIT
  */
 
-import rehypeSanitize from "rehype-sanitize";
-import rehypeStringify from "rehype-stringify";
-import remarkGfm from "remark-gfm";
-import remarkParse from "remark-parse";
-import remarkRehype from "remark-rehype";
-import { unified } from "unified";
-
-/**
- * Minimal structural surface of the unified processor used here — same rationale as
- * `UnifiedProcessor` in ./types.ts (oxlint sees the ESM-only unified types as `any`), plus
- * `processSync` which the shared type doesn't carry.
- */
-interface MdHtmlProcessor {
-  use: (plugin: unknown, ...options: unknown[]) => MdHtmlProcessor;
-  processSync: (source: string) => { toString: () => string };
-}
-
-const processor = (unified as unknown as () => MdHtmlProcessor)()
-  .use(remarkParse)
-  .use(remarkGfm)
-  .use(remarkRehype)
-  .use(rehypeSanitize)
-  .use(rehypeStringify);
-
-/**
- * Convert markdown source to a sanitized HTML string (GFM tables/strikethrough/task lists
- * supported). Raw HTML in the source is dropped, not passed through.
- *
- * @param {string} markdown
- * @returns {string}
- */
-export function markdownToHtml(markdown: string): string {
-  return String(processor.processSync(markdown));
-}
+export { markdownToHtml } from "@jxsuite/markup/md-html";

package/src/md.ts

@@ -18,7 +18,7 @@ import remarkParseFrontmatter from "remark-parse-frontmatter";
 import remarkGfm from "remark-gfm";
 import remarkDirective from "remark-directive";
 import { readFileSync } from "node:fs";
-import { basename, extname, resolve as resolvePath } from "node:path";
+import { basename, extname, relative, resolve as resolvePath } from "node:path";
 import { globSync } from "glob";
 import { mdastNodeToJx } from "./transpile.ts";
 import type { MarkdownFileResult, MdastNode, TocEntry, UnifiedProcessor } from "./types.ts";
@@ -133,6 +133,30 @@ function extractExcerpt(tree: MdastNode) {
   return mdastToString(firstParagraph);
 }
 
+/**
+ * Derive an entry slug from a file path. Without a source root (or for files directly at the root),
+ * the slug is the basename — the historical behavior every flat collection relies on. Files in
+ * subdirectories of the root get path-based slugs with POSIX separators and a trailing `/index`
+ * stripped, so `studio/canvas.md` and `studio/canvas/index.md` both yield `studio/canvas`.
+ *
+ * @param {string} filePath - Absolute path to the markdown file
+ * @param {string} [sourceRoot] - Resolved content-source root directory
+ * @returns {string} The entry slug
+ */
+function deriveSlug(filePath: string, sourceRoot?: string): string {
+  if (sourceRoot) {
+    const rel = relative(sourceRoot, filePath).split("\\").join("/");
+    if (rel && !rel.startsWith("..") && rel.includes("/")) {
+      let slug = rel.slice(0, rel.length - extname(rel).length);
+      if (slug.endsWith("/index")) {
+        slug = slug.slice(0, -"/index".length);
+      }
+      return slug;
+    }
+  }
+  return basename(filePath, extname(filePath));
+}
+
 /**
  * Process a single markdown source string into a MarkdownFileResult.
  *
@@ -143,6 +167,7 @@ function extractExcerpt(tree: MdastNode) {
  * @param {object} config - Processing options
  * @param {boolean} [config.directives] - Enable directive support
  * @param {unknown} [config.directiveOptions] - Directive plugin options
+ * @param {string} [config.sourceRoot] - Content-source root; files below it get path-based slugs
  * @returns {MarkdownFileResult}
  */
 export function processMarkdown(
@@ -151,6 +176,7 @@ export function processMarkdown(
   config: {
     directives?: boolean;
     directiveOptions?: unknown;
+    sourceRoot?: string;
   } = {},
 ) {
   let processor = (unified as unknown as () => UnifiedProcessor)()
@@ -173,7 +199,7 @@ export function processMarkdown(
   const plainText = mdastToString(mdTree);
   const toc = extractToc(tree);
   const excerpt = extractExcerpt(tree);
-  const slug = basename(filePath, extname(filePath));
+  const slug = deriveSlug(filePath, config.sourceRoot);
 
   const bodyNodes = tree.children!.filter(
     (n: MdastNode) => n.type !== "yaml" && n.type !== "toml",

package/src/serialize.ts

@@ -24,7 +24,7 @@ import remarkStringify from "remark-stringify";
 import remarkDirective from "remark-directive";
 import remarkGfm from "remark-gfm";
 import { stringify as stringifyYaml } from "yaml";
-import { htmlToJx } from "./html-to-jx.ts";
+import { htmlToJx } from "@jxsuite/markup/html-to-jx";
 import { expandDotPaths } from "./transpile.ts";
 import type {
   JsonValue,

package/src/transpile.ts

@@ -17,11 +17,11 @@ import remarkFrontmatter from "remark-frontmatter";
 import remarkParseFrontmatter from "remark-parse-frontmatter";
 import remarkGfm from "remark-gfm";
 import remarkDirective from "remark-directive";
-import { htmlToJx } from "./html-to-jx.ts";
+import { htmlToJx } from "@jxsuite/markup/html-to-jx";
 import type { MdastNode, UnifiedProcessor } from "./types.ts";
 import type { JsonValue, JxAttributeValue, JxDocument, JxElement } from "@jxsuite/schema/types";
 
-export { htmlToJx } from "./html-to-jx.ts";
+export { htmlToJx } from "@jxsuite/markup/html-to-jx";
 
 // ─── Dot-path expansion ─────────────────────────────────────────────────────
 

package/src/types.ts

@@ -1,4 +1,8 @@
-import type { JxElement } from "@jxsuite/schema/types";
+import type { JxElement, TocEntry } from "@jxsuite/schema/types";
+
+// The content wire types are core (extensions implement them, hosts thread them); re-exported here
+// So parser-internal modules and downstream consumers keep their historical import path.
+export type { ContentLoaderEntry, TocEntry } from "@jxsuite/schema/types";
 
 export interface MarkdownFileResult {
   slug: string;
@@ -12,25 +16,18 @@ export interface MarkdownFileResult {
   [key: string]: unknown;
 }
 
-export interface TocEntry {
-  depth: number;
-  text: string;
-  id: string;
-}
-
 export type ContentEntry = MarkdownFileResult & Record<string, unknown>;
 
-export interface ContentLoaderEntry {
-  id: string;
-  data: Record<string, unknown>;
-  body: string | null;
-  $children?: (JxElement | string)[];
-  _meta?: {
-    excerpt?: string;
-    toc?: TocEntry[];
-    readingTime?: number;
-    wordCount?: number;
-  };
+/**
+ * A content-type definition in the project.json `content` section — the parser extension owns this
+ * shape (its project fragment schema is the validation source of truth).
+ */
+export interface ContentTypeDef {
+  source?: string;
+  format?: string;
+  schema?: Record<string, unknown>;
+  $elements?: (string | { $ref: string })[];
+  [key: string]: unknown;
 }
 
 export interface MdastNode {