textlint-plugin-typst 1.0.0 → 1.0.1

package/README.md

@@ -40,6 +40,8 @@ bun add textlint-plugin-typst
 
 ## Syntax support
 
+This plugin supports the syntax of Typst [v0.11.1](https://github.com/typst/typst/releases/tag/v0.11.1).
+
 Legend for syntax support:
 
 - ✅: Supported
@@ -87,6 +89,21 @@ Disables all rules between comments
 This is error text.
 ```
 
+Also, you can use single-line comments.
+
+```typst
+This is error text.
+
+// textlint-disable
+
+This is ignored text by rule.
+Disables all rules between comments
+
+// textlint-enable
+
+This is error text.
+```
+
 ## Contributing
 
 This project is still under development, so please feel free to contribute!

package/lib/index.js

@@ -1517,7 +1517,12 @@ var require_stringify = __commonJS({
       let obj;
       if (identity.isScalar(item)) {
         obj = item.value;
-        const match = tags.filter((t) => t.identify?.(obj));
+        let match = tags.filter((t) => t.identify?.(obj));
+        if (match.length > 1) {
+          const testMatch = match.filter((t) => t.test);
+          if (testMatch.length > 0)
+            match = testMatch;
+        }
         tagObj = match.find((t) => t.format === item.format) ?? match.find((t) => !t.format);
       } else {
         obj = item;
@@ -1731,28 +1736,78 @@ var require_log = __commonJS({
   }
 });
 
+// node_modules/yaml/dist/schema/yaml-1.1/merge.js
+var require_merge = __commonJS({
+  "node_modules/yaml/dist/schema/yaml-1.1/merge.js"(exports2) {
+    "use strict";
+    var identity = require_identity();
+    var Scalar = require_Scalar();
+    var MERGE_KEY = "<<";
+    var merge = {
+      identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
+      default: "key",
+      tag: "tag:yaml.org,2002:merge",
+      test: /^<<$/,
+      resolve: () => Object.assign(new Scalar.Scalar(Symbol(MERGE_KEY)), {
+        addToJSMap: addMergeToJSMap
+      }),
+      stringify: () => MERGE_KEY
+    };
+    var isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
+    function addMergeToJSMap(ctx, map, value) {
+      value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+      if (identity.isSeq(value))
+        for (const it of value.items)
+          mergeValue(ctx, map, it);
+      else if (Array.isArray(value))
+        for (const it of value)
+          mergeValue(ctx, map, it);
+      else
+        mergeValue(ctx, map, value);
+    }
+    function mergeValue(ctx, map, value) {
+      const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+      if (!identity.isMap(source))
+        throw new Error("Merge sources must be maps or map aliases");
+      const srcMap = source.toJSON(null, ctx, Map);
+      for (const [key, value2] of srcMap) {
+        if (map instanceof Map) {
+          if (!map.has(key))
+            map.set(key, value2);
+        } else if (map instanceof Set) {
+          map.add(key);
+        } else if (!Object.prototype.hasOwnProperty.call(map, key)) {
+          Object.defineProperty(map, key, {
+            value: value2,
+            writable: true,
+            enumerable: true,
+            configurable: true
+          });
+        }
+      }
+      return map;
+    }
+    exports2.addMergeToJSMap = addMergeToJSMap;
+    exports2.isMergeKey = isMergeKey;
+    exports2.merge = merge;
+  }
+});
+
 // node_modules/yaml/dist/nodes/addPairToJSMap.js
 var require_addPairToJSMap = __commonJS({
   "node_modules/yaml/dist/nodes/addPairToJSMap.js"(exports2) {
     "use strict";
     var log = require_log();
+    var merge = require_merge();
     var stringify = require_stringify();
     var identity = require_identity();
-    var Scalar = require_Scalar();
     var toJS = require_toJS();
-    var MERGE_KEY = "<<";
     function addPairToJSMap(ctx, map, { key, value }) {
-      if (ctx?.doc.schema.merge && isMergeKey(key)) {
-        value = identity.isAlias(value) ? value.resolve(ctx.doc) : value;
-        if (identity.isSeq(value))
-          for (const it of value.items)
-            mergeToJSMap(ctx, map, it);
-        else if (Array.isArray(value))
-          for (const it of value)
-            mergeToJSMap(ctx, map, it);
-        else
-          mergeToJSMap(ctx, map, value);
-      } else {
+      if (identity.isNode(key) && key.addToJSMap)
+        key.addToJSMap(ctx, map, value);
+      else if (merge.isMergeKey(ctx, key))
+        merge.addMergeToJSMap(ctx, map, value);
+      else {
         const jsKey = toJS.toJS(key, "", ctx);
         if (map instanceof Map) {
           map.set(jsKey, toJS.toJS(value, jsKey, ctx));
@@ -1774,29 +1829,6 @@ var require_addPairToJSMap = __commonJS({
       }
       return map;
     }
-    var isMergeKey = (key) => key === MERGE_KEY || identity.isScalar(key) && key.value === MERGE_KEY && (!key.type || key.type === Scalar.Scalar.PLAIN);
-    function mergeToJSMap(ctx, map, value) {
-      const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
-      if (!identity.isMap(source))
-        throw new Error("Merge sources must be maps or map aliases");
-      const srcMap = source.toJSON(null, ctx, Map);
-      for (const [key, value2] of srcMap) {
-        if (map instanceof Map) {
-          if (!map.has(key))
-            map.set(key, value2);
-        } else if (map instanceof Set) {
-          map.add(key);
-        } else if (!Object.prototype.hasOwnProperty.call(map, key)) {
-          Object.defineProperty(map, key, {
-            value: value2,
-            writable: true,
-            enumerable: true,
-            configurable: true
-          });
-        }
-      }
-      return map;
-    }
     function stringifyKey(key, jsKey, ctx) {
       if (jsKey === null)
         return "";
@@ -3156,6 +3188,7 @@ var require_schema3 = __commonJS({
     var bool = require_bool2();
     var float = require_float2();
     var int = require_int2();
+    var merge = require_merge();
     var omap = require_omap();
     var pairs = require_pairs();
     var set = require_set();
@@ -3175,6 +3208,7 @@ var require_schema3 = __commonJS({
       float.floatExp,
       float.float,
       binary.binary,
+      merge.merge,
       omap.omap,
       pairs.pairs,
       set.set,
@@ -3200,6 +3234,7 @@ var require_tags = __commonJS({
     var schema = require_schema();
     var schema$1 = require_schema2();
     var binary = require_binary();
+    var merge = require_merge();
     var omap = require_omap();
     var pairs = require_pairs();
     var schema$2 = require_schema3();
@@ -3224,6 +3259,7 @@ var require_tags = __commonJS({
       intOct: int.intOct,
       intTime: timestamp.intTime,
       map: map.map,
+      merge: merge.merge,
       null: _null.nullTag,
       omap: omap.omap,
       pairs: pairs.pairs,
@@ -3233,13 +3269,18 @@ var require_tags = __commonJS({
     };
     var coreKnownTags = {
       "tag:yaml.org,2002:binary": binary.binary,
+      "tag:yaml.org,2002:merge": merge.merge,
       "tag:yaml.org,2002:omap": omap.omap,
       "tag:yaml.org,2002:pairs": pairs.pairs,
       "tag:yaml.org,2002:set": set.set,
       "tag:yaml.org,2002:timestamp": timestamp.timestamp
     };
-    function getTags(customTags, schemaName) {
-      let tags = schemas.get(schemaName);
+    function getTags(customTags, schemaName, addMergeTag) {
+      const schemaTags = schemas.get(schemaName);
+      if (schemaTags && !customTags) {
+        return addMergeTag && !schemaTags.includes(merge.merge) ? schemaTags.concat(merge.merge) : schemaTags.slice();
+      }
+      let tags = schemaTags;
       if (!tags) {
         if (Array.isArray(customTags))
           tags = [];
@@ -3254,15 +3295,19 @@ var require_tags = __commonJS({
       } else if (typeof customTags === "function") {
         tags = customTags(tags.slice());
       }
-      return tags.map((tag) => {
-        if (typeof tag !== "string")
-          return tag;
-        const tagObj = tagsByName[tag];
-        if (tagObj)
-          return tagObj;
-        const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
-        throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
-      });
+      if (addMergeTag)
+        tags = tags.concat(merge.merge);
+      return tags.reduce((tags2, tag) => {
+        const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
+        if (!tagObj) {
+          const tagName = JSON.stringify(tag);
+          const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
+          throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
+        }
+        if (!tags2.includes(tagObj))
+          tags2.push(tagObj);
+        return tags2;
+      }, []);
     }
     exports2.coreKnownTags = coreKnownTags;
     exports2.getTags = getTags;
@@ -3282,10 +3327,9 @@ var require_Schema = __commonJS({
     var Schema = class _Schema {
       constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
         this.compat = Array.isArray(compat) ? tags.getTags(compat, "compat") : compat ? tags.getTags(null, compat) : null;
-        this.merge = !!merge;
         this.name = typeof schema === "string" && schema || "core";
         this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
-        this.tags = tags.getTags(customTags, this.name);
+        this.tags = tags.getTags(customTags, this.name, merge);
         this.toStringOptions = toStringDefaults ?? null;
         Object.defineProperty(this, identity.MAP, { value: map.map });
         Object.defineProperty(this, identity.SCALAR, { value: string.string });
@@ -3417,6 +3461,7 @@ var require_Document = __commonJS({
           logLevel: "warn",
           prettyErrors: true,
           strict: true,
+          stringKeys: false,
           uniqueKeys: true,
           version: "1.2"
         }, options);
@@ -3618,7 +3663,7 @@ var require_Document = __commonJS({
               this.directives.yaml.version = "1.1";
             else
               this.directives = new directives.Directives({ version: "1.1" });
-            opt = { merge: true, resolveKnownTags: false, schema: "yaml-1.1" };
+            opt = { resolveKnownTags: false, schema: "yaml-1.1" };
             break;
           case "1.2":
           case "next":
@@ -3626,7 +3671,7 @@ var require_Document = __commonJS({
               this.directives.yaml.version = version;
             else
               this.directives = new directives.Directives({ version });
-            opt = { merge: false, resolveKnownTags: true, schema: "core" };
+            opt = { resolveKnownTags: true, schema: "core" };
             break;
           case null:
             if (this.directives)
@@ -3959,7 +4004,7 @@ var require_util_map_includes = __commonJS({
       const { uniqueKeys } = ctx.options;
       if (uniqueKeys === false)
         return false;
-      const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || identity.isScalar(a) && identity.isScalar(b) && a.value === b.value && !(a.value === "<<" && ctx.schema.merge);
+      const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || identity.isScalar(a) && identity.isScalar(b) && a.value === b.value;
       return items.some((pair) => isEqual(pair.key, search));
     }
     exports2.mapIncludes = mapIncludes;
@@ -4018,10 +4063,12 @@ var require_resolve_block_map = __commonJS({
         } else if (keyProps.found?.indent !== bm.indent) {
           onError(offset, "BAD_INDENT", startColMsg);
         }
+        ctx.atKey = true;
         const keyStart = keyProps.end;
         const keyNode = key ? composeNode(ctx, key, keyProps, onError) : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
         if (ctx.schema.compat)
           utilFlowIndentCheck.flowIndentCheck(bm.indent, key, onError);
+        ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
         const valueProps = resolveProps.resolveProps(sep ?? [], {
@@ -4084,6 +4131,8 @@ var require_resolve_block_seq = __commonJS({
       const seq = new NodeClass(ctx.schema);
       if (ctx.atRoot)
         ctx.atRoot = false;
+      if (ctx.atKey)
+        ctx.atKey = false;
       let offset = bs.offset;
       let commentEnd = null;
       for (const { start, value } of bs.items) {
@@ -4187,6 +4236,8 @@ var require_resolve_flow_collection = __commonJS({
       const atRoot = ctx.atRoot;
       if (atRoot)
         ctx.atRoot = false;
+      if (ctx.atKey)
+        ctx.atKey = false;
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
@@ -4263,10 +4314,12 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(value))
             onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
         } else {
+          ctx.atKey = true;
           const keyStart = props.end;
           const keyNode = key ? composeNode(ctx, key, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError);
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
+          ctx.atKey = false;
           const valueProps = resolveProps.resolveProps(sep ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
@@ -4829,7 +4882,15 @@ var require_compose_scalar = __commonJS({
     function composeScalar(ctx, token, tagToken, onError) {
       const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
       const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
-      const tag = tagToken && tagName ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError) : token.type === "scalar" ? findScalarTagByTest(ctx, value, token, onError) : ctx.schema[identity.SCALAR];
+      let tag;
+      if (ctx.options.stringKeys && ctx.atKey) {
+        tag = ctx.schema[identity.SCALAR];
+      } else if (tagName)
+        tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+      else if (token.type === "scalar")
+        tag = findScalarTagByTest(ctx, value, token, onError);
+      else
+        tag = ctx.schema[identity.SCALAR];
       let scalar;
       try {
         const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
@@ -4874,8 +4935,8 @@ var require_compose_scalar = __commonJS({
       onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
       return schema[identity.SCALAR];
     }
-    function findScalarTagByTest({ directives, schema }, value, token, onError) {
-      const tag = schema.tags.find((tag2) => tag2.default && tag2.test?.test(value)) || schema[identity.SCALAR];
+    function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) {
+      const tag = schema.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value)) || schema[identity.SCALAR];
       if (schema.compat) {
         const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema[identity.SCALAR];
         if (tag.tag !== compat.tag) {
@@ -4927,12 +4988,14 @@ var require_compose_node = __commonJS({
   "node_modules/yaml/dist/compose/compose-node.js"(exports2) {
     "use strict";
     var Alias = require_Alias();
+    var identity = require_identity();
     var composeCollection = require_compose_collection();
     var composeScalar = require_compose_scalar();
     var resolveEnd = require_resolve_end();
     var utilEmptyScalarPosition = require_util_empty_scalar_position();
     var CN = { composeNode, composeEmptyNode };
     function composeNode(ctx, token, props, onError) {
+      const atKey = ctx.atKey;
       const { spaceBefore, comment, anchor, tag } = props;
       let node;
       let isSrcToken = true;
@@ -4966,6 +5029,10 @@ var require_compose_node = __commonJS({
       }
       if (anchor && node.anchor === "")
         onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+      if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
+        const msg = "With stringKeys, all keys must be strings";
+        onError(tag ?? token, "NON_STRING_KEY", msg);
+      }
       if (spaceBefore)
         node.spaceBefore = true;
       if (comment) {
@@ -5029,6 +5096,7 @@ var require_compose_doc = __commonJS({
       const opts = Object.assign({ _directives: directives }, options);
       const doc = new Document.Document(void 0, opts);
       const ctx = {
+        atKey: false,
         atRoot: true,
         directives: doc.directives,
         options: doc.options,
@@ -7141,6 +7209,7 @@ var require_public_api = __commonJS({
     var Document = require_Document();
     var errors = require_errors();
     var log = require_log();
+    var identity = require_identity();
     var lineCounter = require_line_counter();
     var parser = require_parser();
     function parseOptions(options) {
@@ -7218,6 +7287,8 @@ var require_public_api = __commonJS({
         if (!keepUndefined)
           return void 0;
       }
+      if (identity.isDocument(value) && !_replacer)
+        return value.toString(options);
       return new Document.Document(value, _replacer, options).toString(options);
     }
     exports2.parse = parse2;
@@ -7793,20 +7864,6 @@ var convertRawTypstAstStringToObject = (rawTypstAstString) => {
   const parsed = (0, import_yaml.parse)(escapedRawTypstAstYamlString);
   return parsed.ast;
 };
-var convertTypstAstNodeTypeToTextlintNodeType = (typstAstNodeType) => {
-  const nodeTypeMap = /* @__PURE__ */ new Map([
-    [/^Marked::Heading$/, import_ast_node_types.ASTNodeTypes.Header],
-    [/^Marked::Text/, import_ast_node_types.ASTNodeTypes.Str],
-    [/^Marked::Parbreak/, import_ast_node_types.ASTNodeTypes.Break],
-    [/^Escape::Linebreak/, import_ast_node_types.ASTNodeTypes.Break]
-  ]);
-  for (const [pattern, nodeType] of nodeTypeMap) {
-    if (pattern.test(typstAstNodeType)) {
-      return nodeType;
-    }
-  }
-  return typstAstNodeType;
-};
 var extractRawSourceByLocation = (typstSource, location) => {
   const { start, end } = location;
   const lines = typstSource.split("\n");
@@ -7927,16 +7984,32 @@ var convertRawTypstAstObjectToTextlintAstObject = (rawTypstAstObject, typstSourc
       node.value = extractRawSourceByLocation(typstSource, location);
     }
     const endOffset = currentOffset + nodeLength;
-    node.type = convertTypstAstNodeTypeToTextlintNodeType(
-      extractNodeType(node.s)
-    );
     node.raw = extractRawSourceByLocation(typstSource, location);
     node.range = [startOffset, endOffset];
     node.loc = location;
+    node.type = extractNodeType(node.s);
+    if (/^Marked::Heading$/.test(node.type)) {
+      node.type = import_ast_node_types.ASTNodeTypes.Header;
+    }
+    if (/^Marked::Text/.test(node.type)) {
+      node.type = import_ast_node_types.ASTNodeTypes.Str;
+    }
+    if (/^Marked::Parbreak/.test(node.type)) {
+      node.type = import_ast_node_types.ASTNodeTypes.Break;
+    }
+    if (/^Escape::Linebreak/.test(node.type)) {
+      node.type = import_ast_node_types.ASTNodeTypes.Break;
+    }
     if (node.type === "Marked::Raw") {
       if (node.loc.start.line === node.loc.end.line) {
         node.type = import_ast_node_types.ASTNodeTypes.Code;
-        node.value = node.raw.replace(/`([\s\S]*?)`/, "$1");
+        if (/^```([\s\S]*?)```$/.test(node.raw)) {
+          const codeBlockPattern = /^```(\w+)?\s([\s\S]*?)\s*```$/;
+          const match = node.raw.match(codeBlockPattern);
+          node.value = match ? match[2].trim() : "";
+        } else {
+          node.value = node.raw.replace(/`([\s\S]*?)`/, "$1");
+        }
       } else {
         node.type = import_ast_node_types.ASTNodeTypes.CodeBlock;
         node.value = node.raw.replace(/```(?:\w*)\n([\s\S]*?)\n```/, "$1");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "textlint-plugin-typst",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"description": "textlint plugin to lint Typst",
 	"keywords": ["textlint", "textlintplugin", "plugin", "lint", "typst"],
 	"repository": "https://github.com/3w36zj6/textlint-plugin-typst",
@@ -21,7 +21,8 @@
 		"lint:apply": "biome lint --apply .",
 		"check": "biome check .",
 		"check:write": "biome check --write .",
-		"test": "vitest"
+		"test": "vitest",
+		"update-fixtures": "bun ./test/update-fixtures.ts && biome check --write ./test/fixtures"
 	},
 	"dependencies": {
 		"@myriaddreamin/typst-ts-web-compiler": "^0.5.0-rc7",