@markuplint/ml-config 3.6.1 → 3.8.0

package/lib/types.d.ts

@@ -3,185 +3,201 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-config",
-	"version": "3.6.1",
+	"version": "3.8.0",
 	"description": "JSON Schema and TypeScript types of markuplint configure JSON",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -18,17 +18,15 @@
 		"build": "tsc",
 		"clean": "tsc --build --clean"
 	},
-	"devDependencies": {
-		"@markuplint/ml-ast": "3.1.0",
-		"@markuplint/shared": "3.5.0",
-		"@types/mustache": "^4.2.2"
-	},
 	"dependencies": {
-		"@markuplint/selector": "3.6.1",
-		"deepmerge": "^4.2.2",
+		"@markuplint/ml-ast": "3.1.0",
+		"@markuplint/selector": "3.8.0",
+		"@markuplint/shared": "3.6.0",
+		"@types/mustache": "^4.2.2",
+		"deepmerge": "^4.3.1",
 		"is-plain-object": "^5.0.0",
 		"mustache": "^4.2.0",
-		"type-fest": "^3.6.1"
+		"type-fest": "^3.8.0"
 	},
-	"gitHead": "3cdf5a088b2da03773d5d4461d0e65ec32290a00"
+	"gitHead": "adc6e432cccba7cfad0dc8bf9f92e5aaf1107359"
 }

package/test/merge-config.spec.js

@@ -0,0 +1,233 @@
+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'],
+	});
+});
+
+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',
+				},
+			},
+			'd',
+		],
+	});
+});
+
+it('test', () => {
+	expect(
+		mergeConfig(
+			{
+				parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+			},
+			{
+				parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+			},
+		),
+	).toStrictEqual({
+		parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
+	});
+});
+
+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',
+		},
+	});
+});
+
+it('test', () => {
+	expect(
+		mergeRule(
+			{
+				value: true,
+			},
+			{},
+		),
+	).toStrictEqual({
+		value: true,
+	});
+
+	expect(
+		mergeRule(
+			{
+				value: true,
+			},
+			false,
+		),
+	).toStrictEqual(false);
+
+	expect(
+		mergeRule(
+			{
+				value: false,
+			},
+			true,
+		),
+	).toStrictEqual({
+		value: true,
+	});
+
+	expect(
+		mergeRule(
+			{
+				options: {
+					optional: 'OPTIONAL_VALUE',
+				},
+			},
+			{
+				options: {
+					optional: 'CHANGED_OPTIONAL_VALUE',
+				},
+			},
+		),
+	).toStrictEqual({
+		options: {
+			optional: 'CHANGED_OPTIONAL_VALUE',
+		},
+	});
+
+	expect(
+		mergeRule(
+			{
+				option: {
+					optional: 'OPTIONAL_VALUE',
+				},
+			},
+			{
+				option: {
+					optional: 'CHANGED_OPTIONAL_VALUE',
+				},
+			},
+		),
+	).toStrictEqual({
+		options: {
+			optional: 'CHANGED_OPTIONAL_VALUE',
+		},
+	});
+});
+
+it('test', () => {
+	expect(
+		mergeConfig(
+			{
+				overrides: {
+					a: {
+						rules: {
+							rule1: true,
+						},
+					},
+				},
+			},
+			{
+				overrides: {
+					a: {
+						rules: {
+							rule1: false,
+						},
+					},
+					b: {
+						rules: {
+							rule1: true,
+						},
+					},
+				},
+			},
+		),
+	).toStrictEqual({
+		overrides: {
+			a: {
+				rules: {
+					rule1: false,
+				},
+			},
+			b: {
+				rules: {
+					rule1: true,
+				},
+			},
+		},
+	});
+});
+
+it('test', () => {
+	expect(
+		mergeConfig(
+			{
+				rules: {
+					a: {
+						// @ts-ignore
+						option: {
+							ruleA: true,
+						},
+					},
+				},
+			},
+			{
+				rules: {
+					b: {
+						options: {
+							ruleB: true,
+						},
+					},
+				},
+			},
+		),
+	).toStrictEqual({
+		rules: {
+			a: {
+				options: {
+					ruleA: true,
+				},
+			},
+			b: {
+				options: {
+					ruleB: true,
+				},
+			},
+		},
+	});
+});

package/test/utils.spec.js

@@ -0,0 +1,119 @@
+const { exchangeValueOnRule, provideValue } = require('../lib/utils');
+
+it('provideValue', () => {
+	expect(
+		provideValue('The name is {{ dataName }}', {
+			$0: 'data-hoge',
+			$1: 'hoge',
+			dataName: 'hoge',
+		}),
+	).toBe('The name is hoge');
+
+	expect(provideValue('The name is {{ dataName }}', {})).toBeUndefined();
+
+	expect(
+		provideValue('No variable', {
+			$0: 'data-hoge',
+			$1: 'hoge',
+			dataName: 'hoge',
+		}),
+	).toBe('No variable');
+});
+
+it('exchangeValueOnRule', () => {
+	expect(
+		exchangeValueOnRule('The name is {{ dataName }}', {
+			$0: 'data-hoge',
+			$1: 'hoge',
+			dataName: 'hoge',
+		}),
+	).toBe('The name is hoge');
+
+	expect(
+		exchangeValueOnRule(
+			{
+				value: 'The name is {{ dataName }}',
+			},
+			{
+				$0: 'data-hoge',
+				$1: 'hoge',
+				dataName: 'hoge',
+			},
+		),
+	).toStrictEqual({
+		value: 'The name is hoge',
+	});
+
+	expect(
+		exchangeValueOnRule(
+			{
+				severity: 'error',
+				value: 'The name is {{ dataName }}',
+				reason: 'For {{ dataName }}',
+			},
+			{
+				$0: 'data-hoge',
+				$1: 'hoge',
+				dataName: 'hoge',
+			},
+		),
+	).toStrictEqual({
+		severity: 'error',
+		value: 'The name is hoge',
+		reason: 'For hoge',
+	});
+
+	expect(
+		exchangeValueOnRule(
+			{
+				value: 'The name is {{ dataName }}',
+				option: {
+					propA: 'The name is {{ dataName }}',
+					propB: ['The name is {{ dataName }}'],
+					propC: {
+						prop: 'The name is {{ dataName }}',
+					},
+				},
+			},
+			{
+				dataName: 'hoge',
+			},
+		),
+	).toStrictEqual({
+		value: 'The name is hoge',
+		options: {
+			propA: 'The name is hoge',
+			propB: ['The name is hoge'],
+			propC: {
+				prop: 'The name is hoge',
+			},
+		},
+	});
+
+	expect(
+		exchangeValueOnRule(
+			{
+				value: 'The name is {{ dataName }}',
+				options: {
+					propA: 'The name is {{ dataName }}',
+					propB: ['The name is {{ dataName }}'],
+					propC: {
+						prop: 'The name is {{ dataName }}',
+					},
+				},
+			},
+			{
+				dataName: 'hoge',
+			},
+		),
+	).toStrictEqual({
+		value: 'The name is hoge',
+		options: {
+			propA: 'The name is hoge',
+			propB: ['The name is hoge'],
+			propC: {
+				prop: 'The name is hoge',
+			},
+		},
+	});
+});