@markuplint/ml-config 3.14.0 → 4.0.0-alpha.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2019 Yusuke Hirao
+Copyright (c) 2017-2024 Yusuke Hirao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from './merge-config';
-export * from './utils';
-export * from './types';
+export * from './merge-config.js';
+export * from './utils.js';
+export * from './types.js';

package/lib/index.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./merge-config"), exports);
-tslib_1.__exportStar(require("./utils"), exports);
-tslib_1.__exportStar(require("./types"), exports);
+export * from './merge-config.js';
+export * from './utils.js';
+export * from './types.js';

package/lib/merge-config.d.ts

@@ -1,4 +1,4 @@
-import type { Config, AnyRule, AnyRuleV2 } from './types';
+import type { Config, AnyRule, AnyRuleV2 } from './types.js';
 import type { Nullable } from '@markuplint/shared';
 export declare function mergeConfig(a: Config, b: Config): Config;
 export declare function mergeRule(a: Nullable<AnyRule | AnyRuleV2>, b: AnyRule | AnyRuleV2): AnyRule;

package/lib/merge-config.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeRule = exports.mergeConfig = void 0;
-const tslib_1 = require("tslib");
-const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
-const utils_1 = require("./utils");
-function mergeConfig(a, b) {
+import deepmerge from 'deepmerge';
+import { deleteUndefProp, cleanOptions, isRuleConfigValue } from './utils.js';
+export function mergeConfig(a, b) {
     const config = {
         ...a,
         ...b,
@@ -22,61 +18,58 @@ function mergeConfig(a, b) {
         // delete all
         extends: undefined,
     };
-    (0, utils_1.deleteUndefProp)(config);
+    deleteUndefProp(config);
     return config;
 }
-exports.mergeConfig = mergeConfig;
-function mergeRule(a, b) {
-    var _a, _b, _c;
+export function mergeRule(a, b) {
     const oA = optimizeRule(a);
     const oB = optimizeRule(b);
     // Particular behavior:
     // If the right-side value is false, return false.
     // In short; The `false` makes the rule to be disabled absolutely.
-    if (oB === false || (!(0, utils_1.isRuleConfigValue)(oB) && (oB === null || oB === void 0 ? void 0 : oB.value) === false)) {
+    if (oB === false || (!isRuleConfigValue(oB) && oB?.value === false)) {
         return false;
     }
     if (oA === undefined) {
-        return oB !== null && oB !== void 0 ? oB : {};
+        return oB ?? {};
     }
     if (oB === undefined) {
         return oA;
     }
-    if ((0, utils_1.isRuleConfigValue)(oB)) {
-        if ((0, utils_1.isRuleConfigValue)(oA)) {
+    if (isRuleConfigValue(oB)) {
+        if (isRuleConfigValue(oA)) {
             if (Array.isArray(oA) && Array.isArray(oB)) {
                 return [...oA, ...oB];
             }
             return oB;
         }
         const value = Array.isArray(oA.value) && Array.isArray(oB) ? [...oA.value, ...oB] : oB;
-        const res = (0, utils_1.cleanOptions)({ ...oA, value });
-        (0, utils_1.deleteUndefProp)(res);
+        const res = cleanOptions({ ...oA, value });
+        deleteUndefProp(res);
         return res;
     }
-    const severity = (_a = oB.severity) !== null && _a !== void 0 ? _a : (!(0, utils_1.isRuleConfigValue)(oA) ? oA.severity : undefined);
-    const value = (_b = oB.value) !== null && _b !== void 0 ? _b : ((0, utils_1.isRuleConfigValue)(oA) ? oA : oA.value);
-    const options = mergeObject(!(0, utils_1.isRuleConfigValue)(oA) ? oA.options : undefined, oB.options);
-    const reason = (_c = oB.reason) !== null && _c !== void 0 ? _c : (!(0, utils_1.isRuleConfigValue)(oA) ? oA.reason : undefined);
+    const severity = oB.severity ?? (isRuleConfigValue(oA) ? undefined : oA.severity);
+    const value = oB.value ?? (isRuleConfigValue(oA) ? oA : oA.value);
+    const options = mergeObject(isRuleConfigValue(oA) ? undefined : oA.options, oB.options);
+    const reason = oB.reason ?? (isRuleConfigValue(oA) ? undefined : oA.reason);
     const res = {
         severity,
         value,
         options,
         reason,
     };
-    (0, utils_1.deleteUndefProp)(res);
+    deleteUndefProp(res);
     return res;
 }
-exports.mergeRule = mergeRule;
 function mergeObject(a, b) {
     if (a == null) {
-        return b !== null && b !== void 0 ? b : undefined;
+        return b ?? undefined;
     }
     if (b == null) {
-        return a !== null && a !== void 0 ? a : undefined;
+        return a ?? undefined;
     }
-    const res = (0, deepmerge_1.default)(a, b);
-    (0, utils_1.deleteUndefProp)(res);
+    const res = deepmerge(a, b);
+    deleteUndefProp(res);
     return res;
 }
 function concatArray(a, b, uniquely = false, comparePropName) {
@@ -114,8 +107,10 @@ function concatArray(a, b, uniquely = false, comparePropName) {
         }
         newArray.splice(existedIndex, 1, merged);
     }
-    a === null || a === void 0 ? void 0 : a.forEach(concat);
-    b === null || b === void 0 ? void 0 : b.forEach(concat);
+    // eslint-disable-next-line unicorn/no-array-for-each
+    a?.forEach(concat);
+    // eslint-disable-next-line unicorn/no-array-for-each
+    b?.forEach(concat);
     return newArray.length === 0 ? undefined : newArray;
 }
 function getName(item, comparePropName) {
@@ -144,7 +139,7 @@ function mergeRules(a, b) {
             res[key] = merged;
         }
     }
-    (0, utils_1.deleteUndefProp)(res);
+    deleteUndefProp(res);
     return Object.freeze(res);
 }
 function optimizeRules(rules) {
@@ -161,8 +156,8 @@ function optimizeRule(rule) {
     if (rule === undefined) {
         return;
     }
-    if ((0, utils_1.isRuleConfigValue)(rule)) {
+    if (isRuleConfigValue(rule)) {
         return rule;
     }
-    return (0, utils_1.cleanOptions)(rule);
+    return cleanOptions(rule);
 }

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/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/utils.d.ts

@@ -1,4 +1,4 @@
-import type { AnyRule, AnyRuleV2, PlainData, RuleConfig, RuleConfigV2, RuleConfigValue } from './types';
+import type { AnyRule, AnyRuleV2, PlainData, RuleConfig, RuleConfigV2, RuleConfigValue } from './types.js';
 /**
  * Return undefined if the template doesn't include the variable that is set as a property in data.
  * But return template string without changes if it doesn't have a variable.
@@ -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/lib/utils.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteUndefProp = exports.isRuleConfigValue = exports.cleanOptions = exports.exchangeValueOnRule = exports.provideValue = void 0;
-const tslib_1 = require("tslib");
-const is_plain_object_1 = require("is-plain-object");
-const mustache_1 = tslib_1.__importDefault(require("mustache"));
+// @ts-ignore
+import { isPlainObject } from 'is-plain-object';
+import mustache from 'mustache';
 /**
  * Return undefined if the template doesn't include the variable that is set as a property in data.
  * But return template string without changes if it doesn't have a variable.
@@ -11,23 +8,21 @@ const mustache_1 = tslib_1.__importDefault(require("mustache"));
  * @param template Mustache template string
  * @param data Captured string for replacement
  */
-function provideValue(template, data) {
-    var _a;
-    const ast = mustache_1.default.parse(template);
-    if (ast.length === 1 && ((_a = ast[0]) === null || _a === void 0 ? void 0 : _a[0]) === 'text') {
+export function provideValue(template, data) {
+    const ast = mustache.parse(template);
+    if (ast.length === 1 && ast[0]?.[0] === 'text') {
         // It doesn't have a variable
         return template;
     }
-    const noDataResult = mustache_1.default.render(template, {});
-    const result = mustache_1.default.render(template, data);
+    const noDataResult = mustache.render(template, {});
+    const result = mustache.render(template, data);
     // Assume variables are empty in the template if it matched.
     if (noDataResult === result) {
         return;
     }
     return result;
 }
-exports.provideValue = provideValue;
-function exchangeValueOnRule(rule, data) {
+export function exchangeValueOnRule(rule, data) {
     if (isRuleConfigValue(rule)) {
         return exchangeValue(rule, data);
     }
@@ -54,14 +49,13 @@ function exchangeValueOnRule(rule, data) {
         const exchangedValue = exchangeValue(result.reason, data);
         result = {
             ...result,
-            reason: exchangedValue != null ? `${exchangedValue}` : undefined,
+            reason: exchangedValue == null ? undefined : `${exchangedValue}`,
         };
     }
     deleteUndefProp(result);
     return result;
 }
-exports.exchangeValueOnRule = exchangeValueOnRule;
-function cleanOptions(rule) {
+export function cleanOptions(rule) {
     const res = {
         severity: rule.severity,
         value: rule.value,
@@ -71,8 +65,7 @@ function cleanOptions(rule) {
     deleteUndefProp(res);
     return res;
 }
-exports.cleanOptions = cleanOptions;
-function isRuleConfigValue(v) {
+export function isRuleConfigValue(v) {
     switch (typeof v) {
         case 'string':
         case 'number':
@@ -85,14 +78,13 @@ function isRuleConfigValue(v) {
     }
     return Array.isArray(v);
 }
-exports.isRuleConfigValue = isRuleConfigValue;
 /**
  *
  * @param obj
  * @returns
  */
-function deleteUndefProp(obj) {
-    if (!(0, is_plain_object_1.isPlainObject)(obj)) {
+export function deleteUndefProp(obj) {
+    if (!isPlainObject(obj)) {
         return;
     }
     for (const key in obj) {
@@ -101,7 +93,6 @@ function deleteUndefProp(obj) {
         }
     }
 }
-exports.deleteUndefProp = deleteUndefProp;
 /**
  * Return options from `options` or `option`
  *
@@ -150,9 +141,9 @@ function exchangeOption(optionValue, data) {
         return optionValue.map(v => exchangeOption(v, data));
     }
     const result = {};
-    Object.keys(optionValue).forEach(key => {
+    for (const key of Object.keys(optionValue)) {
         result[key] = exchangeOption(optionValue[key], data);
-    });
+    }
     return result;
 }
 /**

package/package.json

@@ -1,12 +1,17 @@
 {
 	"name": "@markuplint/ml-config",
-	"version": "3.14.0",
+	"version": "4.0.0-alpha.10",
 	"description": "JSON Schema and TypeScript types of markuplint configure JSON",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"private": false,
-	"main": "lib/index.js",
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./lib/index.js"
+		}
+	},
 	"types": "lib/index.d.ts",
 	"publishConfig": {
 		"access": "public"
@@ -19,14 +24,14 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "3.2.0",
-		"@markuplint/selector": "3.14.0",
-		"@markuplint/shared": "3.8.0",
+		"@markuplint/ml-ast": "4.0.0-alpha.10",
+		"@markuplint/selector": "4.0.0-alpha.10",
+		"@markuplint/shared": "4.0.0-alpha.10",
 		"@types/mustache": "^4.2.5",
 		"deepmerge": "^4.3.1",
 		"is-plain-object": "^5.0.0",
 		"mustache": "^4.2.0",
-		"type-fest": "^4.8.2"
+		"type-fest": "^4.10.1"
 	},
-	"gitHead": "b37b749d7ac0f9e6cbd022ee7031bc020c6677d3"
+	"gitHead": "b41153ea665aa8f091daf6114a06047f4ccb8350"
 }

package/test/merge-config.spec.js

@@ -1,294 +0,0 @@
-const { mergeConfig, mergeRule } = require('../lib/merge-config');
-
-describe('mergeConfig', () => {
-	test('empty + empty', () => {
-		expect(mergeConfig({}, {})).toStrictEqual({});
-	});
-
-	test('plugins + plugins', () => {
-		expect(
-			mergeConfig(
-				{
-					plugins: ['a', 'b', 'c'],
-				},
-				{
-					plugins: ['c', 'b', 'd'],
-				},
-			),
-		).toStrictEqual({
-			plugins: ['a', 'b', 'c', 'd'],
-		});
-	});
-
-	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',
-			],
-		});
-	});
-
-	test('parser + parser', () => {
-		expect(
-			mergeConfig(
-				{
-					parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
-				},
-				{
-					parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
-				},
-			),
-		).toStrictEqual({
-			parser: { '/\\.vue$/i': '@markuplint/vue-parser' },
-		});
-	});
-
-	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',
-			},
-		});
-	});
-
-	test('overrides + overrides', () => {
-		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,
-					},
-				},
-			},
-		});
-	});
-
-	test('rules + rules', () => {
-		expect(
-			mergeConfig(
-				{
-					rules: {
-						a: {
-							option: {
-								ruleA: true,
-							},
-						},
-					},
-				},
-				{
-					rules: {
-						b: {
-							options: {
-								ruleB: true,
-							},
-						},
-					},
-				},
-			),
-		).toStrictEqual({
-			rules: {
-				a: {
-					options: {
-						ruleA: true,
-					},
-				},
-				b: {
-					options: {
-						ruleB: true,
-					},
-				},
-			},
-		});
-	});
-
-	test('rules[rule].value + rules[rule].value', () => {
-		expect(
-			mergeConfig(
-				{
-					rules: {
-						ruleA: true,
-						ruleB: [],
-					},
-				},
-				{
-					rules: {
-						ruleA: {
-							options: {
-								optionName: true,
-							},
-						},
-						ruleB: {
-							options: {
-								optionName: true,
-							},
-						},
-					},
-				},
-			),
-		).toStrictEqual({
-			rules: {
-				ruleA: {
-					value: true,
-					options: {
-						optionName: true,
-					},
-				},
-				ruleB: {
-					value: [],
-					options: {
-						optionName: 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',
-					},
-				},
-				{
-					options: {
-						optional: 'CHANGED_OPTIONAL_VALUE',
-					},
-				},
-			),
-		).toStrictEqual({
-			options: {
-				optional: 'CHANGED_OPTIONAL_VALUE',
-			},
-		});
-	});
-
-	test('{value} + empty', () => {
-		expect(
-			mergeRule(
-				{
-					value: [],
-				},
-				{},
-			),
-		).toStrictEqual({
-			value: [],
-		});
-	});
-
-	test('{value} + {options}', () => {
-		expect(
-			mergeRule(
-				{
-					value: [],
-				},
-				{
-					options: {},
-				},
-			),
-		).toStrictEqual({
-			value: [],
-			options: {},
-		});
-	});
-});

package/test/utils.spec.js

@@ -1,119 +0,0 @@
-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',
-			},
-		},
-	});
-});