@jxsuite/parser 0.21.4 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/parser",
-  "version": "0.21.4",
+  "version": "0.22.1",
   "description": "Jx markdown parser and external class integration",
   "license": "MIT",
   "repository": {
@@ -14,9 +14,13 @@
   "type": "module",
   "exports": {
     ".": "./src/md.js",
+    "./content": "./src/content.js",
+    "./ContentCollection.class.json": "./src/ContentCollection.class.json",
+    "./ContentEntry.class.json": "./src/ContentEntry.class.json",
     "./MarkdownCollection.class.json": "./src/MarkdownCollection.class.json",
     "./MarkdownFile.class.json": "./src/MarkdownFile.class.json",
-    "./transpile": "./src/transpile.js"
+    "./transpile": "./src/transpile.js",
+    "./html-to-jx": "./src/html-to-jx.js"
   },
   "publishConfig": {
     "provenance": true
@@ -44,7 +48,7 @@
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.9.0",
-    "@jxsuite/runtime": "^0.21.4",
+    "@jxsuite/runtime": "^0.22.1",
     "@types/hast": "^3.0.4"
   }
 }

package/src/ContentCollection.class.json

@@ -0,0 +1,112 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "ContentCollection",
+  "description": "Query a project content type with filter, sort, and limit",
+  "$prototype": "Class",
+  "extends": "Object",
+  "$implementation": "./content.js",
+
+  "$defs": {
+    "parameters": {
+      "contentType": {
+        "identifier": "contentType",
+        "type": { "type": "string", "enum": { "$ref": "#/$context/contentTypes" } },
+        "description": "Content type to query"
+      },
+      "filter": {
+        "identifier": "filter",
+        "type": {
+          "type": "array",
+          "default": [],
+          "items": {
+            "type": "object",
+            "properties": {
+              "field": {
+                "type": "string",
+                "enum": { "$ref": "#/$context/contentTypes/{@contentType}/schema/properties" }
+              },
+              "op": {
+                "type": "string",
+                "enum": [
+                  "==",
+                  "!=",
+                  ">",
+                  "<",
+                  ">=",
+                  "<=",
+                  "contains",
+                  "not contains",
+                  "empty",
+                  "not empty"
+                ]
+              },
+              "value": {}
+            },
+            "required": ["field", "op"]
+          }
+        },
+        "description": "Filter rules"
+      },
+      "sort": {
+        "identifier": "sort",
+        "type": {
+          "type": "array",
+          "default": [],
+          "items": {
+            "type": "object",
+            "properties": {
+              "field": {
+                "type": "string",
+                "enum": { "$ref": "#/$context/contentTypes/{@contentType}/schema/properties" }
+              },
+              "order": { "type": "string", "enum": ["asc", "desc"], "default": "asc" }
+            },
+            "required": ["field"]
+          }
+        },
+        "description": "Sort rules"
+      },
+      "limit": {
+        "identifier": "limit",
+        "type": { "type": "integer", "minimum": 1, "default": null },
+        "description": "Maximum entries to return"
+      }
+    },
+
+    "fields": {
+      "config": {
+        "role": "field",
+        "access": "private",
+        "scope": "instance",
+        "identifier": "config",
+        "type": { "type": "object" },
+        "description": "Raw configuration object passed to the constructor"
+      }
+    },
+
+    "constructor": {
+      "role": "constructor",
+      "$prototype": "Function",
+      "parameters": [
+        { "$ref": "#/$defs/parameters/contentType" },
+        { "$ref": "#/$defs/parameters/filter" },
+        { "$ref": "#/$defs/parameters/sort" },
+        { "$ref": "#/$defs/parameters/limit" }
+      ],
+      "body": ["this.config = config;"],
+      "description": "Stores the configuration for deferred resolution"
+    },
+
+    "methods": {
+      "resolve": {
+        "role": "method",
+        "$prototype": "Function",
+        "access": "public",
+        "scope": "instance",
+        "identifier": "resolve",
+        "parameters": [],
+        "description": "Query the content type entries with filter, sort, and limit"
+      }
+    }
+  }
+}

package/src/ContentEntry.class.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "ContentEntry",
+  "description": "Fetch a single entry from a content type by ID",
+  "$prototype": "Class",
+  "extends": "Object",
+  "$implementation": "./content.js",
+
+  "$defs": {
+    "parameters": {
+      "contentType": {
+        "identifier": "contentType",
+        "type": { "type": "string", "enum": { "$ref": "#/$context/contentTypes" } },
+        "description": "Content type to query"
+      },
+      "id": {
+        "identifier": "id",
+        "type": { "type": "string" },
+        "description": "Entry ID to fetch"
+      }
+    },
+
+    "fields": {
+      "config": {
+        "role": "field",
+        "access": "private",
+        "scope": "instance",
+        "identifier": "config",
+        "type": { "type": "object" },
+        "description": "Raw configuration object passed to the constructor"
+      }
+    },
+
+    "constructor": {
+      "role": "constructor",
+      "$prototype": "Function",
+      "parameters": [
+        { "$ref": "#/$defs/parameters/contentType" },
+        { "$ref": "#/$defs/parameters/id" }
+      ],
+      "body": ["this.config = config;"],
+      "description": "Stores the configuration for deferred resolution"
+    },
+
+    "methods": {
+      "resolve": {
+        "role": "method",
+        "$prototype": "Function",
+        "access": "public",
+        "scope": "instance",
+        "identifier": "resolve",
+        "parameters": [],
+        "description": "Fetch the entry by ID from the content type"
+      }
+    }
+  }
+}

package/src/content.js

@@ -0,0 +1,166 @@
+/**
+ * Content.js — ContentCollection and ContentEntry class implementations
+ *
+ * Provides the $implementation sidecar for ContentCollection.class.json and
+ * ContentEntry.class.json. Also exports the pure query functions (evaluateFilterRule,
+ * queryContentType, findEntry) used by both the classes and the server endpoint.
+ */
+
+// ─── Query Functions ────────────────────────────────────────────────────────
+
+/**
+ * Evaluate a single filter rule against an entry.
+ *
+ * @param {{ field: string; op: string; value?: unknown }} rule
+ * @param {ContentLoaderEntry} entry
+ * @returns {boolean}
+ */
+export function evaluateFilterRule(rule, entry) {
+  const actual = rule.field === "id" ? entry.id : entry.data[rule.field];
+  switch (rule.op) {
+    case "==":
+      return actual === rule.value;
+    case "!=":
+      return actual !== rule.value;
+    case "empty":
+      return actual == null || actual === "" || (Array.isArray(actual) && actual.length === 0);
+    case "not empty":
+      return actual != null && actual !== "" && !(Array.isArray(actual) && actual.length === 0);
+    case "contains":
+      return typeof actual === "string" && actual.includes(String(rule.value ?? ""));
+    case "not contains":
+      return typeof actual === "string" && !actual.includes(String(rule.value ?? ""));
+    case ">":
+      return /** @type {any} */ (actual) > /** @type {any} */ (rule.value);
+    case "<":
+      return /** @type {any} */ (actual) < /** @type {any} */ (rule.value);
+    case ">=":
+      return /** @type {any} */ (actual) >= /** @type {any} */ (rule.value);
+    case "<=":
+      return /** @type {any} */ (actual) <= /** @type {any} */ (rule.value);
+    default:
+      return true;
+  }
+}
+
+/**
+ * Query a loaded content type with filter, sort, and limit.
+ *
+ * @param {ContentLoaderEntry[]} entries - Full content type entries
+ * @param {{
+ *   filter?: Record<string, unknown> | Array<{ field: string; op: string; value?: unknown }>;
+ *   sort?: { field: string; order?: string } | Array<{ field: string; order?: string }>;
+ *   limit?: number;
+ * }} [query]
+ * @returns {ContentLoaderEntry[]} Filtered, sorted, limited entries
+ */
+export function queryContentType(entries, query = {}) {
+  let result = [...entries];
+
+  // Filter
+  if (query.filter) {
+    /** @type {{ field: string; op: string; value?: unknown }[]} */
+    let rules;
+    if (Array.isArray(query.filter)) {
+      rules = query.filter;
+    } else if (typeof query.filter === "object") {
+      rules = Object.entries(query.filter).map(([field, value]) => ({ field, op: "==", value }));
+    } else {
+      rules = [];
+    }
+    result = result.filter((entry) => rules.every((rule) => evaluateFilterRule(rule, entry)));
+  }
+
+  // Sort
+  if (query.sort) {
+    const sortRules = Array.isArray(query.sort) ? query.sort : [query.sort];
+    result.sort((a, b) => {
+      for (const { field, order = "asc" } of sortRules) {
+        const aVal = /** @type {string | number} */ (field === "id" ? a.id : (a.data[field] ?? ""));
+        const bVal = /** @type {string | number} */ (field === "id" ? b.id : (b.data[field] ?? ""));
+        if (aVal < bVal) return order === "asc" ? -1 : 1;
+        if (aVal > bVal) return order === "asc" ? 1 : -1;
+      }
+      return 0;
+    });
+  }
+
+  // Limit
+  if (query.limit && query.limit > 0) {
+    result = result.slice(0, query.limit);
+  }
+
+  return result;
+}
+
+/**
+ * Find a single entry by ID in a content type.
+ *
+ * @param {ContentLoaderEntry[]} entries - Full content type entries
+ * @param {string} id - Entry ID to find
+ * @returns {ContentLoaderEntry | null} The matching entry or null
+ */
+export function findEntry(entries, id) {
+  return entries.find((e) => e.id === id) ?? null;
+}
+
+// ─── Class Implementations ──────────────────────────────────────────────────
+
+/**
+ * @typedef {{
+ *   contentType?: string;
+ *   filter?: unknown;
+ *   sort?: unknown;
+ *   limit?: number;
+ *   _project?: { contentTypes?: Map<string, ContentLoaderEntry[]>; [k: string]: unknown };
+ *   [k: string]: unknown;
+ * }} CollectionConfig
+ *
+ * @typedef {{
+ *   contentType?: string;
+ *   id?: unknown;
+ *   _project?: { contentTypes?: Map<string, ContentLoaderEntry[]>; [k: string]: unknown };
+ *   _document?: { route?: { _pathParams?: Record<string, string> }; [k: string]: unknown };
+ *   [k: string]: unknown;
+ * }} EntryConfig
+ */
+
+export class ContentCollection {
+  /** @param {CollectionConfig} config */
+  constructor(config) {
+    this.config = config;
+  }
+
+  resolve() {
+    const { contentType, filter, sort, limit, _project } = this.config;
+    const entries = _project?.contentTypes?.get(contentType ?? "");
+    if (!entries) return [];
+    return queryContentType(entries, /** @type {any} */ ({ filter, sort, limit }));
+  }
+}
+
+export class ContentEntry {
+  /** @param {EntryConfig} config */
+  constructor(config) {
+    this.config = config;
+  }
+
+  resolve() {
+    const { contentType, id, _project, _document } = this.config;
+    const entries = _project?.contentTypes?.get(contentType ?? "");
+    if (!entries) return null;
+
+    let resolvedId = id;
+    if (
+      resolvedId &&
+      typeof resolvedId === "object" &&
+      /** @type {{ $ref?: string }} */ (resolvedId).$ref?.startsWith("#/$params/")
+    ) {
+      const paramName = /** @type {{ $ref: string }} */ (resolvedId).$ref.replace("#/$params/", "");
+      resolvedId = _document?.route?._pathParams?.[paramName];
+    }
+    if (!resolvedId) return null;
+
+    return findEntry(entries, /** @type {string} */ (resolvedId));
+  }
+}