@jxsuite/parser 0.35.1 → 1.1.0

package/README.md

@@ -1,115 +1,156 @@
 # `@jxsuite/parser`
 
-> Markdown parser and external class integration for Jx.
+> Content & Markdown extension for Jx — file-based content collections with Markdown and CSV formats.
 
 ## Overview
 
-`@jxsuite/parser` provides the content layer for Jx applications. It exports `MarkdownFile` and `MarkdownCollection` — external classes that satisfy the Jx `$prototype` + `$src` contract — and a `transpile` utility for converting Jx-flavored Markdown directly into Jx component objects.
+`@jxsuite/parser` is the first-party content extension. Its `jx-extension.json` manifest exposes six classes plus project/document schema fragments:
 
-Built on the [`unified`](https://unifiedjs.com/) / remark / rehype pipeline.
+| Class                | Kind            | Purpose                                                                                            |
+| -------------------- | --------------- | -------------------------------------------------------------------------------------------------- |
+| `Markdown`           | Format (`.md`)  | Parse/serialize Jx Markdown documents, load markdown content entries, resolve a file at runtime    |
+| `Csv`                | Format (`.csv`) | Parse local CSV files or remote CSV URLs into typed content entries                                |
+| `Content`            | Project section | Loads the project.json `content` section into `_project.content` and expands `$paths` route params |
+| `ContentCollection`  | Runtime class   | Query a content type with filter, sort, and limit                                                  |
+| `ContentEntry`       | Runtime class   | Fetch a single entry from a content type by ID (or another field)                                  |
+| `MarkdownCollection` | Runtime class   | Glob markdown files into a sorted, filterable array                                                |
 
-## Installation
+Built on the [`unified`](https://unifiedjs.com/) / remark ecosystem.
+
+## Installation & registration
 
 ```bash
 bun add @jxsuite/parser
 ```
 
-## `MarkdownFile`
-
-Parses a single Markdown file into structured data.
+Registration is manifest-based — add the package to `project.json`:
 
 ```json
 {
-  "state": {
-    "post": {
-      "$prototype": "MarkdownFile",
-      "$src": "@jxsuite/parser/MarkdownFile.class.json",
-      "src": "./content/posts/hello-world.md"
-    }
-  }
+  "extensions": ["@jxsuite/parser"]
 }
 ```
 
-**Resolved value:**
+That one entry registers the `.md`/`.csv` formats, the `content` project section, and the classes: `$prototype: "ContentEntry"` (etc.) resolves by name through the project's extension registry — no `$src` or imports wiring. There are no implicit defaults: a project without the extension supports only `.json` documents.
 
-| Property       | Type     | Description                         |
-| -------------- | -------- | ----------------------------------- |
-| `slug`         | `string` | Filename without extension          |
-| `path`         | `string` | Full file path                      |
-| `frontmatter`  | `object` | Parsed YAML frontmatter             |
-| `$body`        | `string` | Rendered HTML body                  |
-| `$excerpt`     | `string` | First paragraph as HTML             |
-| `$toc`         | `array`  | Table of contents (id, text, depth) |
-| `$readingTime` | `number` | Estimated reading time in minutes   |
-| `$wordCount`   | `number` | Word count                          |
+## Content collections
 
-## `MarkdownCollection`
+Declare content types in the `content` section (validated by this package's project schema fragment):
+
+```json
+{
+  "content": {
+    "docs": {
+      "source": "./content/docs",
+      "format": "Markdown",
+      "schema": {
+        "type": "object",
+        "properties": { "title": { "type": "string" }, "date": { "type": "string" } }
+      },
+      "$elements": [{ "$ref": "./components/doc-note.json" }]
+    }
+  }
+}
+```
 
-Globs Markdown files into a sorted, filterable collection.
+Query them from any page or component:
 
 ```json
 {
   "state": {
     "posts": {
-      "$prototype": "MarkdownCollection",
-      "$src": "@jxsuite/parser/MarkdownCollection.class.json",
-      "src": "./content/posts/*.md",
-      "sortBy": "date",
-      "sortOrder": "desc",
+      "$prototype": "ContentCollection",
+      "contentType": "docs",
+      "filter": [{ "field": "draft", "op": "!=", "value": true }],
       "limit": 10
+    },
+    "page": {
+      "$prototype": "ContentEntry",
+      "contentType": "docs",
+      "id": { "$ref": "#/$params/slug" }
     }
   }
 }
 ```
 
-Returns an array of `MarkdownFile` resolved objects.
+`ContentEntry` matches on the entry id (slug) by default; set `field` to match a frontmatter field (e.g. `"sku"`) instead.
 
-| Option      | Type     | Default  | Description                         |
-| ----------- | -------- | -------- | ----------------------------------- |
-| `src`       | `string` | —        | Glob pattern for Markdown files     |
-| `sortBy`    | `string` | `"date"` | Frontmatter field to sort by        |
-| `sortOrder` | `string` | `"desc"` | `"asc"` or `"desc"`                 |
-| `limit`     | `number` | —        | Maximum number of results           |
-| `filter`    | `string` | —        | Frontmatter field filter expression |
+## `Markdown`
 
-## `MarkdownDirective` (remark plugin)
+One class carries every format capability:
 
-Maps `::directive{attrs}` syntax to custom element tags in HTML output. Parameters are encoded as a `data-jx-props` JSON attribute so Jx components can receive them via reactive state.
+- **static `parse`** — Jx Markdown source → Jx document (browser-safe; Studio opens `.md` files with it)
+- **static `serialize`** — Jx document → markdown, `roundtrip` (lossless, default) or `export` (lossy clean markdown)
+- **static `discover` / `load`** — compile-time content access: frontmatter → `data`, source preserved as `body`, parsed `$children`, and `_meta` (excerpt, toc, reading time, word count)
+- **instance `resolve`** — runtime on-demand access for a `$prototype: "Markdown"` state entry
 
-```markdown
-:::my-card{title="Hello" image="/img/hero.png"}
-Card body content here.
-:::
+```json
+{
+  "state": {
+    "post": { "$prototype": "Markdown", "src": "./content/posts/hello-world.md" }
+  }
+}
 ```
 
-Produces:
+**Resolved value** (`MarkdownFileResult`):
 
-```html
-<my-card data-jx-props='{"title":"Hello","image":"/img/hero.png"}'>
-  <p>Card body content here.</p>
-</my-card>
-```
+| Property       | Type     | Description                                 |
+| -------------- | -------- | ------------------------------------------- |
+| `slug`         | `string` | Entry id (path-based under the source root) |
+| `path`         | `string` | Full file path                              |
+| `frontmatter`  | `object` | Parsed YAML frontmatter                     |
+| `$children`    | `array`  | Body as Jx element nodes                    |
+| `$excerpt`     | `string` | First paragraph                             |
+| `$toc`         | `array`  | Table of contents (id, text, depth)         |
+| `$readingTime` | `number` | Estimated reading time in minutes           |
+| `$wordCount`   | `number` | Word count                                  |
+
+### Directives
+
+`:::name{attrs}` container syntax converts directly to Jx element nodes — `:::my-card{title="Hello"}` becomes a `my-card` element with its attributes routed to the right Jx locations (props, `$`-annotations, styles). Capitalized directives (e.g. `:::Array`) become tagName-less `$prototype` nodes. A content type's `$elements` list declares which components its entries may use.
+
+## `Csv`
 
-## `transpileJxMarkdown`
+CSV content format (`documentKinds: ["content"]`; Studio opens `.csv` in grid/source modes).
 
-Converts a Jx-flavored Markdown source string directly into a Jx component object (no file I/O).
+| Option    | Type     | Description                                                       |
+| --------- | -------- | ----------------------------------------------------------------- |
+| `src`     | `string` | Path or http(s) URL to a CSV file (remote sources supported)      |
+| `schema`  | `object` | Per-column type schema for coercion (number, boolean, array)      |
+| `idField` | `string` | Column used as entry id (default chain: id, sku, slug, row index) |
 
-```js
-import { transpileJxMarkdown } from "@jxsuite/parser/transpile";
+## `MarkdownCollection`
+
+Globs markdown files into a sorted array of `MarkdownFileResult`s (runtime alternative to the content section):
 
-const doc = transpileJxMarkdown(markdownString);
-// { tagName: "article", children: [...] }
+```json
+{
+  "state": {
+    "posts": {
+      "$prototype": "MarkdownCollection",
+      "src": "./content/posts/*.md",
+      "sortBy": "frontmatter.date",
+      "sortOrder": "desc",
+      "limit": 10
+    }
+  }
+}
 ```
 
-## Parsing pipeline
+Options: `src` (glob), `sortBy` (dot-path, default `"frontmatter.date"`), `sortOrder` (`"asc"`/`"desc"`), `limit`, `filter` (predicate), `basePath`, `directives`.
+
+## Module exports
 
-1. `remark-parse` — Markdown → MDAST
-2. `remark-frontmatter` + `remark-parse-frontmatter` — YAML extraction
-3. `remark-gfm` — GitHub Flavored Markdown
-4. `remark-directive` — directive syntax
-5. `MarkdownDirective` — directive nodes → custom element tags
-6. `remark-rehype` — MDAST → HAST
-7. `rehype-stringify` — HAST → HTML
+| Export                           | Contents                                                               |
+| -------------------------------- | ---------------------------------------------------------------------- |
+| `@jxsuite/parser`                | `processMarkdown`, `Markdown`, `MarkdownCollection`                    |
+| `@jxsuite/parser/markdown`       | The `Markdown` format class (browser-safe parse/serialize)             |
+| `@jxsuite/parser/csv`            | `Csv`, `parseCSV`, `coerceCSVRows`                                     |
+| `@jxsuite/parser/content`        | `ContentCollection`, `ContentEntry`, pure query functions              |
+| `@jxsuite/parser/content-loader` | `Content` project-section loader                                       |
+| `@jxsuite/parser/transpile`      | `transpileJxMarkdown` (markdown source → Jx document), `isJxMarkdown`  |
+| `@jxsuite/parser/serialize`      | `serializeJxMarkdown`, `jxToMdast`, `mdastToJx`, markdown element sets |
+| `@jxsuite/parser/*.class.json`   | The class descriptors named by the manifest                            |
 
 ## License
 

package/dist/content-loader.js

@@ -0,0 +1,285 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/content-loader.ts
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
+function loadJSONEntries(filePath) {
+  const raw = JSON.parse(readFileSync(filePath, "utf8"));
+  if (Array.isArray(raw)) {
+    return raw.map((item, i) => ({
+      body: null,
+      data: item,
+      id: item.id ?? `${basename(filePath, ".json")}-${i}`
+    }));
+  }
+  const rawObj = raw;
+  return [
+    {
+      body: null,
+      data: rawObj,
+      id: rawObj.id ?? basename(filePath, ".json")
+    }
+  ];
+}
+function discoverJSONFiles(resolvedSource) {
+  if (extname(resolvedSource)) {
+    return existsSync(resolvedSource) ? [resolvedSource] : [];
+  }
+  try {
+    return readdirSync(resolvedSource, { recursive: true }).filter((f) => String(f).endsWith(".json")).map((f) => resolve(resolvedSource, String(f)));
+  } catch {
+    return [];
+  }
+}
+function loadContentConfig(projectRoot, projectConfig) {
+  const contentDir = resolve(projectRoot, "content");
+  const config = { content: projectConfig?.content ?? {} };
+  return { config, contentDir };
+}
+async function loadContentSection(section, root, formats) {
+  const contentTypes = new Map;
+  for (const [name, contentTypeDef] of Object.entries(section)) {
+    const entries = await loadContentType(name, contentTypeDef, root, formats);
+    contentTypes.set(name, entries);
+  }
+  return contentTypes;
+}
+function getContentTypeElements(projectRoot, contentTypeName, projectConfig) {
+  const { config } = loadContentConfig(projectRoot, projectConfig);
+  const def = config.content[contentTypeName];
+  return def?.$elements;
+}
+async function loadContentType(name, contentTypeDef, projectRoot, registry) {
+  const { source } = contentTypeDef;
+  if (!source) {
+    return [];
+  }
+  const schema = contentTypeDef.schema;
+  const directiveOptions = contentTypeDef.$elements?.length ? {
+    allowedNames: contentTypeDef.$elements.filter((e) => typeof e === "string" || typeof e === "object" && e?.$ref).map((e) => typeof e === "string" ? e : e.$ref)
+  } : undefined;
+  const formatName = contentTypeDef.format;
+  let entry;
+  if (formatName && formatName !== "json") {
+    entry = registry.byName(formatName);
+    if (!entry) {
+      throw new Error(`Content type "${name}": format "${formatName}" is not a registered format class. ` + `Enable an extension providing it in project.json "extensions", e.g. "@jxsuite/parser".`);
+    }
+  }
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    if (!entry) {
+      throw new Error(`Content type "${name}": remote sources require an explicit "format" naming a ` + `format class with "remote": true (e.g. "Csv").`);
+    }
+    if (!entry.remote) {
+      throw new Error(`Content type "${name}": format "${entry.name}" does not support remote sources ` + `(its format block lacks "remote": true).`);
+    }
+    try {
+      const entries2 = await entry.call("load", source, {
+        directiveOptions,
+        schema
+      });
+      if (schema) {
+        validateEntries(entries2, schema, name);
+      }
+      return entries2;
+    } catch (error) {
+      console.warn(`Content type "${name}": ${errorMessage(error)}`);
+      return [];
+    }
+  }
+  const resolvedSource = resolve(projectRoot, source).split("\\").join("/");
+  const ext = extname(source).toLowerCase();
+  if (formatName === "json" || !entry && ext === ".json") {
+    const files2 = discoverJSONFiles(resolvedSource);
+    const entries2 = [];
+    for (const filePath of files2) {
+      entries2.push(...loadJSONEntries(filePath));
+    }
+    if (schema) {
+      validateEntries(entries2, schema, name);
+    }
+    return entries2;
+  }
+  if (!entry && ext) {
+    entry = registry.byExtension(ext, "load");
+  }
+  if (!entry) {
+    throw unknownFormatError(source, ext || `content type "${name}" (directory sources need an explicit "format")`);
+  }
+  const files = entry.capabilities.discover ? await entry.call("discover", source, {
+    baseDir: projectRoot
+  }) : [resolvedSource];
+  const sourceRoot = extname(source) ? undefined : resolvedSource;
+  const entries = [];
+  for (const filePath of files) {
+    entries.push(...await entry.call("load", filePath, {
+      directiveOptions,
+      schema,
+      ...sourceRoot !== undefined && { sourceRoot }
+    }));
+  }
+  if (schema) {
+    validateEntries(entries, schema, name);
+  }
+  return entries;
+}
+function unknownFormatError(path, ext) {
+  return new Error(`No format class registered for "${ext}" (${path}). ` + `Enable an extension providing this format in project.json "extensions", ` + `e.g. "@jxsuite/parser".`);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function validateEntries(entries, schema, contentTypeName) {
+  const required = schema.required ?? [];
+  const properties = schema.properties ?? {};
+  for (const entry of entries) {
+    for (const field of required) {
+      if (!(field in entry.data) || entry.data[field] == null) {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" missing required field "${field}"`);
+      }
+    }
+    for (const [field, def] of Object.entries(properties)) {
+      const value = entry.data[field];
+      if (value == null) {
+        continue;
+      }
+      if (def.type === "string" && typeof value !== "string") {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected string, got ${typeof value}`);
+      } else if (def.type === "number" && typeof value !== "number") {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected number, got ${typeof value}`);
+      } else if (def.type === "boolean" && typeof value !== "boolean") {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected boolean, got ${typeof value}`);
+      } else if (def.type === "array" && !Array.isArray(value)) {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected array, got ${typeof value}`);
+      }
+    }
+  }
+}
+var CONTENT_REF_PREFIX = "#/content/";
+function refTargetName(ref) {
+  if (!ref?.startsWith(CONTENT_REF_PREFIX)) {
+    return;
+  }
+  return ref.slice(CONTENT_REF_PREFIX.length);
+}
+function resolveContentTypeRefs(contentTypes, section) {
+  for (const [name, contentTypeDef] of Object.entries(section)) {
+    const schema = contentTypeDef.schema;
+    if (!schema?.properties) {
+      continue;
+    }
+    const entries = contentTypes.get(name);
+    if (!entries) {
+      continue;
+    }
+    for (const [field, def] of Object.entries(schema.properties)) {
+      const toOne = refTargetName(def.$ref);
+      const toMany = toOne ? undefined : refTargetName(def.items?.$ref);
+      const target = toOne ?? toMany;
+      if (!target) {
+        continue;
+      }
+      const refEntries = contentTypes.get(target);
+      if (!refEntries) {
+        console.warn(`Content relationships: "${name}" field "${field}" references unknown content type "${target}"`);
+        continue;
+      }
+      for (const entry of entries) {
+        const value = entry.data[field];
+        if (toOne && typeof value === "string") {
+          const resolved = refEntries.find((e) => e.id === value);
+          if (resolved) {
+            entry.data[field] = resolved;
+          } else {
+            console.warn(`Content relationships: "${name}/${entry.id}" field "${field}" references missing "${target}" entry "${value}"`);
+          }
+        } else if (toMany && Array.isArray(value)) {
+          entry.data[field] = value.map((id) => {
+            if (typeof id !== "string") {
+              return id;
+            }
+            const resolved = refEntries.find((e) => e.id === id);
+            if (!resolved) {
+              console.warn(`Content relationships: "${name}/${entry.id}" field "${field}" references missing "${target}" entry "${id}"`);
+            }
+            return resolved ?? id;
+          });
+        }
+      }
+    }
+  }
+}
+
+class Content {
+  static async projectData(sectionValue, ctx) {
+    const section = sectionValue ?? {};
+    const data = await loadContentSection(section, ctx.root, ctx.registry.formats);
+    resolveContentTypeRefs(data, section);
+    return data;
+  }
+  static async resolvePaths(pathsDef, ctx) {
+    const entries = ctx.data.get(pathsDef.contentType);
+    if (!entries || entries.length === 0) {
+      console.warn(`Warning: $paths references content type "${pathsDef.contentType}" but it has no entries`);
+      return [];
+    }
+    const param = pathsDef.param ?? "slug";
+    const field = pathsDef.field ?? "id";
+    return entries.map((entry) => ({
+      [param]: field === "id" ? entry.id : entry.data[field] ?? entry.id
+    })).filter((p) => p[param]);
+  }
+}
+export {
+  resolveContentTypeRefs,
+  loadContentSection,
+  loadContentConfig,
+  getContentTypeElements,
+  Content
+};

package/dist/content.js

@@ -140,7 +140,7 @@ class ContentCollection {
   }
   resolve() {
     const { contentType, filter, sort, limit, _project } = this.config;
-    const entries = _project?.contentTypes?.get(contentType ?? "");
+    const entries = _project?.content?.get(contentType ?? "");
     if (!entries) {
       return [];
     }
@@ -163,7 +163,7 @@ class ContentEntry {
   }
   resolve() {
     const { contentType, id, field, _project, _document } = this.config;
-    const entries = _project?.contentTypes?.get(contentType ?? "");
+    const entries = _project?.content?.get(contentType ?? "");
     if (!entries) {
       return null;
     }

package/dist/markdown.js

@@ -858,7 +858,7 @@ var init_unified = __esm(() => {
   init_lib3();
 });
 
-// ../schema/src/guards.ts
+// ../../packages/schema/src/guards.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -30939,7 +30939,7 @@ var init_property_information3 = __esm(() => {
   svg6 = merge3([aria3, svg5, xlink3, xmlns3, xml3], "svg");
 });
 
-// src/html-to-jx.ts
+// ../../packages/markup/src/html-to-jx.ts
 function htmlToJx(htmlString) {
   const hast = fromHtml(htmlString, { fragment: true });
   return convertHastChildren(hast.children);
@@ -46180,7 +46180,7 @@ __export(exports_md, {
   Markdown: () => Markdown
 });
 import { readFileSync } from "node:fs";
-import { basename, extname, resolve as resolvePath2 } from "node:path";
+import { basename, extname, relative, resolve as resolvePath2 } from "node:path";
 function visit3(tree, typeOrVisitor, maybeVisitor) {
   const type = typeof typeOrVisitor === "string" ? typeOrVisitor : null;
   const visitor = type ? maybeVisitor : typeOrVisitor;
@@ -46239,6 +46239,19 @@ function extractExcerpt(tree) {
   }
   return mdastToString(firstParagraph);
 }
+function deriveSlug(filePath, sourceRoot) {
+  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));
+}
 function processMarkdown(source, filePath, config = {}) {
   let processor = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(import_remark_parse_frontmatter2.default).use(remarkGfm);
   if (config.directives || config.directiveOptions) {
@@ -46253,7 +46266,7 @@ function processMarkdown(source, filePath, config = {}) {
   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((n7) => n7.type !== "yaml" && n7.type !== "toml");
   const $children = bodyNodes.map((n7) => mdastNodeToJx(n7)).filter(Boolean);
   return {
@@ -46367,7 +46380,8 @@ class Markdown {
       ...options.directives !== undefined && { directives: options.directives },
       ...options.directiveOptions !== undefined && {
         directiveOptions: options.directiveOptions
-      }
+      },
+      ...options.sourceRoot !== undefined && { sourceRoot: options.sourceRoot }
     });
     const _meta = {};
     if (result.$excerpt != null) {

package/dist/serialize.js

@@ -858,7 +858,7 @@ var init_unified = __esm(() => {
   init_lib3();
 });
 
-// ../schema/src/guards.ts
+// ../../packages/schema/src/guards.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -30939,7 +30939,7 @@ var init_property_information3 = __esm(() => {
   svg6 = merge3([aria3, svg5, xlink3, xmlns3, xml3], "svg");
 });
 
-// src/html-to-jx.ts
+// ../../packages/markup/src/html-to-jx.ts
 function htmlToJx(htmlString) {
   const hast = fromHtml(htmlString, { fragment: true });
   return convertHastChildren(hast.children);

package/jx-extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "@jxsuite/parser",
+  "title": "Content & Markdown",
+  "description": "File-based content collections with Markdown and CSV formats",
+  "classes": {
+    "Markdown": "./src/Markdown.class.json",
+    "Csv": "./src/Csv.class.json",
+    "MarkdownCollection": "./src/MarkdownCollection.class.json",
+    "ContentCollection": "./src/ContentCollection.class.json",
+    "ContentEntry": "./src/ContentEntry.class.json",
+    "Content": "./src/Content.class.json"
+  },
+  "schemas": {
+    "project": "./schemas/project.fragment.schema.json",
+    "document": "./schemas/document.fragment.schema.json"
+  }
+}