v2.0.0

.eslintrc

@@ -7,7 +7,7 @@
         "func-style": 0,
         "quotes": 0,
         "max-len": [
-            "error",
+            "warn",
             {
                 "code": 120,
                 "comments": 80,

.gitignore

@@ -1 +1,3 @@
-node_modules
+*.tsbuildinfo
+lib/**/*.d.ts
+node_modules/

lib/RuleContext.js

@@ -0,0 +1,107 @@
+/**
+ * @author Sophie Bremer
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleContext = void 0;
+const FS = require("fs");
+const Path = require("path");
+const SourceCode_1 = require("./SourceCode");
+const SourceTree_1 = require("./SourceTree");
+/* *
+ *
+ *  Class
+ *
+ * */
+class RuleContext {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    constructor(esLintContext, ruleOptionsDefault) {
+        this.cwd = esLintContext.getCwd();
+        this.esLintContext = esLintContext;
+        this.settings = ((esLintContext.settings || {}).highcharts || {});
+        this.options = Object.assign(Object.assign(Object.assign({}, ruleOptionsDefault), this.settings), (esLintContext.options[1] || {}));
+        this.preparedReports = [];
+        this.sourcePath = Path.relative(this.cwd, esLintContext.getFilename());
+    }
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    static setupRuleExport(ruleType, ruleOptionsSchema, ruleOptionsDefault, lintFunction, reportWithFix) {
+        return {
+            meta: {
+                fixable: reportWithFix ? 'code' : void 0,
+                schema: [{
+                        additionalProperties: false,
+                        properties: ruleOptionsSchema,
+                        type: 'object'
+                    }],
+                type: ruleType
+            },
+            create: (esLintRuleContext) => ({
+                Program: () => lintFunction(new RuleContext(esLintRuleContext, ruleOptionsDefault))
+            })
+        };
+    }
+    get sourceCode() {
+        if (!this._sourceCode) {
+            const sourcePath = this.sourcePath;
+            this._sourceCode = new SourceCode_1.default(sourcePath, FS.readFileSync(sourcePath).toString());
+        }
+        return this._sourceCode;
+    }
+    get sourceTree() {
+        if (!this._sourceTree) {
+            const sourcePath = this.sourcePath;
+            this._sourceTree = new SourceTree_1.default(sourcePath, FS.readFileSync(sourcePath).toString());
+        }
+        return this._sourceTree;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    prepareReport(position, message) {
+        this.preparedReports.push({
+            loc: {
+                // ESLint needs column zero-based:
+                column: position.column - 1,
+                line: position.line
+            },
+            message
+        });
+    }
+    sendReports(finalFix) {
+        const esLintContext = this.esLintContext, reports = this.preparedReports.splice(0);
+        if (finalFix) {
+            for (let i = 0, iEnd = reports.length - 1, report; i <= iEnd; ++i) {
+                report = reports[i];
+                if (i === iEnd) {
+                    report.fix = finalFix;
+                }
+                else {
+                    report.fix = () => null;
+                }
+                esLintContext.report(report);
+            }
+        }
+        else {
+            for (const report of reports) {
+                esLintContext.report(report);
+            }
+        }
+    }
+}
+exports.RuleContext = RuleContext;
+/* *
+ *
+ *  Default Export
+ *
+ * */
+exports.default = RuleContext;

lib/SourceCode.js

@@ -0,0 +1,133 @@
+/**
+ * @author Sophie Bremer
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceCode = void 0;
+const TS = require("typescript");
+const U = require("./Utilities");
+const SourceComment_1 = require("./SourceComment");
+const SourceDoc_1 = require("./SourceDoc");
+const SourceLine_1 = require("./SourceLine");
+/* *
+ *
+ *  Constant
+ *
+ * */
+const tsScanner = TS.createScanner(TS.ScriptTarget.Latest, false);
+/* *
+ *
+ *  Class
+ *
+ * */
+class SourceCode {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    constructor(fileName, sourceCode) {
+        this.fileName = fileName;
+        this.lineBreak = U.detectLineBreak(sourceCode) || '\n';
+        this.lines = [];
+        this.raw = sourceCode;
+        this.parse(sourceCode);
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    getLinePosition(line) {
+        const lines = this.lines, lineIndex = lines.indexOf(line), position = {
+            column: 1,
+            end: 0,
+            line: 1,
+            start: 0
+        };
+        if (lineIndex < 0) {
+            return null;
+        }
+        for (let i = 0, tokens, tokenLength, tokenText; i < lineIndex; ++i) {
+            tokens = lines[i].tokens;
+            for (const token of tokens) {
+                tokenText = token.text;
+                if (token.kind === TS.SyntaxKind.JSDocComment ||
+                    token.kind === TS.SyntaxKind.MultiLineCommentTrivia) {
+                    tokenLength = tokenText.split(U.LINE_BREAKS).length;
+                    if (tokenLength > 1) {
+                        position.line += tokenLength - 1;
+                    }
+                }
+                position.start += tokenText.length;
+            }
+            position.line += 1;
+            position.start += 1; // line break
+        }
+        position.end = position.start + line.toString().length;
+        return position;
+    }
+    /**
+     * Returns the token position relative to the code.
+     */
+    getTokenPosition(line, token) {
+        const linePosition = this.getLinePosition(line), tokenPosition = line.getTokenPosition(token);
+        if (!linePosition || !tokenPosition) {
+            return null;
+        }
+        return {
+            column: tokenPosition.column,
+            end: linePosition.start + tokenPosition.end,
+            line: linePosition.line + tokenPosition.line - 1,
+            start: linePosition.start + tokenPosition.start
+        };
+    }
+    parse(sourceCode, replace = false) {
+        const lineBreak = this.lineBreak, lines = this.lines;
+        if (replace) {
+            lines.length = 0;
+        }
+        if (!sourceCode) {
+            return;
+        }
+        let indent, kind, line = new SourceLine_1.default(lineBreak), text, token;
+        tsScanner.setText(sourceCode);
+        do {
+            kind = tsScanner.scan();
+            text = tsScanner.getTokenText();
+            if (kind === TS.SyntaxKind.NewLineTrivia ||
+                kind === TS.SyntaxKind.EndOfFileToken) {
+                lines.push(line);
+                line = new SourceLine_1.default(lineBreak);
+                continue;
+            }
+            if (kind === TS.SyntaxKind.MultiLineCommentTrivia) {
+                indent = Math.floor(line.getIndent() / 2) * 2;
+                if (SourceDoc_1.default.isSourceDoc(text)) {
+                    token = new SourceDoc_1.default(text, lineBreak, indent);
+                }
+                else {
+                    token = new SourceComment_1.default(text, lineBreak, indent);
+                }
+            }
+            else {
+                token = { kind, text };
+            }
+            line.tokens.push(token);
+        } while (kind !== TS.SyntaxKind.EndOfFileToken);
+    }
+    toString(maximalLength) {
+        const lines = this.lines, strings = [];
+        for (const line of lines) {
+            strings.push(line.toString(maximalLength));
+        }
+        return strings.join(this.lineBreak);
+    }
+}
+exports.SourceCode = SourceCode;
+/* *
+ *
+ *  Default Export
+ *
+ * */
+exports.default = SourceCode;

lib/SourceComment.js

@@ -0,0 +1,114 @@
+/**
+ * @author Sophie Bremer
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceComment = void 0;
+/* *
+ *
+ *  Imports
+ *
+ * */
+const TS = require("typescript");
+const U = require("./Utilities");
+const SourceLine_1 = require("./SourceLine");
+/* *
+ *
+ *  Constants
+ *
+ * */
+const starPattern = /^[ \t]+\*[ \t]?/u;
+/* *
+ *
+ *  Class
+ *
+ * */
+class SourceComment extends SourceLine_1.default {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    constructor(text, lineBreak = '\n', indent = 0) {
+        super(lineBreak);
+        this.indent = indent;
+        this.kind = TS.SyntaxKind.MultiLineCommentTrivia;
+        const lines = text.split(U.LINE_BREAKS), tokens = this.tokens;
+        for (let i = 0, iEnd = lines.length; i < iEnd; ++i) {
+            tokens.push({
+                kind: TS.SyntaxKind.SingleLineCommentTrivia,
+                text: (i ? lines[i].substr(indent) : lines[i])
+            });
+        }
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    static extractCommentLines(text, indent = 0) {
+        let lines = text.split(U.LINE_BREAKS);
+        if (lines.length === 1) {
+            // remove /** and */
+            return [text.substr(4, text.length - 7)];
+        }
+        // remove /**\n and \n*/
+        lines = lines.slice(1, -1);
+        for (let i = 0, iEnd = lines.length, line; i < iEnd; ++i) {
+            line = lines[i];
+            if (line.match(starPattern)) {
+                // remove *
+                lines[i] = line.replace(starPattern, '');
+            }
+            else if (indent) {
+                // remove indent
+                lines[i] = line.substr(indent);
+            }
+        }
+        return lines;
+    }
+    get text() {
+        return this.toString();
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    getIndent() {
+        return this.indent;
+    }
+    toString(maximalLength) {
+        const indent = this.indent, lines = [];
+        if (maximalLength) {
+            let line = '', words;
+            for (const token of this.tokens) {
+                words = token.text.split(' ');
+                line = words.shift() || '';
+                for (const word of words) {
+                    if (line.length + 1 + word.length > maximalLength) {
+                        lines.push(line.trimRight());
+                        line = U.pad(indent, word);
+                    }
+                    else {
+                        line += ` ${word}`;
+                    }
+                }
+                lines.push(line.trimRight());
+            }
+        }
+        else {
+            for (const token of this.tokens) {
+                lines.push(U.pad(indent, token.text));
+            }
+        }
+        return lines.join(this.lineBreak).substr(indent);
+    }
+}
+exports.SourceComment = SourceComment;
+/* *
+ *
+ *  Default Export
+ *
+ * */
+exports.default = SourceComment;