@markuplint/ml-spec 5.6.0 → 5.6.1

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.6.1](https://github.com/markuplint/markuplint/compare/v5.6.0...v5.6.1) (2026-11-13)
+
+### Bug Fixes
+
+* **ml-spec:** let a directive pattern declare the key of its repeat ([df95b4c](https://github.com/markuplint/markuplint/commit/df95b4cd56753fa4c665991f6bc091e4c0620225))
+
+
 # [5.6.0](https://github.com/markuplint/markuplint/compare/v5.5.0...v5.6.0) (2026-11-12)
 
 ### Bug Fixes

package/lib/types/index.d.ts

@@ -155,11 +155,58 @@ export type DirectivePattern = {
      */
     readonly valueType?: 'string' | 'number' | 'boolean' | 'code';
     /**
-     * If true, the attribute can appear multiple times on the same element.
-     * Can also be a string array of potentialName values for which
-     * duplication is allowed (e.g., ['class', 'style']).
+     * If true, the attribute is not a repeat of an attribute of the same name (`:class` beside `class`,
+     * which Vue merges). Can also be a string array of potentialName values for which this holds
+     * (e.g., ['class', 'style']).
+     *
+     * It is not whether the attribute may be written twice: that is told by {@link DirectivePattern.duplicateKey}
+     * (without it, the same spelling of a name that is not `true` is a repeat, and `true` is never one).
      */
     readonly isDuplicatable?: true | readonly string[];
+    /**
+     * The key under which the framework counts this directive as written twice, as a template that takes the
+     * captures of `pattern` (`$1`, `$2`, …) as they are spelled. Two attributes of an element with the same key
+     * are a repeat, whatever name the directive resolves to (`potentialName`): a framework tells a repeat by
+     * what it keeps of the name, and a directive is not an attribute of the DOM.
+     *
+     * Without it, a pattern is keyed by the name as it is written (how a framework that rejects only the
+     * same spelling of a directive tells a repeat), except a pattern with `isDuplicatable: true`, which is
+     * never a repeat (a framework that takes any number of the same directive).
+     *
+     * @example "$1" -- the key of `:view-box.camel` is its argument, `view-box` (with `duplicateKeyModifiers`, `viewBox`)
+     */
+    readonly duplicateKey?: string;
+    /**
+     * Modifiers of the directive that change {@link DirectivePattern.duplicateKey}: the modifiers are those
+     * written after the name, and a framework gives two spellings of a name that differ in them the same key
+     * (the order of them, a modifier that it does not know) or a different one (a modifier that changes the
+     * name that is bound). Only the modifiers listed here count, and a modifier is matched as it is spelled.
+     */
+    readonly duplicateKeyModifiers?: {
+        /**
+         * The capture group of `pattern` that holds the modifiers, joined with `.` and starting with it (`.prop.camel`).
+         */
+        readonly group: number;
+        /**
+         * The modifiers that turn the template into camelCase before the prefixes are put in front of it.
+         */
+        readonly camelize?: readonly string[];
+        /**
+         * The prefix that a modifier puts in front of the key. They are put in the order listed, so that
+         * the first of the listed modifiers that is written is the outermost.
+         */
+        readonly prefixes?: readonly {
+            readonly modifier: string;
+            readonly prefix: string;
+        }[];
+        /**
+         * When no prefix is put in front of the key, it is the name of an attribute (`:id.foo` binds `id`), so
+         * the element folds its case as it does for any attribute and it is a repeat of that attribute
+         * written as such (`:id`). A key with a prefix is a property or a namespaced name, which
+         * keeps its case (`.id` and `.ID` are two).
+         */
+        readonly foldedWithoutPrefix?: true;
+    };
 };
 /**
  * Reference URLs

package/lib/utils/directive-resolver.d.ts

@@ -22,6 +22,17 @@ export type DirectiveResolution = {
     readonly expressionLanguage?: ExpressionLanguage;
     readonly valueType?: 'string' | 'number' | 'boolean' | 'code';
     readonly isDuplicatable?: boolean;
+    /**
+     * Present only when the matched pattern decides it ({@link DirectivePattern.duplicateKey}): the key
+     * under which the directive counts as written twice, or `null` when it never does (a pattern that is
+     * `isDuplicatable: true` and declares no key). Absent, the key is the name as it is written.
+     */
+    readonly duplicateKey?: string | null;
+    /**
+     * Present only when the key is the name of an attribute that the element folds
+     * ({@link DirectivePattern.duplicateKeyModifiers}'s `foldedWithoutPrefix`) and no prefix is in front of it.
+     */
+    readonly duplicateKeyFolds?: true;
 };
 /**
  * Resolves an attribute name against a list of compiled directive patterns.

package/lib/utils/directive-resolver.js

@@ -1,3 +1,4 @@
+import { camelize } from '@markuplint/shared';
 const cache = new WeakMap();
 /**
  * Compiles directive patterns into RegExp objects, caching them
@@ -14,6 +15,33 @@ export function compileDirectivePatterns(patterns) {
     }
     return compiled;
 }
+/**
+ * The key of an attribute that a pattern gives, as {@link DirectivePattern.duplicateKey} says.
+ */
+function resolveDuplicateKey(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+pattern, match) {
+    if (pattern.duplicateKey == null) {
+        return { key: pattern.isDuplicatable === true ? null : undefined, folds: false };
+    }
+    const modifiers = pattern.duplicateKeyModifiers;
+    const written = new Set((modifiers ? (match[modifiers.group] ?? '') : '').split('.').filter(Boolean));
+    // Only what the directive writes is camelized (`transformBind` of Vue does so to the argument), not the
+    // text that the template puts around it
+    const camelized = modifiers?.camelize?.some(modifier => written.has(modifier)) === true;
+    const key = pattern.duplicateKey.replaceAll(/\$(\d+)/g, (_, idx) => {
+        const capture = match[Number(idx)] ?? '';
+        return camelized ? camelize(capture) : capture;
+    });
+    if (!modifiers) {
+        return { key, folds: false };
+    }
+    const prefix = (modifiers.prefixes ?? [])
+        .filter(({ modifier }) => written.has(modifier))
+        .map(({ prefix }) => prefix)
+        .join('');
+    return { key: prefix + key, folds: modifiers.foldedWithoutPrefix === true && prefix === '' };
+}
 /**
  * Resolves an attribute name against a list of compiled directive patterns.
  * Returns the first match's resolution, or null if no pattern matches.
@@ -38,6 +66,7 @@ compiledPatterns) {
         else if (Array.isArray(pattern.isDuplicatable) && potentialName) {
             isDuplicatable = pattern.isDuplicatable.includes(potentialName);
         }
+        const duplicateKey = resolveDuplicateKey(pattern, match);
         return {
             potentialName,
             isDirective: pattern.isDirective,
@@ -45,6 +74,8 @@ compiledPatterns) {
             valueType: pattern.valueType,
             isDuplicatable,
             ...(pattern.expressionLanguage ? { expressionLanguage: pattern.expressionLanguage } : {}),
+            ...(duplicateKey.key === undefined ? {} : { duplicateKey: duplicateKey.key }),
+            ...(duplicateKey.folds ? { duplicateKeyFolds: true } : {}),
         };
     }
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-spec",
-	"version": "5.6.0",
+	"version": "5.6.1",
 	"description": "Types and schema that specs of the Markup languages for markuplint",
 	"repository": {
 		"type": "git",
@@ -40,8 +40,8 @@
 		"type-fest": "^5.10.0"
 	},
 	"devDependencies": {
-		"@markuplint/test-tools": "5.6.0",
+		"@markuplint/test-tools": "5.6.1",
 		"json-schema-to-typescript": "16.0.0"
 	},
-	"gitHead": "eade3d7202682e567f3c1b6985478f1d4b5c5481"
+	"gitHead": "a9245162df3699c4880469f493aaaf6103343d83"
 }