@markuplint/ml-core 2.3.3 → 3.0.0-alpha.1

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

@@ -5,10 +5,9 @@ exports.MLRuleContext = void 0;
 const tslib_1 = require("tslib");
 const i18n_1 = require("@markuplint/i18n");
 class MLRuleContext {
-    constructor(document, locale, rule) {
+    constructor(document, locale) {
         _MLRuleContext_reports.set(this, []);
         this.document = document;
-        this.globalRule = rule;
         this.translate = (0, i18n_1.translator)(locale);
         this.locale = locale.locale;
     }
@@ -18,19 +17,31 @@ class MLRuleContext {
             message: finish(report.message),
         }));
     }
-    report(report) {
-        tslib_1.__classPrivateFieldGet(this, _MLRuleContext_reports, "f").push(report);
-    }
     provide() {
         return {
             document: this.document,
             translate: this.translate,
             t: this.translate,
-            globalRule: this.globalRule,
             reports: this.reports,
             report: this.report.bind(this),
         };
     }
+    report(report) {
+        if (typeof report === 'function') {
+            const r = report(this.translate);
+            if (r) {
+                this._push(r);
+                return true;
+            }
+            return false;
+        }
+        this._push(report);
+    }
+    _push(report) {
+        if (!tslib_1.__classPrivateFieldGet(this, _MLRuleContext_reports, "f").find(r => is(r, report))) {
+            tslib_1.__classPrivateFieldGet(this, _MLRuleContext_reports, "f").push(report);
+        }
+    }
 }
 exports.MLRuleContext = MLRuleContext;
 _MLRuleContext_reports = new WeakMap();
@@ -42,3 +53,15 @@ function finish(message, locale = 'en') {
     }
     return message;
 }
+function is(r1, r2) {
+    if ('col' in r1 && 'col' in r2) {
+        return r1.col === r2.col && r1.line === r2.line && r1.message === r2.message && r1.raw === r2.raw;
+    }
+    if ('scope' in r1) {
+        if (!('scope' in r2)) {
+            return false;
+        }
+        return r1.scope === r2.scope && r1.message === r2.message;
+    }
+    return false;
+}

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

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

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

@@ -1,5 +1,5 @@
 "use strict";
-var _MLRule_v, _MLRule_f;
+var _MLRule_f, _MLRule_v;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MLRule = void 0;
 const tslib_1 = require("tslib");
@@ -7,10 +7,10 @@ const ml_rule_context_1 = require("./ml-rule-context");
 class MLRule {
     constructor(o) {
         var _a, _b;
-        _MLRule_v.set(this, void 0);
         _MLRule_f.set(this, void 0);
+        _MLRule_v.set(this, void 0);
         this.name = o.name;
-        this.defaultServerity = o.defaultServerity || 'error';
+        this.defaultSeverity = o.defaultSeverity || 'error';
         this.defaultValue = (_a = o.defaultValue) !== null && _a !== void 0 ? _a : true;
         this.defaultOptions = (_b = o.defaultOptions) !== null && _b !== void 0 ? _b : null;
         tslib_1.__classPrivateFieldSet(this, _MLRule_v, o.verify, "f");
@@ -20,22 +20,69 @@ class MLRule {
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
-    get v() {
-        return tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f");
+    get f() {
+        return tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f");
     }
     /**
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
-    get f() {
-        return tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f");
+    get v() {
+        return tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f");
+    }
+    getRuleInfo(ruleSet, ruleName) {
+        const info = this._optimize(ruleSet.rules, ruleName);
+        return {
+            ...info,
+            nodeRules: ruleSet.nodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
+            childNodeRules: ruleSet.childNodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
+        };
+    }
+    optimizeOption(configSettings) {
+        if (configSettings === undefined || typeof configSettings === 'boolean') {
+            return {
+                disabled: !configSettings,
+                severity: this.defaultSeverity,
+                value: this.defaultValue,
+                option: this.defaultOptions,
+                reason: undefined,
+            };
+        }
+        if (!Array.isArray(configSettings) && typeof configSettings === 'object' && configSettings !== null) {
+            return {
+                disabled: false,
+                severity: configSettings.severity || this.defaultSeverity,
+                value: configSettings.value !== undefined ? configSettings.value : this.defaultValue,
+                option: Array.isArray(this.defaultOptions)
+                    ? configSettings.option
+                        ? // prettier-ignore
+                            // @ts-ignore for "as" casting
+                            this.defaultOptions.concat(configSettings.option)
+                        : this.defaultOptions
+                    : this.defaultOptions !== null &&
+                        typeof this.defaultOptions === 'object' &&
+                        // for example `configSettings.option === true`
+                        (configSettings.option == null || typeof configSettings.option === 'object')
+                        ? { ...this.defaultOptions, ...(configSettings.option || {}) }
+                        : configSettings.option || this.defaultOptions,
+                reason: configSettings.reason,
+            };
+        }
+        return {
+            disabled: false,
+            severity: this.defaultSeverity,
+            // @ts-ignore TODO: Wait for fix to bug of type guards in TypeScript
+            value: configSettings == null ? this.defaultValue : configSettings,
+            option: this.defaultOptions,
+            reason: undefined,
+        };
     }
-    async verify(document, locale, globalRule, fix) {
+    async verify(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, globalRule);
+        const context = new ml_rule_context_1.MLRuleContext(document, locale);
         const providableContext = context.provide();
         await tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f").call(this, providableContext);
         if (tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f") && fix) {
@@ -46,7 +93,7 @@ class MLRule {
                 let line = report.scope.startLine;
                 let col = report.scope.startCol;
                 let raw = report.scope.raw;
-                if ('line' in report) {
+                if ('line' in report && report.line != null) {
                     line = report.line;
                     col = report.col;
                     raw = report.raw;
@@ -59,79 +106,32 @@ class MLRule {
                     raw,
                     ruleId: this.name,
                 };
-                if (report.scope.rule.reason || globalRule.reason) {
-                    violation.reason = report.scope.rule.reason || globalRule.reason;
+                if (report.scope.rule.reason || document.rule.reason) {
+                    violation.reason = report.scope.rule.reason || document.rule.reason;
                 }
                 return violation;
             }
             const violation = {
-                severity: globalRule.severity,
+                severity: document.rule.severity,
                 message: report.message,
                 line: report.line,
                 col: report.col,
                 raw: report.raw,
                 ruleId: this.name,
             };
-            if (globalRule.reason) {
-                violation.reason = globalRule.reason;
+            if (document.rule.reason) {
+                violation.reason = document.rule.reason;
             }
             return violation;
         });
         document.setRule(null);
         return violation;
     }
-    getRuleInfo(ruleSet, ruleName) {
-        const info = this._optimize(ruleSet.rules, ruleName);
-        return {
-            ...info,
-            nodeRules: ruleSet.nodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
-            childNodeRules: ruleSet.childNodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
-        };
-    }
     _optimize(rules, ruleName) {
         const rule = (rules && rules[ruleName]) || false;
         const info = this.optimizeOption(rule);
         return info;
     }
-    optimizeOption(configSettings) {
-        if (configSettings === undefined || typeof configSettings === 'boolean') {
-            return {
-                disabled: !configSettings,
-                severity: this.defaultServerity,
-                value: this.defaultValue,
-                option: this.defaultOptions,
-                reason: undefined,
-            };
-        }
-        if (!Array.isArray(configSettings) && typeof configSettings === 'object' && configSettings !== null) {
-            return {
-                disabled: false,
-                severity: configSettings.severity || this.defaultServerity,
-                value: configSettings.value !== undefined ? configSettings.value : this.defaultValue,
-                option: Array.isArray(this.defaultOptions)
-                    ? configSettings.option
-                        ? // prettier-ignore
-                            // @ts-ignore for "as" casting
-                            this.defaultOptions.concat(configSettings.option)
-                        : this.defaultOptions
-                    : this.defaultOptions !== null &&
-                        typeof this.defaultOptions === 'object' &&
-                        // for example `configSettings.option === true`
-                        (configSettings.option == null || typeof configSettings.option === 'object')
-                        ? { ...this.defaultOptions, ...(configSettings.option || {}) }
-                        : configSettings.option || this.defaultOptions,
-                reason: configSettings.reason,
-            };
-        }
-        return {
-            disabled: false,
-            severity: this.defaultServerity,
-            // @ts-ignore TODO: Wait for fix to bug of type guards in TypeScript
-            value: configSettings == null ? this.defaultValue : configSettings,
-            option: this.defaultOptions,
-            reason: undefined,
-        };
-    }
 }
 exports.MLRule = MLRule;
-_MLRule_v = new WeakMap(), _MLRule_f = new WeakMap();
+_MLRule_f = new WeakMap(), _MLRule_v = new WeakMap();

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

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

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 rules: Readonly<Rules>;
-    readonly nodeRules: ReadonlyArray<NodeRule>;
     readonly childNodeRules: ReadonlyArray<ChildNodeRule>;
+    readonly nodeRules: ReadonlyArray<NodeRule>;
+    readonly rules: Readonly<Rules>;
     constructor(config: Config);
 }

package/lib/test/index.d.ts

@@ -5,9 +5,11 @@ import { Document } from '../ml-dom';
 export declare type CreateTestOptions = {
     config?: Config;
     parser?: MLMarkupLanguageParser;
+    specs?: MLMLSpec;
 };
 export declare function createTestDocument<T extends RuleConfigValue = any, O = any>(sourceCode: string, options?: CreateTestOptions): Document<T, O>;
-export declare function createTestNodeList(sourceCode: string, options?: CreateTestOptions): readonly import("../ml-dom").AnonymousNode<any, any>[];
+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/test/index.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dummySchemas = exports.createTestElement = exports.createTestNodeList = exports.createTestDocument = void 0;
+exports.dummySchemas = exports.createTestElement = exports.createTestTokenList = exports.createTestNodeList = exports.createTestDocument = void 0;
+const tslib_1 = require("tslib");
 const html_parser_1 = require("@markuplint/html-parser");
+const html_spec_1 = tslib_1.__importDefault(require("@markuplint/html-spec"));
 const convert_ruleset_1 = require("../convert-ruleset");
 const ml_dom_1 = require("../ml-dom");
 function createTestDocument(sourceCode, options) {
+    var _a;
     const ast = (options === null || options === void 0 ? void 0 : options.parser) ? options.parser.parse(sourceCode) : (0, html_parser_1.parse)(sourceCode);
     const ruleset = (0, convert_ruleset_1.convertRuleset)(options === null || options === void 0 ? void 0 : options.config);
-    const document = new ml_dom_1.Document(ast, ruleset, [{}, {}]);
+    const document = new ml_dom_1.Document(ast, ruleset, [(_a = options === null || options === void 0 ? void 0 : options.specs) !== null && _a !== void 0 ? _a : {}, {}]);
     return document;
 }
 exports.createTestDocument = createTestDocument;
@@ -16,10 +19,15 @@ function createTestNodeList(sourceCode, options) {
     return document.nodeList;
 }
 exports.createTestNodeList = createTestNodeList;
+function createTestTokenList(sourceCode, options) {
+    const document = createTestDocument(sourceCode, options);
+    return document.getTokenList();
+}
+exports.createTestTokenList = createTestTokenList;
 function createTestElement(sourceCode, options) {
     const document = createTestDocument(sourceCode, options);
     const el = document.nodeList[0];
-    if (el.type === 'Element') {
+    if (el.is(el.ELEMENT_NODE)) {
         return el;
     }
     throw TypeError(`Could not parse it to be an element from: ${sourceCode}`);
@@ -29,7 +37,6 @@ exports.createTestElement = createTestElement;
  * for test suite
  */
 function dummySchemas() {
-    // @ts-ignore
-    return [{}, {}];
+    return [html_spec_1.default];
 }
 exports.dummySchemas = dummySchemas;

package/lib/types.d.ts

@@ -1,8 +1,8 @@
 import type { AnyMLRule } from './ml-rule';
 import type Ruleset from './ruleset';
 import type { LocaleSet } from '@markuplint/i18n';
-import type { MLMarkupLanguageParser } from '@markuplint/ml-ast';
-import type { ParserOptions } from '@markuplint/ml-config';
+import type { MLMarkupLanguageParser, ParserOptions } from '@markuplint/ml-ast';
+import type { Pretender } from '@markuplint/ml-config';
 import type { ExtendedSpec, MLMLSpec } from '@markuplint/ml-spec';
 export declare type MLSchema = Readonly<[MLMLSpec, ...ExtendedSpec[]]>;
 export declare type MLFabric = {
@@ -12,4 +12,5 @@ export declare type MLFabric = {
     locale: LocaleSet;
     schemas: MLSchema;
     parserOptions: ParserOptions;
+    pretenders: Pretender[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "2.3.3",
+	"version": "3.0.0-alpha.1",
 	"description": "The core module of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -17,19 +17,20 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/i18n": "2.1.1",
-		"@markuplint/ml-ast": "2.0.1-dev.20220307.0",
-		"@markuplint/ml-config": "2.1.0",
-		"@markuplint/ml-spec": "2.1.1",
-		"@markuplint/parser-utils": "2.2.1",
+		"@markuplint/config-presets": "3.0.0-alpha.1",
+		"@markuplint/i18n": "3.0.0-alpha.1",
+		"@markuplint/ml-ast": "3.0.0-alpha.1",
+		"@markuplint/ml-config": "3.0.0-alpha.1",
+		"@markuplint/ml-spec": "3.0.0-alpha.1",
+		"@markuplint/parser-utils": "3.0.0-alpha.1",
+		"@markuplint/selector": "3.0.0-alpha.1",
 		"debug": "^4.3.4",
-		"dom-accessibility-api": "^0.5.13",
 		"postcss-selector-parser": "^6.0.10",
-		"tslib": "^2.3.1"
+		"tslib": "^2.4.0"
 	},
 	"devDependencies": {
-		"@markuplint/html-parser": "2.2.2",
+		"@markuplint/html-parser": "3.0.0-alpha.1",
 		"@types/debug": "^4.1.7"
 	},
-	"gitHead": "c28258b756d8c42890698e26c03cdc02c6833489"
+	"gitHead": "56de89456146a06777eb5b6d4e8ba456147dd18b"
 }