@markuplint/ml-config 3.9.0 → 3.11.0

package/lib/types.d.ts

@@ -3,201 +3,185 @@ import type { RegexSelector } from '@markuplint/selector';
 import type { Nullable } from '@markuplint/shared';
 export type { RegexSelector } from '@markuplint/selector';
 export type Config = {
-	readonly $schema?: string;
-	readonly extends?: string | readonly string[];
-	readonly plugins?: readonly (PluginConfig | string)[];
-	readonly parser?: ParserConfig;
-	readonly parserOptions?: ParserOptions;
-	readonly specs?: SpecConfig;
-	readonly excludeFiles?: readonly string[];
-	readonly pretenders?: readonly Pretender[];
-	readonly rules?: Rules;
-	readonly nodeRules?: readonly NodeRule[];
-	readonly childNodeRules?: readonly ChildNodeRule[];
-	readonly overrides?: Readonly<Record<string, OverrideConfig>>;
+    readonly $schema?: string;
+    readonly extends?: string | readonly string[];
+    readonly plugins?: readonly (PluginConfig | string)[];
+    readonly parser?: ParserConfig;
+    readonly parserOptions?: ParserOptions;
+    readonly specs?: SpecConfig;
+    readonly excludeFiles?: readonly string[];
+    readonly pretenders?: readonly Pretender[];
+    readonly rules?: Rules;
+    readonly nodeRules?: readonly NodeRule[];
+    readonly childNodeRules?: readonly ChildNodeRule[];
+    readonly overrides?: Readonly<Record<string, OverrideConfig>>;
 };
 export type PrimitiveScalar = string | number | boolean;
-export type PlainData =
-	| Nullable<PrimitiveScalar>
-	| readonly PlainData[]
-	| {
-			readonly [key: string]: PlainData | any;
-	  };
-export type NonNullablePlainData =
-	| PrimitiveScalar
-	| readonly NonNullablePlainData[]
-	| {
-			readonly [key: string]: NonNullablePlainData;
-	  };
+export type PlainData = Nullable<PrimitiveScalar> | readonly PlainData[] | {
+    readonly [key: string]: PlainData | any;
+};
+export type NonNullablePlainData = PrimitiveScalar | readonly NonNullablePlainData[] | {
+    readonly [key: string]: NonNullablePlainData;
+};
 export type OverrideConfig = Omit<Config, '$schema' | 'extends' | 'overrides'>;
 export type PluginConfig = {
-	readonly name: string;
-	readonly settings: Readonly<Record<string, NonNullablePlainData>>;
+    readonly name: string;
+    readonly settings: Readonly<Record<string, NonNullablePlainData>>;
 };
 export type ParserConfig = {
-	readonly [extensionPattern: string]: string;
+    readonly [extensionPattern: string]: string;
 };
 export type SpecConfig = {
-	readonly [extensionPattern: string]: string;
+    readonly [extensionPattern: string]: string;
 };
 export type Pretender = {
-	/**
-	 * Target node selectors
-	 */
-	readonly selector: string;
-	/**
-	 * If it is a string, it is resolved as an element name.
-	 * An element has the same attributes as the pretended custom element
-	 * because attributes are just inherited.
-	 *
-	 * If it is an Object, It creates the element by that.
-	 */
-	readonly as: string | OriginalNode;
+    /**
+     * Target node selectors
+     */
+    readonly selector: string;
+    /**
+     * If it is a string, it is resolved as an element name.
+     * An element has the same attributes as the pretended custom element
+     * because attributes are just inherited.
+     *
+     * If it is an Object, It creates the element by that.
+     */
+    readonly as: string | OriginalNode;
 };
 export type OriginalNode = {
-	/**
-	 * Element name
-	 */
-	readonly element: string;
-	/**
-	 * Namespace
-	 *
-	 * Supports `"svg"` and `undefined` only.
-	 * If it is `undefined`, the namespace is HTML.
-	 */
-	readonly namespace?: 'svg';
-	/**
-	 * Attributes
-	 */
-	readonly attrs?: readonly {
-		/**
-		 * Attribute name
-		 */
-		readonly name: string;
-		/**
-		 * If it omits this property, the attribute is resolved as a boolean.
-		 */
-		readonly value?:
-			| string
-			| {
-					readonly fromAttr: string;
-			  };
-	}[];
-	/**
-	 * To have attributes the defined element has.
-	 */
-	readonly inheritAttrs?: boolean;
-	/**
-	 * ARIA properties
-	 */
-	readonly aria?: PretenderARIA;
+    /**
+     * Element name
+     */
+    readonly element: string;
+    /**
+     * Namespace
+     *
+     * Supports `"svg"` and `undefined` only.
+     * If it is `undefined`, the namespace is HTML.
+     */
+    readonly namespace?: 'svg';
+    /**
+     * Attributes
+     */
+    readonly attrs?: readonly {
+        /**
+         * Attribute name
+         */
+        readonly name: string;
+        /**
+         * If it omits this property, the attribute is resolved as a boolean.
+         */
+        readonly value?: string | {
+            readonly fromAttr: string;
+        };
+    }[];
+    /**
+     * To have attributes the defined element has.
+     */
+    readonly inheritAttrs?: boolean;
+    /**
+     * ARIA properties
+     */
+    readonly aria?: PretenderARIA;
 };
 /**
  * Pretender Node ARIA properties
  */
 export type PretenderARIA = {
-	/**
-	 * Accessible name
-	 *
-	 * - If it is `true`, it assumes the element has any text on its accessible name.
-	 * - If it specifies `fromAttr` property, it assumes the accessible name refers to the value of the attribute.
-	 */
-	readonly name?:
-		| boolean
-		| {
-				readonly fromAttr: string;
-		  };
+    /**
+     * Accessible name
+     *
+     * - If it is `true`, it assumes the element has any text on its accessible name.
+     * - If it specifies `fromAttr` property, it assumes the accessible name refers to the value of the attribute.
+     */
+    readonly name?: boolean | {
+        readonly fromAttr: string;
+    };
 };
 export type Rule<T extends RuleConfigValue, O extends PlainData = undefined> = RuleConfig<T, O> | Readonly<T> | boolean;
 /**
  * @deprecated
  */
-export type RuleV2<T extends RuleConfigValue, O extends PlainData = undefined> =
-	| RuleConfigV2<T, O>
-	| Readonly<T>
-	| boolean;
+export type RuleV2<T extends RuleConfigValue, O extends PlainData = undefined> = RuleConfigV2<T, O> | Readonly<T> | boolean;
 export type AnyRule = Rule<RuleConfigValue, PlainData>;
 /**
  * @deprecated
  */
 export type AnyRuleV2 = RuleV2<RuleConfigValue, PlainData>;
 export type Rules = {
-	readonly [ruleName: string]: AnyRule;
+    readonly [ruleName: string]: AnyRule;
 };
 export type RuleConfig<T extends RuleConfigValue, O extends PlainData = undefined> = {
-	readonly severity?: Severity;
-	readonly value?: Readonly<T>;
-	readonly options?: Readonly<O>;
-	readonly reason?: string;
+    readonly severity?: Severity;
+    readonly value?: Readonly<T>;
+    readonly options?: Readonly<O>;
+    readonly reason?: string;
 };
 /**
  * @deprecated
  */
 export type RuleConfigV2<T extends RuleConfigValue, O extends PlainData = undefined> = {
-	readonly severity?: Severity;
-	readonly value?: Readonly<T>;
-	readonly reason?: string;
-	/**
-	 * Old property
-	 *
-	 * @deprecated
-	 * @see {this.options}
-	 */
-	readonly option?: Readonly<O>;
+    readonly severity?: Severity;
+    readonly value?: Readonly<T>;
+    readonly reason?: string;
+    /**
+     * Old property
+     *
+     * @deprecated
+     * @see {this.options}
+     */
+    readonly option?: Readonly<O>;
 };
 export type Severity = 'error' | 'warning' | 'info';
 export type RuleConfigValue = PrimitiveScalar | readonly (PrimitiveScalar | Readonly<Record<string, any>>)[] | null;
 export type NodeRule = {
-	readonly selector?: string;
-	readonly regexSelector?: RegexSelector;
-	readonly categories?: readonly string[];
-	readonly roles?: readonly string[];
-	readonly obsolete?: boolean;
-	readonly rules?: Rules;
+    readonly selector?: string;
+    readonly regexSelector?: RegexSelector;
+    readonly categories?: readonly string[];
+    readonly roles?: readonly string[];
+    readonly obsolete?: boolean;
+    readonly rules?: Rules;
 };
 export type ChildNodeRule = {
-	readonly selector?: string;
-	readonly regexSelector?: RegexSelector;
-	readonly inheritance?: boolean;
-	readonly rules?: Rules;
-};
-export type Report<T extends RuleConfigValue, O extends PlainData = undefined> =
-	| Report1<T, O>
-	| Report2
-	| (Report1<T, O> & Report2);
+    readonly selector?: string;
+    readonly regexSelector?: RegexSelector;
+    readonly inheritance?: boolean;
+    readonly rules?: Rules;
+};
+export type Report<T extends RuleConfigValue, O extends PlainData = undefined> = Report1<T, O> | Report2 | (Report1<T, O> & Report2);
 export type Report1<T extends RuleConfigValue, O extends PlainData = undefined> = {
-	readonly message: string;
-	readonly scope: Scope<T, O>;
+    readonly message: string;
+    readonly scope: Scope<T, O>;
 };
 export type Report2 = {
-	readonly message: string;
-	readonly line: number;
-	readonly col: number;
-	readonly raw: string;
+    readonly message: string;
+    readonly line: number;
+    readonly col: number;
+    readonly raw: string;
 };
 export type Scope<T extends RuleConfigValue, O extends PlainData = undefined> = {
-	readonly rule: RuleInfo<T, O>;
-	readonly startLine: number;
-	readonly startCol: number;
-	readonly raw: string;
+    readonly rule: RuleInfo<T, O>;
+    readonly startLine: number;
+    readonly startCol: number;
+    readonly raw: string;
 };
 export type Violation = {
-	readonly ruleId: string;
-	readonly severity: Severity;
-	readonly message: string;
-	readonly reason?: string;
-	readonly line: number;
-	readonly col: number;
-	readonly raw: string;
+    readonly ruleId: string;
+    readonly severity: Severity;
+    readonly message: string;
+    readonly reason?: string;
+    readonly line: number;
+    readonly col: number;
+    readonly raw: string;
 };
 export type RuleInfo<T extends RuleConfigValue, O extends PlainData = undefined> = {
-	readonly disabled: boolean;
-	readonly severity: Severity;
-	readonly value: Readonly<T>;
-	readonly options: Readonly<O>;
-	readonly reason?: string;
+    readonly disabled: boolean;
+    readonly severity: Severity;
+    readonly value: Readonly<T>;
+    readonly options: Readonly<O>;
+    readonly reason?: string;
 };
 export type GlobalRuleInfo<T extends RuleConfigValue, O extends PlainData = undefined> = RuleInfo<T, O> & {
-	nodeRules: RuleInfo<T, O>[];
-	childNodeRules: RuleInfo<T, O>[];
+    nodeRules: RuleInfo<T, O>[];
+    childNodeRules: RuleInfo<T, O>[];
 };

package/lib/utils.d.ts

@@ -7,13 +7,8 @@ import type { AnyRule, AnyRuleV2, PlainData, RuleConfig, RuleConfigV2, RuleConfi
  * @param data Captured string for replacement
  */
 export declare function provideValue(template: string, data: Readonly<Record<string, string>>): string | undefined;
-export declare function exchangeValueOnRule(
-	rule: AnyRule | AnyRuleV2,
-	data: Readonly<Record<string, string>>,
-): AnyRule | undefined;
-export declare function cleanOptions(
-	rule: RuleConfig<RuleConfigValue, PlainData> | RuleConfigV2<RuleConfigValue, PlainData>,
-): RuleConfig<RuleConfigValue, PlainData>;
+export declare function exchangeValueOnRule(rule: AnyRule | AnyRuleV2, data: Readonly<Record<string, string>>): AnyRule | undefined;
+export declare function cleanOptions(rule: RuleConfig<RuleConfigValue, PlainData> | RuleConfigV2<RuleConfigValue, PlainData>): RuleConfig<RuleConfigValue, PlainData>;
 export declare function isRuleConfigValue(v: any): v is RuleConfigValue;
 /**
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-config",
-	"version": "3.9.0",
+	"version": "3.11.0",
 	"description": "JSON Schema and TypeScript types of markuplint configure JSON",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -19,14 +19,14 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "3.1.0",
-		"@markuplint/selector": "3.9.0",
-		"@markuplint/shared": "3.6.0",
+		"@markuplint/ml-ast": "3.2.0",
+		"@markuplint/selector": "3.11.0",
+		"@markuplint/shared": "3.8.0",
 		"@types/mustache": "^4.2.2",
 		"deepmerge": "^4.3.1",
 		"is-plain-object": "^5.0.0",
 		"mustache": "^4.2.0",
-		"type-fest": "^3.10.0"
+		"type-fest": "^3.12.0"
 	},
-	"gitHead": "af370797bfc887e5a5a2ff57fbaa8392ac98ead2"
+	"gitHead": "4ab20276db48a6acb29a923ea8666890ca853442"
 }

package/test/merge-config.spec.js

@@ -1,233 +1,294 @@
 const { mergeConfig, mergeRule } = require('../lib/merge-config');
 
-it('test', () => {
-	expect(mergeConfig({}, {})).toStrictEqual({});
-});
-
-it('test', () => {
-	expect(
-		mergeConfig(
-			{
-				plugins: ['a', 'b', 'c'],
-			},
-			{
-				plugins: ['c', 'b', 'd'],
-			},
-		),
-	).toStrictEqual({
-		plugins: ['a', 'b', 'c', 'd'],
+describe('mergeConfig', () => {
+	test('empty + empty', () => {
+		expect(mergeConfig({}, {})).toStrictEqual({});
 	});
-});
 
-it('test', () => {
-	expect(
-		mergeConfig(
-			{
-				plugins: ['a', 'b', { name: 'c', settings: { foo: 'foo', bar: 'bar' } }],
-			},
-			{
-				plugins: ['c', 'b', 'd', { name: 'c', settings: { foo2: 'foo2', bar: 'bar2' } }],
-			},
-		),
-	).toStrictEqual({
-		plugins: [
-			'a',
-			'b',
-			{
-				name: 'c',
-				settings: {
-					bar: 'bar2',
-					foo: 'foo',
-					foo2: 'foo2',
+	test('plugins + plugins', () => {
+		expect(
+			mergeConfig(
+				{
+					plugins: ['a', 'b', 'c'],
 				},
-			},
-			'd',
-		],
-	});
-});
-
-it('test', () => {
-	expect(
-		mergeConfig(
-			{
-				parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
-			},
-			{
-				parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
-			},
-		),
-	).toStrictEqual({
-		parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+				{
+					plugins: ['c', 'b', 'd'],
+				},
+			),
+		).toStrictEqual({
+			plugins: ['a', 'b', 'c', 'd'],
+		});
 	});
-});
 
-it('test', () => {
-	expect(
-		mergeConfig(
-			{
-				parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
-			},
-			{
-				parser: { '/\\.[jt]sx?$/i': '@markuplint/jsx-parser' },
-			},
-		),
-	).toStrictEqual({
-		parser: {
-			'/\\.vue$/i': '@markuplint/vue-parser',
-			'/\\.[jt]sx?$/i': '@markuplint/jsx-parser',
-		},
+	test('plugins + plugins (with options)', () => {
+		expect(
+			mergeConfig(
+				{
+					plugins: ['a', 'b', { name: 'c', settings: { foo: 'foo', bar: 'bar' } }],
+				},
+				{
+					plugins: ['c', 'b', 'd', { name: 'c', settings: { foo2: 'foo2', bar: 'bar2' } }],
+				},
+			),
+		).toStrictEqual({
+			plugins: [
+				'a',
+				'b',
+				{
+					name: 'c',
+					settings: {
+						bar: 'bar2',
+						foo: 'foo',
+						foo2: 'foo2',
+					},
+				},
+				'd',
+			],
+		});
 	});
-});
 
-it('test', () => {
-	expect(
-		mergeRule(
-			{
-				value: true,
-			},
-			{},
-		),
-	).toStrictEqual({
-		value: true,
+	test('parser + parser', () => {
+		expect(
+			mergeConfig(
+				{
+					parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+				},
+				{
+					parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+				},
+			),
+		).toStrictEqual({
+			parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+		});
 	});
 
-	expect(
-		mergeRule(
-			{
-				value: true,
-			},
-			false,
-		),
-	).toStrictEqual(false);
-
-	expect(
-		mergeRule(
-			{
-				value: false,
+	test('parser + parser (2)', () => {
+		expect(
+			mergeConfig(
+				{
+					parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+				},
+				{
+					parser: { '/\\.[jt]sx?$/i': '@markuplint/jsx-parser' },
+				},
+			),
+		).toStrictEqual({
+			parser: {
+				'/\\.vue$/i': '@markuplint/vue-parser',
+				'/\\.[jt]sx?$/i': '@markuplint/jsx-parser',
 			},
-			true,
-		),
-	).toStrictEqual({
-		value: true,
+		});
 	});
 
-	expect(
-		mergeRule(
-			{
-				options: {
-					optional: 'OPTIONAL_VALUE',
+	test('overrides + overrides', () => {
+		expect(
+			mergeConfig(
+				{
+					overrides: {
+						a: {
+							rules: {
+								rule1: true,
+							},
+						},
+					},
 				},
-			},
-			{
-				options: {
-					optional: 'CHANGED_OPTIONAL_VALUE',
+				{
+					overrides: {
+						a: {
+							rules: {
+								rule1: false,
+							},
+						},
+						b: {
+							rules: {
+								rule1: true,
+							},
+						},
+					},
+				},
+			),
+		).toStrictEqual({
+			overrides: {
+				a: {
+					rules: {
+						rule1: false,
+					},
+				},
+				b: {
+					rules: {
+						rule1: true,
+					},
 				},
 			},
-		),
-	).toStrictEqual({
-		options: {
-			optional: 'CHANGED_OPTIONAL_VALUE',
-		},
+		});
 	});
 
-	expect(
-		mergeRule(
-			{
-				option: {
-					optional: 'OPTIONAL_VALUE',
+	test('rules + rules', () => {
+		expect(
+			mergeConfig(
+				{
+					rules: {
+						a: {
+							option: {
+								ruleA: true,
+							},
+						},
+					},
 				},
-			},
-			{
-				option: {
-					optional: 'CHANGED_OPTIONAL_VALUE',
+				{
+					rules: {
+						b: {
+							options: {
+								ruleB: true,
+							},
+						},
+					},
+				},
+			),
+		).toStrictEqual({
+			rules: {
+				a: {
+					options: {
+						ruleA: true,
+					},
+				},
+				b: {
+					options: {
+						ruleB: true,
+					},
 				},
 			},
-		),
-	).toStrictEqual({
-		options: {
-			optional: 'CHANGED_OPTIONAL_VALUE',
-		},
+		});
 	});
-});
 
-it('test', () => {
-	expect(
-		mergeConfig(
-			{
-				overrides: {
-					a: {
-						rules: {
-							rule1: true,
-						},
+	test('rules[rule].value + rules[rule].value', () => {
+		expect(
+			mergeConfig(
+				{
+					rules: {
+						ruleA: true,
+						ruleB: [],
 					},
 				},
-			},
-			{
-				overrides: {
-					a: {
-						rules: {
-							rule1: false,
+				{
+					rules: {
+						ruleA: {
+							options: {
+								optionName: true,
+							},
 						},
-					},
-					b: {
-						rules: {
-							rule1: true,
+						ruleB: {
+							options: {
+								optionName: true,
+							},
 						},
 					},
 				},
-			},
-		),
-	).toStrictEqual({
-		overrides: {
-			a: {
-				rules: {
-					rule1: false,
+			),
+		).toStrictEqual({
+			rules: {
+				ruleA: {
+					value: true,
+					options: {
+						optionName: true,
+					},
 				},
-			},
-			b: {
-				rules: {
-					rule1: true,
+				ruleB: {
+					value: [],
+					options: {
+						optionName: true,
+					},
 				},
 			},
-		},
+		});
 	});
 });
 
-it('test', () => {
-	expect(
-		mergeConfig(
-			{
-				rules: {
-					a: {
-						// @ts-ignore
-						option: {
-							ruleA: true,
-						},
+describe('mergeRule', () => {
+	test('{value} + shorthand', () => {
+		expect(
+			mergeRule(
+				{
+					value: true,
+				},
+				{},
+			),
+		).toStrictEqual({
+			value: true,
+		});
+	});
+
+	test('{value} + shorthand (2)', () => {
+		expect(
+			mergeRule(
+				{
+					value: true,
+				},
+				false,
+			),
+		).toStrictEqual(false);
+	});
+
+	test('{value} + shorthand (3)', () => {
+		expect(
+			mergeRule(
+				{
+					value: false,
+				},
+				true,
+			),
+		).toStrictEqual({
+			value: true,
+		});
+	});
+
+	test('{options} + {options}', () => {
+		expect(
+			mergeRule(
+				{
+					options: {
+						optional: 'OPTIONAL_VALUE',
 					},
 				},
-			},
-			{
-				rules: {
-					b: {
-						options: {
-							ruleB: true,
-						},
+				{
+					options: {
+						optional: 'CHANGED_OPTIONAL_VALUE',
 					},
 				},
+			),
+		).toStrictEqual({
+			options: {
+				optional: 'CHANGED_OPTIONAL_VALUE',
 			},
-		),
-	).toStrictEqual({
-		rules: {
-			a: {
-				options: {
-					ruleA: true,
+		});
+	});
+
+	test('{value} + empty', () => {
+		expect(
+			mergeRule(
+				{
+					value: [],
 				},
-			},
-			b: {
-				options: {
-					ruleB: true,
+				{},
+			),
+		).toStrictEqual({
+			value: [],
+		});
+	});
+
+	test('{value} + {options}', () => {
+		expect(
+			mergeRule(
+				{
+					value: [],
 				},
-			},
-		},
+				{
+					options: {},
+				},
+			),
+		).toStrictEqual({
+			value: [],
+			options: {},
+		});
 	});
 });