@jxsuite/parser 4.2.0 → 4.3.1

package/dist/content-loader.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";
 }
@@ -272,6 +275,195 @@ var init_alerts = __esm(() => {
   LINE_END = /\r?\n/;
 });
 
+// ../../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`\$&`);
@@ -397,7 +589,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`);
@@ -437,152 +629,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
@@ -34647,7 +34698,7 @@ function isNonRelativeRef(value) {
 }
 var DOCUMENT_EXTENSIONS = new Set([".md", ".markdown", ".mdx"]);
 function mountFilterFor(def) {
-  if (!def || def.exclude === undefined && def.where === undefined && def.route === undefined) {
+  if (!def || def.exclude === undefined && def.where === undefined && def.hold === undefined && def.route === undefined) {
     return;
   }
   let exclude;
@@ -34799,11 +34850,11 @@ function loadContentConfig(projectRoot, projectConfig) {
   const config = { content: projectConfig?.content ?? {} };
   return { config, contentDir };
 }
-async function loadContentSection(section, root, formats, projectConfig) {
+async function loadContentSection(section, root, formats, projectConfig, includeHeld) {
   const contentTypes = new Map;
   const mounts = sectionMounts(section, root, projectConfig);
   for (const name of Object.keys(section)) {
-    contentTypes.set(name, await loadSectionType(name, { formats, mounts, projectConfig, root, section }));
+    contentTypes.set(name, await loadSectionType(name, { formats, includeHeld, mounts, projectConfig, root, section }));
   }
   return contentTypes;
 }
@@ -34814,7 +34865,7 @@ function sectionMounts(section, root, projectConfig) {
   ]));
 }
 async function loadSectionType(name, source) {
-  const { section, root, formats, projectConfig, mounts, onDeferred } = source;
+  const { section, root, formats, projectConfig, mounts, onDeferred, includeHeld } = source;
   const contentTypeDef = section[name];
   if (!contentTypeDef) {
     return [];
@@ -34823,6 +34874,7 @@ async function loadSectionType(name, source) {
   const typeSource = contentTypeDef.source;
   if (!isString(typeSource) || !typeSource.includes(LOCALE_PLACEHOLDER)) {
     return await loadContentType(name, contentTypeDef, root, formats, {
+      includeHeld,
       mount: mounts.get(name),
       projectConfig,
       ...deferral
@@ -34837,6 +34889,7 @@ async function loadSectionType(name, source) {
   for (const locale of locales) {
     const localized = { ...contentTypeDef, source: localeSource(root, typeSource, locale) };
     const entries = await loadContentType(name, localized, root, formats, {
+      includeHeld,
       locale,
       mount: mounts.get(`${name}/${locale}`),
       projectConfig,
@@ -34863,6 +34916,7 @@ var KNOWN_TYPE_KEYS = [
   "alerts",
   "exclude",
   "format",
+  "hold",
   "idField",
   "indexRoute",
   "links",
@@ -34922,7 +34976,8 @@ function compileTypeRules(name, def) {
       idField: def.idField,
       links,
       route: parseRouteConfig(def.route, def.indexRoute, name),
-      where: def.where === undefined ? null : compileWhere(def.where)
+      where: def.where === undefined ? null : compileWhere(def.where),
+      hold: def.hold === undefined ? null : compileHold(def.hold)
     };
   } catch (error) {
     const message = errorMessage(error);
@@ -34937,6 +34992,7 @@ function finishEntries(files, ctx) {
   const { name, rules } = ctx;
   const kept = [];
   const unpublished = new Map;
+  const held = [];
   let loadedCount = 0;
   for (const file of files) {
     const keep = [];
@@ -34946,8 +35002,19 @@ function finishEntries(files, ctx) {
         if (file.rel !== null && file.entries.length === 1) {
           unpublished.set(file.rel, `left out by where.${rules.where.why(entry.data) ?? "filter"}`);
         }
-      } else {
+        continue;
+      }
+      const hold = rules.hold?.(entry.data);
+      if (hold === undefined) {
+        keep.push(entry);
+      } else if (ctx.includeHeld === true) {
+        entry._meta = { ...entry._meta, hold };
         keep.push(entry);
+      } else {
+        held.push(`${file.rel ?? entry.id} (${hold})`);
+        if (file.rel !== null && file.entries.length === 1) {
+          unpublished.set(file.rel, `held: ${hold}`);
+        }
       }
     }
     if (keep.length > 0) {
@@ -34958,6 +35025,9 @@ function finishEntries(files, ctx) {
     const [first] = files.flatMap((file) => file.entries);
     console.warn(`Content type "${name}": "where" left out all ${loadedCount} entries, so the collection is ` + `empty (it failed on "${first ? rules.where.why(first.data) ?? "?" : "?"}" for the first one). ` + `Check the field names and the value types: YAML \`true\` is a boolean, "true" is text.`);
   }
+  if (held.length > 0) {
+    console.info(`Content type "${name}": holding ${held.length} from this build: ${held.join(", ")}`);
+  }
   for (const file of kept) {
     for (const entry of file.entries) {
       if (file.rel !== null) {
@@ -35225,12 +35295,13 @@ async function loadContentType(name, contentTypeDef, projectRoot, registry, opti
   if (!source) {
     return [];
   }
-  const { mount, projectConfig, locale, deferBody, onDeferred } = options;
+  const { mount, projectConfig, locale, deferBody, onDeferred, includeHeld } = options;
   const { schema } = contentTypeDef;
   const rules = compileTypeRules(name, contentTypeDef);
   const finishContext = (extra) => ({
     coerceDates: false,
     entryExtensions: new Set,
+    includeHeld,
     locale,
     mount,
     name,
@@ -35519,7 +35590,7 @@ class ContentStore extends Map {
   }
   static async whole(source) {
     const store = new ContentStore(source);
-    const loaded = await loadContentSection(source.section, source.root, source.formats, source.projectConfig);
+    const loaded = await loadContentSection(source.section, source.root, source.formats, source.projectConfig, source.includeHeld);
     for (const [name, entries] of loaded) {
       store.#adopt(name, entries);
       store.#loads.set(name, Promise.resolve());
@@ -35594,8 +35665,9 @@ class ContentStore extends Map {
   #loadType(name) {
     let load = this.#loads.get(name);
     if (!load) {
-      const { section, root, formats, projectConfig } = this.#source;
+      const { section, root, formats, projectConfig, includeHeld } = this.#source;
       load = loadSectionType(name, {
+        includeHeld,
         formats,
         mounts: this.#mounts,
         onDeferred: (entry, completeBody) => {
@@ -35646,6 +35718,7 @@ class Content {
   static async projectData(sectionValue, ctx) {
     const source = {
       formats: ctx.registry.formats,
+      includeHeld: ctx.includeHeld,
       projectConfig: ctx.projectConfig,
       root: ctx.root,
       section: sectionValue ?? {}

package/dist/content.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";
 }