@jxsuite/parser 4.2.0 → 4.3.1

package/dist/markdown.js

@@ -80,6 +80,9 @@ function isRef(value) {
 function isNodeObject(value) {
   return isJsonObject(value);
 }
+function isTemplateString(value) {
+  return typeof value === "string" && value.includes("${");
+}
 function isPlainTagName(tagName) {
   return typeof tagName === "string";
 }
@@ -129,6 +132,195 @@ var init_guards = __esm(() => {
   ]);
 });
 
+// ../../packages/schema/src/content-query.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function comparable(value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      return;
+    }
+    const iso = value.toISOString();
+    return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso.replace(/\.\d{3}Z$/, "Z");
+  }
+  return value;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => deepEqual(comparable(item), comparable(b[i])));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => (key in b) && deepEqual(comparable(a[key]), comparable(b[key])));
+  }
+  return false;
+}
+function sameValue(actual, expected) {
+  const a = comparable(actual);
+  if (Array.isArray(expected) || isPlainObject(expected)) {
+    return deepEqual(a, expected);
+  }
+  if (Array.isArray(a)) {
+    return a.some((item) => comparable(item) === expected);
+  }
+  return a === expected;
+}
+function readField(data, key) {
+  if (Object.hasOwn(data, key)) {
+    return data[key];
+  }
+  if (!key.includes(".")) {
+    return;
+  }
+  return readPath(data, key.split("."));
+}
+function readPath(holder, [part, ...rest]) {
+  if (part === undefined || !isPlainObject(holder) || !Object.hasOwn(holder, part)) {
+    return;
+  }
+  const value = holder[part];
+  return rest.length === 0 ? value : readPath(value, rest);
+}
+function order(actual, operand) {
+  const a = comparable(actual);
+  if (isNumber(a) && isNumber(operand)) {
+    return a - operand;
+  }
+  if (isString(a) && isString(operand)) {
+    return a < operand ? -1 : a > operand ? 1 : 0;
+  }
+  return;
+}
+function isNowOperand(operand) {
+  return isPlainObject(operand) && operand.$now === true && Object.keys(operand).length === 1;
+}
+function timeOf(value) {
+  const time = value instanceof Date ? value.getTime() : isString(value) ? Date.parse(value) : Number.NaN;
+  return Number.isNaN(time) ? undefined : time;
+}
+function operatorTest(where, op, operand, ctx) {
+  switch (op) {
+    case "$eq": {
+      return (actual) => sameValue(actual, operand);
+    }
+    case "$ne": {
+      return (actual) => !sameValue(actual, operand);
+    }
+    case "$in":
+    case "$nin": {
+      if (!Array.isArray(operand)) {
+        throw new TypeError(`${where}.${op}: expected an array, got ${JSON.stringify(operand)}`);
+      }
+      const hit = (actual) => operand.some((candidate) => sameValue(actual, candidate));
+      return op === "$in" ? hit : (actual) => !hit(actual);
+    }
+    case "$exists": {
+      if (!isBoolean(operand)) {
+        throw new TypeError(`${where}.$exists: expected true or false, got ${JSON.stringify(operand)}`);
+      }
+      return (actual) => (actual !== undefined && actual !== null) === operand;
+    }
+    default: {
+      const test = (diff) => op === "$gt" ? diff > 0 : op === "$gte" ? diff >= 0 : op === "$lt" ? diff < 0 : diff <= 0;
+      if (isNowOperand(operand)) {
+        return (actual) => {
+          if (actual === undefined || actual === null) {
+            return false;
+          }
+          const time = timeOf(actual);
+          return time === undefined ? ctx.onBadDate : test(time - ctx.now().getTime());
+        };
+      }
+      if (!isString(operand) && !isNumber(operand)) {
+        throw new TypeError(`${where}.${op}: expected a string or number, got ${JSON.stringify(operand)}`);
+      }
+      return (actual) => {
+        const diff = order(actual, operand);
+        return diff !== undefined && test(diff);
+      };
+    }
+  }
+}
+function operatorKeys(condition) {
+  const keys = Object.keys(condition);
+  const dollars = keys.filter((key) => key.startsWith("$"));
+  if (dollars.length === 0) {
+    return null;
+  }
+  return dollars.length === keys.length ? keys : [];
+}
+function compileCondition(key, condition, ctx) {
+  const where = `${ctx.name}.${key}`;
+  if (!isPlainObject(condition)) {
+    return (actual) => sameValue(actual, condition);
+  }
+  const ops = operatorKeys(condition);
+  if (ops === null) {
+    return (actual) => deepEqual(comparable(actual), condition);
+  }
+  if (ops.length === 0) {
+    throw new TypeError(`${where}: cannot mix $operators with plain keys in one condition`);
+  }
+  const tests = ops.map((op) => {
+    if (!OPERATORS.has(op)) {
+      throw new TypeError(`${where}: unknown operator "${op}" (use ${[...OPERATORS].join(", ")})`);
+    }
+    return operatorTest(where, op, condition[op], ctx);
+  });
+  return (actual) => tests.every((test) => test(actual));
+}
+function compileFields(query, ctx) {
+  return Object.entries(query).map(([key, condition]) => {
+    if (key.startsWith("$")) {
+      throw new TypeError(`${ctx.name}.${key}: top-level operators are not supported, conditions on different fields already combine with AND`);
+    }
+    return { key, test: compileCondition(key, condition, ctx) };
+  });
+}
+function compileWhere(where, options = {}) {
+  if (where === undefined) {
+    return Object.assign(() => true, { why: nothing });
+  }
+  if (!isPlainObject(where)) {
+    throw new TypeError(`"where" must be an object mapping frontmatter fields to conditions`);
+  }
+  const ctx = { name: "where", now: options.now ?? realClock, onBadDate: false };
+  const tests = compileFields(where, ctx);
+  return Object.assign((data) => tests.every(({ key, test }) => test(readField(data, key))), {
+    why: (data) => tests.find(({ key, test }) => !test(readField(data, key)))?.key
+  });
+}
+function compileHold(hold, options = {}) {
+  if (hold === undefined) {
+    return nothing;
+  }
+  if (!Array.isArray(hold)) {
+    throw new TypeError(`"hold" must be an array of { "label", "when" } rules`);
+  }
+  const now = options.now ?? realClock;
+  const rules = hold.map((rule, index) => {
+    const at = `hold[${index}]`;
+    if (!isPlainObject(rule) || !isString(rule.label) || rule.label.trim() === "") {
+      throw new TypeError(`${at}: expected a non-empty "label"`);
+    }
+    if (!isPlainObject(rule.when) || Object.keys(rule.when).length === 0) {
+      throw new TypeError(`${at}: expected "when" to name at least one frontmatter field`);
+    }
+    const ctx = { name: `${at}.when`, now, onBadDate: true };
+    return { label: rule.label, tests: compileFields(rule.when, ctx) };
+  });
+  return (data) => rules.find(({ tests }) => tests.every(({ key, test }) => test(readField(data, key))))?.label;
+}
+var OPERATORS, nothing = () => {}, realClock = () => new Date;
+var init_content_query = __esm(() => {
+  init_guards();
+  OPERATORS = new Set(["$eq", "$ne", "$in", "$nin", "$exists", "$gt", "$gte", "$lt", "$lte"]);
+});
+
 // src/content-rules.ts
 function escapeRegExp(text) {
   return text.replaceAll(REGEXP_SPECIAL, String.raw`\$&`);
@@ -254,7 +446,7 @@ function mayNameDirectory(pattern) {
 }
 function compileExclude(patterns) {
   if (patterns === undefined) {
-    return { empty: true, excludedBy: nothing, excludesDir: () => false };
+    return { empty: true, excludedBy: nothing2, excludesDir: () => false };
   }
   if (!Array.isArray(patterns)) {
     throw new TypeError(`"exclude" must be an array of glob patterns`);
@@ -294,152 +486,11 @@ function compileExclude(patterns) {
     excludedBy: (path) => files.find((f) => f.re.test(path))?.pattern
   };
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
-}
-function comparable(value) {
-  if (value instanceof Date) {
-    if (Number.isNaN(value.getTime())) {
-      return;
-    }
-    const iso = value.toISOString();
-    return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso.replace(/\.\d{3}Z$/, "Z");
-  }
-  return value;
-}
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((item, i) => deepEqual(comparable(item), comparable(b[i])));
-  }
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const keys = Object.keys(a);
-    return keys.length === Object.keys(b).length && keys.every((key) => (key in b) && deepEqual(comparable(a[key]), comparable(b[key])));
-  }
-  return false;
-}
-function sameValue(actual, expected) {
-  const a = comparable(actual);
-  if (Array.isArray(expected) || isPlainObject(expected)) {
-    return deepEqual(a, expected);
-  }
-  if (Array.isArray(a)) {
-    return a.some((item) => comparable(item) === expected);
-  }
-  return a === expected;
-}
-function readField(data, key) {
-  if (Object.hasOwn(data, key)) {
-    return data[key];
-  }
-  if (!key.includes(".")) {
-    return;
-  }
-  return readPath(data, key.split("."));
-}
-function readPath(holder, [part, ...rest]) {
-  if (part === undefined || !isPlainObject(holder) || !Object.hasOwn(holder, part)) {
-    return;
-  }
-  const value = holder[part];
-  return rest.length === 0 ? value : readPath(value, rest);
-}
-function order(actual, operand) {
-  const a = comparable(actual);
-  if (isNumber(a) && isNumber(operand)) {
-    return a - operand;
-  }
-  if (isString(a) && isString(operand)) {
-    return a < operand ? -1 : a > operand ? 1 : 0;
-  }
-  return;
-}
-function operatorTest(where, op, operand) {
-  switch (op) {
-    case "$eq": {
-      return (actual) => sameValue(actual, operand);
-    }
-    case "$ne": {
-      return (actual) => !sameValue(actual, operand);
-    }
-    case "$in":
-    case "$nin": {
-      if (!Array.isArray(operand)) {
-        throw new TypeError(`${where}.${op}: expected an array, got ${JSON.stringify(operand)}`);
-      }
-      const hit = (actual) => operand.some((candidate) => sameValue(actual, candidate));
-      return op === "$in" ? hit : (actual) => !hit(actual);
-    }
-    case "$exists": {
-      if (!isBoolean(operand)) {
-        throw new TypeError(`${where}.$exists: expected true or false, got ${JSON.stringify(operand)}`);
-      }
-      return (actual) => (actual !== undefined && actual !== null) === operand;
-    }
-    default: {
-      if (!isString(operand) && !isNumber(operand)) {
-        throw new TypeError(`${where}.${op}: expected a string or number, got ${JSON.stringify(operand)}`);
-      }
-      const test = (diff) => op === "$gt" ? diff > 0 : op === "$gte" ? diff >= 0 : op === "$lt" ? diff < 0 : diff <= 0;
-      return (actual) => {
-        const diff = order(actual, operand);
-        return diff !== undefined && test(diff);
-      };
-    }
-  }
-}
-function operatorKeys(condition) {
-  const keys = Object.keys(condition);
-  const dollars = keys.filter((key) => key.startsWith("$"));
-  if (dollars.length === 0) {
-    return null;
-  }
-  return dollars.length === keys.length ? keys : [];
-}
-function compileCondition(key, condition) {
-  const where = `where.${key}`;
-  if (!isPlainObject(condition)) {
-    return (actual) => sameValue(actual, condition);
-  }
-  const ops = operatorKeys(condition);
-  if (ops === null) {
-    return (actual) => deepEqual(comparable(actual), condition);
-  }
-  if (ops.length === 0) {
-    throw new TypeError(`${where}: cannot mix $operators with plain keys in one condition`);
-  }
-  const tests = ops.map((op) => {
-    if (!OPERATORS.has(op)) {
-      throw new TypeError(`${where}: unknown operator "${op}" (use ${[...OPERATORS].join(", ")})`);
-    }
-    return operatorTest(where, op, condition[op]);
-  });
-  return (actual) => tests.every((test) => test(actual));
-}
-function compileWhere(where) {
-  if (where === undefined) {
-    return Object.assign(() => true, { why: nothing });
-  }
-  if (!isPlainObject(where)) {
-    throw new TypeError(`"where" must be an object mapping frontmatter fields to conditions`);
-  }
-  const tests = Object.entries(where).map(([key, condition]) => {
-    if (key.startsWith("$")) {
-      throw new TypeError(`where.${key}: top-level operators are not supported, conditions on different fields already combine with AND`);
-    }
-    return { key, test: compileCondition(key, condition) };
-  });
-  return Object.assign((data) => tests.every(({ key, test }) => test(readField(data, key))), {
-    why: (data) => tests.find(({ key, test }) => !test(readField(data, key)))?.key
-  });
-}
-var nothing = () => {}, REGEXP_SPECIAL, MAX_STAR_RUNS = 4, OPERATORS;
+var nothing2 = () => {}, REGEXP_SPECIAL, MAX_STAR_RUNS = 4;
 var init_content_rules = __esm(() => {
   init_guards();
+  init_content_query();
   REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/g;
-  OPERATORS = new Set(["$eq", "$ne", "$in", "$nin", "$exists", "$gt", "$gte", "$lt", "$lte"]);
 });
 
 // ../../node_modules/bail/index.js
@@ -41277,6 +41328,9 @@ function normalizeAllowlist(allowlist) {
   return allowlist instanceof Set ? allowlist : new Set(allowlist);
 }
 function hasJxProps(el) {
+  if (isTemplateString(el.children)) {
+    return true;
+  }
   for (const key of Object.keys(el)) {
     if (key === "tagName" || key === "children" || key === "textContent" || key === "innerHTML" || key === "attributes") {
       continue;
@@ -41490,7 +41544,7 @@ function collectDirectiveAttrs(el) {
       continue;
     }
     if (key === "children") {
-      if (isJsonObject(value)) {
+      if (isJsonObject(value) || isTemplateString(value)) {
         propsObj.children = value;
       }
       continue;

package/dist/serialize.js

@@ -892,6 +892,9 @@ function isRef(value) {
 function isNodeObject(value) {
   return isJsonObject(value);
 }
+function isTemplateString(value) {
+  return typeof value === "string" && value.includes("${");
+}
 function isPlainTagName(tagName) {
   return typeof tagName === "string";
 }
@@ -40964,6 +40967,9 @@ function normalizeAllowlist(allowlist) {
   return allowlist instanceof Set ? allowlist : new Set(allowlist);
 }
 function hasJxProps(el) {
+  if (isTemplateString(el.children)) {
+    return true;
+  }
   for (const key of Object.keys(el)) {
     if (key === "tagName" || key === "children" || key === "textContent" || key === "innerHTML" || key === "attributes") {
       continue;
@@ -41177,7 +41183,7 @@ function collectDirectiveAttrs(el) {
       continue;
     }
     if (key === "children") {
-      if (isJsonObject(value)) {
+      if (isJsonObject(value) || isTemplateString(value)) {
         propsObj.children = value;
       }
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/parser",
-  "version": "4.2.0",
+  "version": "4.3.1",
   "description": "Jx markdown parser and external class integration",
   "license": "MIT",
   "repository": {
@@ -48,8 +48,8 @@
     "upgrade": "bun update --latest && bun install"
   },
   "dependencies": {
-    "@jxsuite/markup": "^1.0.3",
-    "@jxsuite/schema": "^5.1.0",
+    "@jxsuite/markup": "^1.0.5",
+    "@jxsuite/schema": "^5.3.0",
     "@shikijs/langs": "^4.5.0",
     "@shikijs/themes": "^4.5.0",
     "glob": "^14.0.3",
@@ -67,7 +67,7 @@
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^21.0.4",
-    "@jxsuite/runtime": "^6.0.2",
+    "@jxsuite/runtime": "^6.2.0",
     "@jxsuite/test-support": "^0.0.0",
     "@types/mdast": "^4.0.4",
     "ajv": "^8.20.0"

package/schemas/project.fragment.schema.json

@@ -100,16 +100,76 @@
                       "type": "boolean"
                     },
                     "$gt": {
-                      "type": ["string", "number"]
+                      "anyOf": [
+                        {
+                          "type": ["string", "number"]
+                        },
+                        {
+                          "type": "object",
+                          "description": "The moment the rule is evaluated: the build machine's real clock.",
+                          "properties": {
+                            "$now": {
+                              "const": true
+                            }
+                          },
+                          "required": ["$now"],
+                          "additionalProperties": false
+                        }
+                      ]
                     },
                     "$gte": {
-                      "type": ["string", "number"]
+                      "anyOf": [
+                        {
+                          "type": ["string", "number"]
+                        },
+                        {
+                          "type": "object",
+                          "description": "The moment the rule is evaluated: the build machine's real clock.",
+                          "properties": {
+                            "$now": {
+                              "const": true
+                            }
+                          },
+                          "required": ["$now"],
+                          "additionalProperties": false
+                        }
+                      ]
                     },
                     "$lt": {
-                      "type": ["string", "number"]
+                      "anyOf": [
+                        {
+                          "type": ["string", "number"]
+                        },
+                        {
+                          "type": "object",
+                          "description": "The moment the rule is evaluated: the build machine's real clock.",
+                          "properties": {
+                            "$now": {
+                              "const": true
+                            }
+                          },
+                          "required": ["$now"],
+                          "additionalProperties": false
+                        }
+                      ]
                     },
                     "$lte": {
-                      "type": ["string", "number"]
+                      "anyOf": [
+                        {
+                          "type": ["string", "number"]
+                        },
+                        {
+                          "type": "object",
+                          "description": "The moment the rule is evaluated: the build machine's real clock.",
+                          "properties": {
+                            "$now": {
+                              "const": true
+                            }
+                          },
+                          "required": ["$now"],
+                          "additionalProperties": false
+                        }
+                      ]
                     }
                   }
                 },
@@ -133,6 +193,165 @@
               }
             ]
           },
+          "hold": {
+            "description": "What keeps an entry out of a production build while authors still see it. Any rule matching holds the entry, and the first names why. `jx build` leaves held entries out, `jx build --include-held`, `jx dev` and Studio keep them. Jx gives no field a meaning of its own: a project names its fields and says here what they imply.",
+            "type": "array",
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["label", "when"],
+              "properties": {
+                "label": {
+                  "description": "The words every surface shows for an entry this rule holds.",
+                  "type": "string",
+                  "minLength": 1
+                },
+                "when": {
+                  "type": "object",
+                  "propertyNames": {
+                    "pattern": "^[^$]"
+                  },
+                  "additionalProperties": {
+                    "anyOf": [
+                      {
+                        "type": "object",
+                        "propertyNames": {
+                          "enum": [
+                            "$eq",
+                            "$ne",
+                            "$in",
+                            "$nin",
+                            "$exists",
+                            "$gt",
+                            "$gte",
+                            "$lt",
+                            "$lte"
+                          ]
+                        },
+                        "minProperties": 1,
+                        "properties": {
+                          "$eq": {},
+                          "$ne": {},
+                          "$in": {
+                            "type": "array"
+                          },
+                          "$nin": {
+                            "type": "array"
+                          },
+                          "$exists": {
+                            "type": "boolean"
+                          },
+                          "$gt": {
+                            "anyOf": [
+                              {
+                                "type": ["string", "number"]
+                              },
+                              {
+                                "type": "object",
+                                "description": "The moment the rule is evaluated: the build machine's real clock.",
+                                "properties": {
+                                  "$now": {
+                                    "const": true
+                                  }
+                                },
+                                "required": ["$now"],
+                                "additionalProperties": false
+                              }
+                            ]
+                          },
+                          "$gte": {
+                            "anyOf": [
+                              {
+                                "type": ["string", "number"]
+                              },
+                              {
+                                "type": "object",
+                                "description": "The moment the rule is evaluated: the build machine's real clock.",
+                                "properties": {
+                                  "$now": {
+                                    "const": true
+                                  }
+                                },
+                                "required": ["$now"],
+                                "additionalProperties": false
+                              }
+                            ]
+                          },
+                          "$lt": {
+                            "anyOf": [
+                              {
+                                "type": ["string", "number"]
+                              },
+                              {
+                                "type": "object",
+                                "description": "The moment the rule is evaluated: the build machine's real clock.",
+                                "properties": {
+                                  "$now": {
+                                    "const": true
+                                  }
+                                },
+                                "required": ["$now"],
+                                "additionalProperties": false
+                              }
+                            ]
+                          },
+                          "$lte": {
+                            "anyOf": [
+                              {
+                                "type": ["string", "number"]
+                              },
+                              {
+                                "type": "object",
+                                "description": "The moment the rule is evaluated: the build machine's real clock.",
+                                "properties": {
+                                  "$now": {
+                                    "const": true
+                                  }
+                                },
+                                "required": ["$now"],
+                                "additionalProperties": false
+                              }
+                            ]
+                          }
+                        }
+                      },
+                      {
+                        "type": ["string", "number", "boolean", "null", "array"]
+                      },
+                      {
+                        "type": "object",
+                        "propertyNames": {
+                          "pattern": "^[^$]"
+                        }
+                      }
+                    ]
+                  },
+                  "description": "The frontmatter that matches this rule, with the grammar of `where`.",
+                  "minProperties": 1
+                }
+              }
+            },
+            "examples": [
+              [
+                {
+                  "label": "Draft",
+                  "when": {
+                    "draft": true
+                  }
+                },
+                {
+                  "label": "Scheduled",
+                  "when": {
+                    "publishDate": {
+                      "$gt": {
+                        "$now": true
+                      }
+                    }
+                  }
+                }
+              ]
+            ]
+          },
           "idField": {
             "description": "Frontmatter field whose value is the entry id, instead of the path-derived id. An entry without the field keeps its path id and is reported.",
             "type": "string",