@jxsuite/markup 0.4.12 → 0.4.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/markup",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Browser-safe markup conversion: HTML → Jx nodes, markdown → sanitized HTML",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
     "upgrade": "bun update --latest && bun install"
   },
   "dependencies": {
-    "@jxsuite/schema": "^3.0.0",
+    "@jxsuite/schema": "^4.0.0",
     "hast-util-from-html": "^2.0.3",
     "hast-util-whitespace": "^3.0.0",
     "property-information": "^7.2.0",

package/src/html-to-jx.ts

@@ -1,8 +1,9 @@
 import { fromHtml } from "hast-util-from-html";
 import { whitespace } from "hast-util-whitespace";
-import { find, html as htmlInfo } from "property-information";
+import { find, html } from "property-information";
+import { isString } from "@jxsuite/schema/guards";
 
-import type { Nodes as HastNode } from "hast";
+import type { Properties, RootContent } from "hast";
 import type { JxElement } from "@jxsuite/schema/types";
 
 /**
@@ -13,14 +14,14 @@ import type { JxElement } from "@jxsuite/schema/types";
  */
 export function htmlToJx(htmlString: string) {
   const hast = fromHtml(htmlString, { fragment: true });
-  return convertHastChildren(hast.children as HastNode[]);
+  return convertHastChildren(hast.children);
 }
 
 /**
- * @param {HastNode[]} children
+ * @param {RootContent[]} children
  * @returns {(JxElement | string)[]}
  */
-function convertHastChildren(children: HastNode[]) {
+function convertHastChildren(children: RootContent[]) {
   const result: (JxElement | string)[] = [];
   for (const child of children) {
     const converted = convertHastNode(child);
@@ -32,21 +33,21 @@ function convertHastChildren(children: HastNode[]) {
 }
 
 /**
- * @param {HastNode} node
+ * @param {RootContent} node
  * @returns {JxElement | string | null}
  */
-function convertHastNode(node: HastNode) {
+function convertHastNode(node: RootContent) {
   if (node.type === "text") {
-    if (whitespace(node as Parameters<typeof whitespace>[0])) {
+    if (whitespace(node)) {
       return null;
     }
-    return node.value ?? null;
+    return node.value;
   }
 
   if (node.type === "element") {
     const el: JxElement = { tagName: node.tagName };
 
-    if (node.properties && Object.keys(node.properties).length > 0) {
+    if (Object.keys(node.properties).length > 0) {
       const { style, attrs } = hastPropsToJx(node.properties);
       if (Object.keys(attrs).length > 0) {
         el.attributes = attrs;
@@ -56,12 +57,12 @@ function convertHastNode(node: HastNode) {
       }
     }
 
-    const kids = node.children ? convertHastChildren(node.children) : [];
+    const kids = convertHastChildren(node.children);
 
-    if (kids.length === 1 && typeof kids[0] === "string") {
+    if (kids.length === 1 && isString(kids[0])) {
       [el.textContent] = kids;
     } else if (kids.length > 0) {
-      el.children = kids as JxElement[];
+      el.children = kids;
     }
 
     return el;
@@ -71,10 +72,10 @@ function convertHastNode(node: HastNode) {
 }
 
 /**
- * @param {Record<string, unknown>} properties
+ * @param {Properties} properties
  * @returns {{ style: Record<string, string>; attrs: Record<string, string> }}
  */
-function hastPropsToJx(properties: Record<string, unknown>) {
+function hastPropsToJx(properties: Properties) {
   const attrs: Record<string, string> = {};
   const style: Record<string, string> = {};
 
@@ -83,10 +84,10 @@ function hastPropsToJx(properties: Record<string, unknown>) {
       continue;
     }
 
-    const info = find(htmlInfo, key);
+    const info = find(html, key);
     const name = info.attribute;
 
-    if (name === "style" && typeof value === "string") {
+    if (name === "style" && isString(value)) {
       parseInlineStyle(value, style);
       continue;
     }

package/src/md-html.ts

@@ -1,12 +1,12 @@
 /**
  * Md-html — browser-safe markdown → sanitized HTML string
  *
- * 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.
+ * 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.
  *
- * Like everything in @jxsuite/markup 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
+ * Like everything in @jxsuite/markup 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.
  *
  * @module @jxsuite/markup/md-html
@@ -20,22 +20,35 @@ import remarkParse from "remark-parse";
 import remarkRehype from "remark-rehype";
 import { unified } from "unified";
 
+/**
+ * A unified attacher: called with `this` bound to the processor and the plugin's optional settings.
+ * Its result (a parser, compiler or transformer) is consumed by unified, never by us.
+ */
+type UnifiedPlugin = (...settings: never[]) => void;
+
 /**
  * Minimal structural surface of the unified processor used here — same rationale as
  * `UnifiedProcessor` in @jxsuite/parser's types (oxlint sees the ESM-only unified types as `any`),
  * plus `processSync` which that shared type doesn't carry.
  */
 interface MdHtmlProcessor {
-  use: (plugin: unknown, ...options: unknown[]) => MdHtmlProcessor;
+  use: (plugin: UnifiedPlugin) => MdHtmlProcessor;
   processSync: (source: string) => { toString: () => string };
 }
 
-const processor = (unified as unknown as () => MdHtmlProcessor)()
-  .use(remarkParse)
+/* SAFETY: `unified`, `remark-parse`, `remark-rehype` and `rehype-stringify` are shorthand
+   `declare module` entries in the root types.d.ts, so their imports are `any` here. unified@11
+   exports `unified` as a callable Processor whose call returns a fresh Processor; that Processor's
+   `use(plugin)` returns itself and `processSync(string)` returns a VFile whose toString() yields
+   the compiled HTML, which is exactly the MdHtmlProcessor surface. Each of the three plugin
+   packages default-exports a unified attacher function taking optional settings, which is the
+   UnifiedPlugin shape. */
+const processor = (unified as () => MdHtmlProcessor)()
+  .use(remarkParse as UnifiedPlugin)
   .use(remarkGfm)
-  .use(remarkRehype)
+  .use(remarkRehype as UnifiedPlugin)
   .use(rehypeSanitize)
-  .use(rehypeStringify);
+  .use(rehypeStringify as UnifiedPlugin);
 
 /**
  * Convert markdown source to a sanitized HTML string (GFM tables/strikethrough/task lists