@markuplint/ml-core 3.9.0 → 3.11.0

package/lib/ml-rule/ml-rule.js

@@ -56,7 +56,11 @@ class MLRule {
             return {
                 disabled: false,
                 severity: (_a = configSettings.severity) !== null && _a !== void 0 ? _a : this.defaultSeverity,
-                value: configSettings.value !== undefined ? configSettings.value : this.defaultValue,
+                value: configSettings.value === undefined ||
+                    // @ts-ignore
+                    configSettings.value === true
+                    ? this.defaultValue
+                    : configSettings.value,
                 options: mergeOptions(this.defaultOptions, configSettings.options),
                 reason: configSettings.reason,
             };

package/lib/ml-rule/types.d.ts

@@ -3,36 +3,18 @@ import type { Attr, Element } from '../ml-dom';
 import type { Translator } from '@markuplint/i18n';
 import type { PlainData, Report, RuleConfigValue, Severity } from '@markuplint/ml-config';
 export type RuleSeed<T extends RuleConfigValue = boolean, O extends PlainData = undefined> = {
-	readonly defaultSeverity?: Severity;
-	readonly defaultValue?: T;
-	readonly defaultOptions?: O;
-	verify(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
-	fix?(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
+    readonly defaultSeverity?: Severity;
+    readonly defaultValue?: T;
+    readonly defaultOptions?: O;
+    verify(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
+    fix?(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
 };
-export type Checker<
-	T extends RuleConfigValue,
-	O extends PlainData = undefined,
-	P extends Record<string, unknown> = {},
-> = (params: P) => CheckerReport<T, O>;
-export type ElementChecker<
-	T extends RuleConfigValue,
-	O extends PlainData = undefined,
-	P extends Record<string, unknown> = {},
-> = (
-	params: P & {
-		el: Element<T, O>;
-	},
-) => CheckerReport<T, O>;
-export type AttrChecker<
-	T extends RuleConfigValue,
-	O extends PlainData = undefined,
-	P extends Record<string, unknown> = {},
-> = (
-	params: P & {
-		attr: Attr<T, O>;
-	},
-) => CheckerReport<T, O>;
-export type CheckerReport<T extends RuleConfigValue, O extends PlainData = undefined> = (
-	t: Translator,
-) => Report<T, O> | undefined | null;
+export type Checker<T extends RuleConfigValue, O extends PlainData = undefined, P extends Record<string, unknown> = {}> = (params: P) => CheckerReport<T, O>;
+export type ElementChecker<T extends RuleConfigValue, O extends PlainData = undefined, P extends Record<string, unknown> = {}> = (params: P & {
+    el: Element<T, O>;
+}) => CheckerReport<T, O>;
+export type AttrChecker<T extends RuleConfigValue, O extends PlainData = undefined, P extends Record<string, unknown> = {}> = (params: P & {
+    attr: Attr<T, O>;
+}) => CheckerReport<T, O>;
+export type CheckerReport<T extends RuleConfigValue, O extends PlainData = undefined> = (t: Translator) => Report<T, O> | undefined | null;
 export type AnyRuleSeed<T extends RuleConfigValue = RuleConfigValue, O extends PlainData = PlainData> = RuleSeed<T, O>;

package/lib/plugin/plugin.d.ts

@@ -1,4 +1,2 @@
 import type { PluginCreator, CreatePluginSettings } from './types';
-export declare function createPlugin<S extends CreatePluginSettings>(
-	fn: Readonly<PluginCreator<S>>,
-): Readonly<PluginCreator<S>>;
+export declare function createPlugin<S extends CreatePluginSettings>(fn: Readonly<PluginCreator<S>>): Readonly<PluginCreator<S>>;

package/lib/plugin/types.d.ts

@@ -1,12 +1,12 @@
 import type { RuleSeed } from '../ml-rule';
 import type { Config } from '@markuplint/ml-config';
 export type Plugin = {
-	readonly name: string;
-	readonly rules?: Readonly<Record<string, Readonly<RuleSeed<any, any>>>>;
-	readonly configs?: Readonly<Record<string, Config>>;
+    readonly name: string;
+    readonly rules?: Readonly<Record<string, Readonly<RuleSeed<any, any>>>>;
+    readonly configs?: Readonly<Record<string, Config>>;
 };
 export type PluginCreator<S extends CreatePluginSettings> = {
-	readonly name: string;
-	create(setting: S): Omit<Plugin, 'name'>;
+    readonly name: string;
+    create(setting: S): Omit<Plugin, 'name'>;
 };
 export type CreatePluginSettings = Readonly<Record<string, unknown>>;

package/lib/ruleset/index.d.ts

@@ -1,7 +1,7 @@
 import type { ChildNodeRule, Config, NodeRule, Rules } from '@markuplint/ml-config';
 export default class Ruleset {
-	readonly childNodeRules: readonly ChildNodeRule[];
-	readonly nodeRules: readonly NodeRule[];
-	readonly rules: Rules;
-	constructor(config: Config);
+    readonly childNodeRules: readonly ChildNodeRule[];
+    readonly nodeRules: readonly NodeRule[];
+    readonly rules: Rules;
+    constructor(config: Config);
 }

package/lib/test/index.d.ts

@@ -3,26 +3,14 @@ import type { Config, PlainData, RuleConfigValue } from '@markuplint/ml-config';
 import type { ExtendedSpec, MLMLSpec } from '@markuplint/ml-spec';
 import { Document } from '../ml-dom';
 export type CreateTestOptions = {
-	readonly config?: Config;
-	readonly parser?: Readonly<MLMarkupLanguageParser>;
-	readonly specs?: MLMLSpec;
+    readonly config?: Config;
+    readonly parser?: Readonly<MLMarkupLanguageParser>;
+    readonly specs?: MLMLSpec;
 };
-export declare function createTestDocument<T extends RuleConfigValue = any, O extends PlainData = any>(
-	sourceCode: string,
-	options?: CreateTestOptions,
-): Document<T, O>;
-export declare function createTestNodeList(
-	sourceCode: string,
-	options?: CreateTestOptions,
-): readonly import('../ml-dom/node/node').MLNode<any, any, import('@markuplint/ml-ast').MLASTAbstractNode>[];
-export declare function createTestTokenList(
-	sourceCode: string,
-	options?: CreateTestOptions,
-): readonly import('../ml-dom/token/token').MLToken<import('@markuplint/ml-ast').MLToken>[];
-export declare function createTestElement(
-	sourceCode: string,
-	options?: CreateTestOptions,
-): import('../ml-dom').Element<any, any>;
+export declare function createTestDocument<T extends RuleConfigValue = any, O extends PlainData = any>(sourceCode: string, options?: CreateTestOptions): Document<T, O>;
+export declare function createTestNodeList(sourceCode: string, options?: CreateTestOptions): readonly import("../ml-dom/node/node").MLNode<any, any, import("@markuplint/ml-ast").MLASTAbstractNode>[];
+export declare function createTestTokenList(sourceCode: string, options?: CreateTestOptions): readonly import("../ml-dom/token/token").MLToken<import("@markuplint/ml-ast").MLToken>[];
+export declare function createTestElement(sourceCode: string, options?: CreateTestOptions): import("../ml-dom").Element<any, any>;
 /**
  * for test suite
  */

package/lib/types.d.ts

@@ -6,12 +6,12 @@ import type { Pretender } from '@markuplint/ml-config';
 import type { ExtendedSpec, MLMLSpec } from '@markuplint/ml-spec';
 export type MLSchema = readonly [MLMLSpec, ...ExtendedSpec[]];
 export type MLFabric = {
-	readonly parser: Readonly<MLMarkupLanguageParser>;
-	readonly ruleset: Partial<Readonly<Ruleset>>;
-	readonly rules: readonly Readonly<AnyMLRule>[];
-	readonly locale: LocaleSet;
-	readonly schemas: MLSchema;
-	readonly parserOptions: ParserOptions;
-	readonly pretenders: readonly Pretender[];
-	readonly configErrors?: readonly Readonly<Error>[];
+    readonly parser: Readonly<MLMarkupLanguageParser>;
+    readonly ruleset: Partial<Readonly<Ruleset>>;
+    readonly rules: readonly Readonly<AnyMLRule>[];
+    readonly locale: LocaleSet;
+    readonly schemas: MLSchema;
+    readonly parserOptions: ParserOptions;
+    readonly pretenders: readonly Pretender[];
+    readonly configErrors?: readonly Readonly<Error>[];
 };

package/lib/utils/get-location-from-chars.d.ts

@@ -1,12 +1,7 @@
 interface Location {
-	line: number;
-	col: number;
-	raw: string;
+    line: number;
+    col: number;
+    raw: string;
 }
-export declare function getLocationFromChars(
-	searches: readonly string[],
-	text: string,
-	currentLine: number,
-	currentCol: number,
-): Location[];
+export declare function getLocationFromChars(searches: readonly string[], text: string, currentLine: number, currentCol: number): Location[];
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "3.9.0",
+	"version": "3.11.0",
 	"description": "The core module of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -23,20 +23,20 @@
 		"./lib/configs.js": "./lib/configs.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/config-presets": "3.6.1",
-		"@markuplint/html-parser": "3.7.0",
-		"@markuplint/html-spec": "3.8.0",
-		"@markuplint/i18n": "3.8.0",
-		"@markuplint/ml-ast": "3.1.0",
-		"@markuplint/ml-config": "3.8.0",
-		"@markuplint/ml-spec": "3.8.0",
-		"@markuplint/parser-utils": "3.7.0",
-		"@markuplint/selector": "3.8.0",
-		"@types/debug": "^4.1.7",
+		"@markuplint/config-presets": "3.7.0",
+		"@markuplint/html-parser": "3.9.0",
+		"@markuplint/html-spec": "3.10.0",
+		"@markuplint/i18n": "3.9.0",
+		"@markuplint/ml-ast": "3.2.0",
+		"@markuplint/ml-config": "3.10.0",
+		"@markuplint/ml-spec": "3.10.0",
+		"@markuplint/parser-utils": "3.9.0",
+		"@markuplint/selector": "3.10.0",
+		"@types/debug": "^4.1.8",
 		"debug": "^4.3.4",
 		"is-plain-object": "^5.0.0",
-		"tslib": "^2.4.1",
-		"type-fest": "^3.8.0"
+		"tslib": "^2.5.3",
+		"type-fest": "^3.11.1"
 	},
-	"gitHead": "adc6e432cccba7cfad0dc8bf9f92e5aaf1107359"
+	"gitHead": "9547b8dca20736a93e4d01af2d61bee314ba5718"
 }

package/test/ml-dom/ml-rule/create-rule.spec.js

@@ -0,0 +1,108 @@
+const { createRule } = require('../../../lib/ml-rule/create-test-rule');
+const { createTestDocument } = require('../../../lib/test');
+
+describe('createRule', () => {
+	test('defaultValue', () => {
+		const document = createTestDocument('<div></div>');
+
+		const rule = createRule({
+			name: 'test-rule',
+			defaultValue: [1, 2, 3],
+			verify({ document }) {
+				expect(document.rule.value).toStrictEqual([1, 2, 3]);
+
+				document.getElementsByTagName('div').forEach(el => {
+					expect(el.rule.value).toStrictEqual([1, 2, 3]);
+				});
+
+				return;
+			},
+		});
+
+		void rule.verify(document, { locale: 'en' });
+	});
+
+	test('Change value from config', () => {
+		const document = createTestDocument('<div></div>', {
+			config: {
+				rules: {
+					'test-rule': {
+						value: [4, 5, 6],
+					},
+				},
+			},
+		});
+
+		const rule = createRule({
+			name: 'test-rule',
+			defaultValue: [1, 2, 3],
+			verify({ document }) {
+				expect(document.rule.value).toStrictEqual([4, 5, 6]);
+
+				document.getElementsByTagName('div').forEach(el => {
+					expect(el.rule.value).toStrictEqual([4, 5, 6]);
+				});
+
+				return;
+			},
+		});
+
+		void rule.verify(document, { locale: 'en' });
+	});
+
+	test('Change value to true from config', () => {
+		const document = createTestDocument('<div></div>', {
+			config: {
+				rules: {
+					'test-rule': {
+						value: true,
+					},
+				},
+			},
+		});
+
+		const rule = createRule({
+			name: 'test-rule',
+			defaultValue: [1, 2, 3],
+			verify({ document }) {
+				expect(document.rule.value).toStrictEqual([1, 2, 3]);
+
+				document.getElementsByTagName('div').forEach(el => {
+					expect(el.rule.value).toStrictEqual([1, 2, 3]);
+				});
+
+				return;
+			},
+		});
+
+		void rule.verify(document, { locale: 'en' });
+	});
+
+	test('Change severity', () => {
+		const document = createTestDocument('<div></div>', {
+			config: {
+				rules: {
+					'test-rule': {
+						severity: 'warning',
+					},
+				},
+			},
+		});
+
+		const rule = createRule({
+			name: 'test-rule',
+			defaultValue: [],
+			verify({ document }) {
+				expect(document.rule.value).toStrictEqual([]);
+
+				document.getElementsByTagName('div').forEach(el => {
+					expect(el.rule.value).toStrictEqual([]);
+				});
+
+				return;
+			},
+		});
+
+		void rule.verify(document, { locale: 'en' });
+	});
+});