@markuplint/ml-core 3.5.0 → 3.6.1

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

@@ -3,51 +3,59 @@ import type { MLDocument } from '../ml-dom/node/document';
 import type { LocaleSet, Translator } from '@markuplint/i18n';
 import type { PlainData, Report, RuleConfigValue } from '@markuplint/ml-config';
 export declare class MLRuleContext<T extends RuleConfigValue, O extends PlainData = undefined> {
-    #private;
-    readonly document: MLDocument<T, O>;
-    readonly locale: string;
-    readonly translate: Translator;
-    constructor(document: MLDocument<T, O>, locale: LocaleSet);
-    get reports(): ({
-        message: string;
-        line: number;
-        col: number;
-        raw: string;
-    } | {
-        message: string;
-        scope: import("@markuplint/ml-config").Scope<T, O>;
-    } | {
-        message: string;
-        scope: import("@markuplint/ml-config").Scope<T, O>;
-        line: number;
-        col: number;
-        raw: string;
-    })[];
-    provide(): {
-        document: MLDocument<T, O>;
-        translate: Translator;
-        t: Translator;
-        reports: ({
-            message: string;
-            line: number;
-            col: number;
-            raw: string;
-        } | {
-            message: string;
-            scope: import("@markuplint/ml-config").Scope<T, O>;
-        } | {
-            message: string;
-            scope: import("@markuplint/ml-config").Scope<T, O>;
-            line: number;
-            col: number;
-            raw: string;
-        })[];
-        report: {
-            (report: Report<T, O>): undefined;
-            (report: CheckerReport<T, O>): boolean;
-        };
-    };
-    report(report: Report<T, O>): undefined;
-    report(report: CheckerReport<T, O>): boolean;
-    private _push;
+	#private;
+	readonly document: MLDocument<T, O>;
+	readonly locale: string;
+	readonly translate: Translator;
+	constructor(document: MLDocument<T, O>, locale: LocaleSet);
+	get reports(): (
+		| {
+				message: string;
+				line: number;
+				col: number;
+				raw: string;
+		  }
+		| {
+				message: string;
+				scope: import('@markuplint/ml-config').Scope<T, O>;
+		  }
+		| {
+				message: string;
+				scope: import('@markuplint/ml-config').Scope<T, O>;
+				line: number;
+				col: number;
+				raw: string;
+		  }
+	)[];
+	provide(): {
+		document: MLDocument<T, O>;
+		translate: Translator;
+		t: Translator;
+		reports: (
+			| {
+					message: string;
+					line: number;
+					col: number;
+					raw: string;
+			  }
+			| {
+					message: string;
+					scope: import('@markuplint/ml-config').Scope<T, O>;
+			  }
+			| {
+					message: string;
+					scope: import('@markuplint/ml-config').Scope<T, O>;
+					line: number;
+					col: number;
+					raw: string;
+			  }
+		)[];
+		report: {
+			(report: Report<T, O>): undefined;
+			(report: CheckerReport<T, O>): boolean;
+		};
+	};
+	report(report: Report<T, O>): undefined;
+	report(report: CheckerReport<T, O>): boolean;
+	private _push;
 }

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

@@ -2,29 +2,39 @@ import type { RuleSeed } from './types';
 import type { Ruleset } from '..';
 import type { MLDocument } from '../ml-dom/node/document';
 import type { LocaleSet } from '@markuplint/i18n';
-import type { GlobalRuleInfo, PlainData, Rule, RuleConfigValue, RuleInfo, Severity, Violation } from '@markuplint/ml-config';
+import type {
+	GlobalRuleInfo,
+	PlainData,
+	Rule,
+	RuleConfigValue,
+	RuleInfo,
+	Severity,
+	Violation,
+} from '@markuplint/ml-config';
 export declare class MLRule<T extends RuleConfigValue, O extends PlainData = undefined> {
-    #private;
-    readonly defaultOptions: O;
-    readonly defaultSeverity: Severity;
-    readonly defaultValue: T;
-    readonly name: string;
-    constructor(o: Readonly<RuleSeed<T, O>> & {
-        readonly name: string;
-    });
-    /**
-     * The following getter is unused internally,
-     * only for extending from 3rd party library
-     */
-    protected get f(): RuleSeed<T, O>['fix'];
-    /**
-     * The following getter is unused internally,
-     * only for extending from 3rd party library
-     */
-    protected get v(): RuleSeed<T, O>['verify'];
-    getRuleInfo(ruleSet: Ruleset, ruleName: string): GlobalRuleInfo<T, O>;
-    optimizeOption(configSettings: Rule<T, O> | null | undefined): RuleInfo<T, O>;
-    verify(document: MLDocument<T, O>, locale: LocaleSet, fix: boolean): Promise<Violation[]>;
-    private _optimize;
+	#private;
+	readonly defaultOptions: O;
+	readonly defaultSeverity: Severity;
+	readonly defaultValue: T;
+	readonly name: string;
+	constructor(
+		o: Readonly<RuleSeed<T, O>> & {
+			readonly name: string;
+		},
+	);
+	/**
+	 * The following getter is unused internally,
+	 * only for extending from 3rd party library
+	 */
+	protected get f(): RuleSeed<T, O>['fix'];
+	/**
+	 * The following getter is unused internally,
+	 * only for extending from 3rd party library
+	 */
+	protected get v(): RuleSeed<T, O>['verify'];
+	getRuleInfo(ruleSet: Ruleset, ruleName: string): GlobalRuleInfo<T, O>;
+	optimizeOption(configSettings: Rule<T, O> | null | undefined): RuleInfo<T, O>;
+	verify(document: MLDocument<T, O>, locale: LocaleSet, fix: boolean): Promise<Violation[]>;
+	private _optimize;
 }
 export type AnyMLRule = MLRule<RuleConfigValue, PlainData>;

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

@@ -41,6 +41,7 @@ class MLRule {
         };
     }
     optimizeOption(configSettings) {
+        var _a;
         if (configSettings === undefined || typeof configSettings === 'boolean') {
             return {
                 disabled: !configSettings,
@@ -53,7 +54,7 @@ class MLRule {
         if (isRuleConfig(configSettings)) {
             return {
                 disabled: false,
-                severity: configSettings.severity || this.defaultSeverity,
+                severity: (_a = configSettings.severity) !== null && _a !== void 0 ? _a : this.defaultSeverity,
                 value: configSettings.value !== undefined ? configSettings.value : this.defaultValue,
                 options: mergeOptions(this.defaultOptions, configSettings.options),
                 reason: configSettings.reason,
@@ -70,9 +71,6 @@ class MLRule {
     async verify(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     document, locale, fix) {
-        if (!tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f")) {
-            return [];
-        }
         document.setRule(this);
         const context = new ml_rule_context_1.MLRuleContext(document, locale);
         const providableContext = context.provide();
@@ -81,6 +79,7 @@ class MLRule {
             await tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f").call(this, providableContext);
         }
         const violation = context.reports.map(report => {
+            var _a;
             if ('scope' in report) {
                 let line = report.scope.startLine;
                 let col = report.scope.startCol;
@@ -97,7 +96,7 @@ class MLRule {
                     col,
                     raw,
                     ruleId: this.name,
-                    reason: report.scope.rule.reason || document.rule.reason,
+                    reason: (_a = report.scope.rule.reason) !== null && _a !== void 0 ? _a : document.rule.reason,
                 };
                 (0, ml_config_1.deleteUndefProp)(violation);
                 return violation;

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

@@ -3,18 +3,36 @@ 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,2 +1,4 @@
 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,14 +3,26 @@ 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,7 +1,12 @@
 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.5.0",
+	"version": "3.6.1",
 	"description": "The core module of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -23,23 +23,22 @@
 		"./lib/configs.js": "./lib/configs.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/config-presets": "3.4.0",
-		"@markuplint/html-parser": "3.5.0",
-		"@markuplint/html-spec": "3.5.0",
-		"@markuplint/i18n": "3.5.0",
+		"@markuplint/config-presets": "3.5.0",
+		"@markuplint/html-parser": "3.6.1",
+		"@markuplint/html-spec": "3.6.1",
+		"@markuplint/i18n": "3.6.0",
 		"@markuplint/ml-ast": "3.1.0",
-		"@markuplint/ml-config": "3.5.0",
-		"@markuplint/ml-spec": "3.5.0",
-		"@markuplint/parser-utils": "3.5.0",
-		"@markuplint/selector": "3.5.0",
+		"@markuplint/ml-config": "3.6.1",
+		"@markuplint/ml-spec": "3.6.1",
+		"@markuplint/parser-utils": "3.6.1",
+		"@markuplint/selector": "3.6.1",
 		"debug": "^4.3.4",
 		"is-plain-object": "^5.0.0",
 		"tslib": "^2.4.1"
 	},
 	"devDependencies": {
-		"@markuplint/html-parser": "3.3.0",
 		"@types/debug": "^4.1.7",
 		"type-fest": "^3.6.1"
 	},
-	"gitHead": "0c47b2c2722f6823a17f36edbab98486275f8ab4"
+	"gitHead": "3cdf5a088b2da03773d5d4461d0e65ec32290a00"
 }