@diplodoc/yfmlint 1.4.0 → 1.6.0

package/build/config.d.ts

@@ -15,5 +15,6 @@ declare const _default: {
     YFM009: LogLevels;
     YFM010: LogLevels;
     YFM011: LogLevels;
+    YFM018: LogLevels;
 };
 export default _default;

package/build/index.js

@@ -21337,6 +21337,9 @@ function log(errors, logger) {
       case "warn" /* WARN */:
         logger.warn(message);
         break;
+      case "info" /* INFO */:
+        logger.info(message);
+        break;
       case "disabled" /* DISABLED */:
       default:
         break;
@@ -21367,12 +21370,14 @@ var config_default = {
   // Term used without definition
   YFM008: "warn" /* WARN */,
   // Term inside definition not allowed
-  YFM009: "warn" /* WARN */,
+  YFM009: "error" /* ERROR */,
   // Term definition used not at the end of file
   YFM010: "warn" /* WARN */,
   // Autotitle anchor is missed
-  YFM011: "warn" /* WARN */
+  YFM011: "warn" /* WARN */,
   // Max svg size
+  YFM018: "info" /* INFO */
+  // Term definition from include
 };
 
 // src/rules/index.ts
@@ -21388,7 +21393,8 @@ __export(rules_exports, {
   yfm008: () => yfm008,
   yfm009: () => yfm009,
   yfm010: () => yfm010,
-  yfm011: () => yfm011
+  yfm011: () => yfm011,
+  yfm018: () => yfm018
 });
 
 // src/rules/yfm001.ts
@@ -21766,6 +21772,56 @@ var yfm008 = {
 };
 
 // src/rules/yfm009.ts
+function isFromInclude(token) {
+  return token.attrGet("from-include") === "true";
+}
+function isLintMarker(token) {
+  return token.type === "__yfm_lint";
+}
+function findMatchingDfnOpen(tokens, closeIndex) {
+  let depth = 0;
+  for (let j = closeIndex; j >= 0; j--) {
+    if (tokens[j].type === "dfn_close") depth++;
+    if (tokens[j].type === "dfn_open") {
+      depth--;
+      if (depth === 0) return j;
+    }
+  }
+  return -1;
+}
+function skipNonContent(tokens, from) {
+  let pos = from;
+  while (pos < tokens.length) {
+    if (isLintMarker(tokens[pos])) {
+      pos++;
+      continue;
+    }
+    if (tokens[pos].type === "dfn_open" && isFromInclude(tokens[pos])) {
+      pos = skipDfnPair(tokens, pos);
+      continue;
+    }
+    break;
+  }
+  return pos;
+}
+function skipDfnPair(tokens, from) {
+  let depth = 1;
+  let pos = from + 1;
+  while (pos < tokens.length && depth > 0) {
+    if (tokens[pos].type === "dfn_open") depth++;
+    if (tokens[pos].type === "dfn_close") depth--;
+    pos++;
+  }
+  return pos;
+}
+function isLocalDfnClose(tokens, index) {
+  if (tokens[index].type !== "dfn_close") return false;
+  const openIndex = findMatchingDfnOpen(tokens, index);
+  return openIndex < 0 || !isFromInclude(tokens[openIndex]);
+}
+function hasLocalDfnOpenAt(tokens, index) {
+  return index < tokens.length && tokens[index].type === "dfn_open" && !isFromInclude(tokens[index]);
+}
 var yfm009 = {
   names: ["YFM009", "no-term-definition-in-content"],
   description: "Term definition should be placed at the end of file",
@@ -21777,23 +21833,19 @@ var yfm009 = {
     if (!config) {
       return;
     }
-    let lastCloseIndex = -1;
     const tokens = params2.parsers.markdownit.tokens;
     const size = tokens.length;
+    let lastLocalCloseIndex = -1;
     for (let i = 0; i < size; i++) {
-      if (tokens[i].type === "dfn_close") {
-        lastCloseIndex = i;
-      }
-      if (tokens[i].type !== "dfn_close") {
+      if (!isLocalDfnClose(tokens, i)) {
         continue;
       }
+      lastLocalCloseIndex = i;
       if (i === size - 1) {
         continue;
       }
-      if (tokens[i + 1].type === "dfn_open") {
-        continue;
-      }
-      if (i < size - 2 && tokens[i + 2].type === "dfn_open") {
+      const nextReal = skipNonContent(tokens, i + 1);
+      if (nextReal >= size || hasLocalDfnOpenAt(tokens, nextReal)) {
         continue;
       }
       onError({
@@ -21801,12 +21853,13 @@ var yfm009 = {
         detail: "There is a content between term definition. All term defitions should be placed at the end of file."
       });
     }
-    if (lastCloseIndex === -1) {
+    if (lastLocalCloseIndex === -1) {
       return;
     }
-    if (lastCloseIndex !== size - 1) {
+    const tailPos = skipNonContent(tokens, lastLocalCloseIndex + 1);
+    if (tailPos < size) {
       onError({
-        lineNumber: ((_b = tokens[lastCloseIndex + 1]) == null ? void 0 : _b.lineNumber) || tokens[lastCloseIndex].lineNumber || 1,
+        lineNumber: ((_b = tokens[lastLocalCloseIndex + 1]) == null ? void 0 : _b.lineNumber) || tokens[lastLocalCloseIndex].lineNumber || 1,
         detail: "The file must end with term only."
       });
     }
@@ -21866,6 +21919,34 @@ var yfm011 = {
   }
 };
 
+// src/rules/yfm018.ts
+var yfm018 = {
+  names: ["YFM018", "term-definition-from-include"],
+  description: "Term definition comes from an included file",
+  tags: ["term"],
+  parser: "markdownit",
+  function: function YFM018(params2, onError) {
+    const { config } = params2;
+    if (!config) {
+      return;
+    }
+    const tokens = params2.parsers.markdownit.tokens;
+    const size = tokens.length;
+    for (let i = 0; i < size; i++) {
+      if (tokens[i].type !== "dfn_open") {
+        continue;
+      }
+      if (tokens[i].attrGet("from-include") !== "true") {
+        continue;
+      }
+      onError({
+        lineNumber: tokens[i].lineNumber || 1,
+        detail: "Term definition is provided via include. Consider moving it to the end of the page or defining the term locally."
+      });
+    }
+  }
+};
+
 // src/index.ts
 async function yfmlint(content3, path3, opts) {
   const { lint } = await Promise.resolve().then(() => (init_exports_promise(), exports_promise_exports));