@adobe/remark-gridtables 3.0.4 → 3.0.5

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [3.0.5](https://github.com/adobe/remark-gridtables/compare/v3.0.4...v3.0.5) (2024-06-08)
+
+
+### Bug Fixes
+
+* **deps:** update dependency @adobe/mdast-util-gridtables to v4.0.5 ([#100](https://github.com/adobe/remark-gridtables/issues/100)) ([8074e31](https://github.com/adobe/remark-gridtables/commit/8074e31c1b60cc48b58018ac332f9aca08f234af))
+
 ## [3.0.4](https://github.com/adobe/remark-gridtables/compare/v3.0.3...v3.0.4) (2024-04-02)
 
 

package/eslint/index.js

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2019 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import globals from 'globals';
+import header from './plugins/header/index.cjs';
+
+import bestPractices from './rules/best-practices.js';
+import errors from './rules/errors.js';
+import es6 from './rules/es6.js';
+import node from './rules/node.js';
+import strict from './rules/strict.js';
+import style from './rules/style.js';
+import variables from './rules/variables.js';
+
+const common = {
+  languageOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+    globals: {
+      ...globals.node,
+      ...globals.es6,
+      '__rootdir': true,
+    },
+  },
+  plugins: {
+    header,
+  },
+  rules: {
+    ...bestPractices.rules,
+    ...errors.rules,
+    ...es6.rules,
+    ...node.rules,
+    ...strict.rules,
+    ...style.rules,
+    ...variables.rules,
+
+    strict: 0,
+
+    'import/prefer-default-export': 0,
+
+    // Forbid multiple statements in one line
+    'max-statements-per-line': ['error', { max: 1 }],
+
+    // Allow for-of loops
+    'no-restricted-syntax': ['error', 'ForInStatement', 'LabeledStatement', 'WithStatement'],
+
+    // Allow return before else & redundant else statements
+    'no-else-return': 'off',
+
+    // allow dangling underscores for 'fields'
+    'no-underscore-dangle': ['error', {
+      allowAfterThis: true,
+    }],
+
+    // allow '_' as a throw-away variable
+    'no-unused-vars': ['error', {
+      argsIgnorePattern: '^_$',
+      varsIgnorePattern: '^_$',
+    }],
+
+    'no-shadow': ['error', {
+      allow: ['_'],
+    }],
+
+    // don't enforce extension rules
+    // 'import/extensions': [2, 'ignorePackages'],
+
+    // enforce license header
+    'header/header': [2, 'block', ['',
+      { pattern: ' * Copyright \\d{4} Adobe\\. All rights reserved\\.', template: ' * Copyright 2024 Adobe. All rights reserved.' },
+      ' * This file is licensed to you under the Apache License, Version 2.0 (the "License");',
+      ' * you may not use this file except in compliance with the License. You may obtain a copy',
+      ' * of the License at http://www.apache.org/licenses/LICENSE-2.0',
+      ' *',
+      ' * Unless required by applicable law or agreed to in writing, software distributed under',
+      ' * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS',
+      ' * OF ANY KIND, either express or implied. See the License for the specific language',
+      ' * governing permissions and limitations under the License.',
+      ' ',
+    ]],
+
+    'id-match': ['error', '^(?!.*?([wW][hH][iI][tT][eE]|[bB][lL][aA][cC][kK]).*[lL][iI][sS][tT]).*$', {
+      properties: true,
+    }],
+  },
+  files: ['*.js'],
+  linterOptions: {
+    reportUnusedDisableDirectives: 'off',
+  },
+};
+
+const source = {
+  ...common,
+  files: ['src/*.js', 'src/**/*.js', 'test/dev/*.mjs'],
+};
+
+const test = {
+  ...common,
+  languageOptions: {
+    globals: {
+      ...common.languageOptions.globals,
+      ...globals.mocha,
+      '__testdir': true,
+    },
+  },
+  files: ['test/*.js', 'test/**/*.js'],
+};
+
+export default [
+  {
+    ...source,
+  },
+  {
+    ...test,
+  }
+];

package/eslint/plugins/header/comment-parser.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+// This is a really simple and dumb parser, that looks just for a
+// single kind of comment. It won't detect multiple block comments.
+
+module.exports = function commentParser(text) {
+    text = text.trim();
+
+    if (text.substr(0, 2) === "//") {
+        return [
+            "line",
+            text.split(/\r?\n/).map(function(line) {
+                return line.substr(2);
+            })
+        ];
+    } else if (
+        text.substr(0, 2) === "/*" &&
+        text.substr(-2) === "*/"
+    ) {
+        return ["block", text.substring(2, text.length - 2)];
+    } else {
+        throw new Error("Could not parse comment file: the file must contain either just line comments (//) or a single block comment (/* ... */)");
+    }
+};

package/eslint/plugins/header/header.cjs

@@ -0,0 +1,272 @@
+"use strict";
+
+var fs = require("fs");
+var commentParser = require("./comment-parser.cjs");
+var os = require("os");
+
+function isPattern(object) {
+    return typeof object === "object" && Object.prototype.hasOwnProperty.call(object, "pattern");
+}
+
+function match(actual, expected) {
+    if (expected.test) {
+        return expected.test(actual);
+    } else {
+        return expected === actual;
+    }
+}
+
+function excludeShebangs(comments) {
+    return comments.filter(function(comment) {
+        return comment.type !== "Shebang";
+    });
+}
+
+// Returns either the first block comment or the first set of line comments that
+// are ONLY separated by a single newline. Note that this does not actually
+// check if they are at the start of the file since that is already checked by
+// hasHeader().
+function getLeadingComments(context, node) {
+    var all = excludeShebangs(context.getSourceCode().getAllComments(node.body.length ? node.body[0] : node));
+    if (all[0].type.toLowerCase() === "block") {
+        return [all[0]];
+    }
+    for (var i = 1; i < all.length; ++i) {
+        var txt = context.getSourceCode().getText().slice(all[i - 1].range[1], all[i].range[0]);
+        if (!txt.match(/^(\r\n|\r|\n)$/)) {
+            break;
+        }
+    }
+    return all.slice(0, i);
+}
+
+function genCommentBody(commentType, textArray, eol, numNewlines) {
+    var eols = eol.repeat(numNewlines);
+    if (commentType === "block") {
+        return "/*" + textArray.join(eol) + "*/" + eols;
+    } else {
+        return "//" + textArray.join(eol + "//") + eols;
+    }
+}
+
+function genCommentsRange(context, comments, eol) {
+    var start = comments[0].range[0];
+    var end = comments.slice(-1)[0].range[1];
+    if (context.getSourceCode().text[end] === eol) {
+        end += eol.length;
+    }
+    return [start, end];
+}
+
+function genPrependFixer(commentType, node, headerLines, eol, numNewlines) {
+    return function(fixer) {
+        return fixer.insertTextBefore(
+            node,
+            genCommentBody(commentType, headerLines, eol, numNewlines)
+        );
+    };
+}
+
+function genReplaceFixer(commentType, context, leadingComments, headerLines, eol, numNewlines) {
+    return function(fixer) {
+        return fixer.replaceTextRange(
+            genCommentsRange(context, leadingComments, eol),
+            genCommentBody(commentType, headerLines, eol, numNewlines)
+        );
+    };
+}
+
+function findSettings(options) {
+    var lastOption = options.length > 0 ? options[options.length - 1] : null;
+    if (typeof lastOption === "object" && !Array.isArray(lastOption) && lastOption !== null
+        && !Object.prototype.hasOwnProperty.call(lastOption, "pattern")) {
+        return lastOption;
+    }
+    return null;
+}
+
+function getEOL(options) {
+    var settings = findSettings(options);
+    if (settings && settings.lineEndings === "unix") {
+        return "\n";
+    }
+    if (settings && settings.lineEndings === "windows") {
+        return "\r\n";
+    }
+    return os.EOL;
+}
+
+function hasHeader(src) {
+    if (src.substr(0, 2) === "#!") {
+        var m = src.match(/(\r\n|\r|\n)/);
+        if (m) {
+            src = src.slice(m.index + m[0].length);
+        }
+    }
+    return src.substr(0, 2) === "/*" || src.substr(0, 2) === "//";
+}
+
+function matchesLineEndings(src, num) {
+    for (var j = 0; j < num; ++j) {
+        var m = src.match(/^(\r\n|\r|\n)/);
+        if (m) {
+            src = src.slice(m.index + m[0].length);
+        } else {
+            return false;
+        }
+    }
+    return true;
+}
+
+module.exports = {
+    meta: {
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                enum: ["block", "line"]
+            },
+            {
+                type: "array",
+            }
+        ]
+    },
+    create: function(context) {
+        var options = context.options;
+        var numNewlines = options.length > 2 ? options[2] : 1;
+        var eol = getEOL(options);
+
+        // If just one option then read comment from file
+        if (options.length === 1 || (options.length === 2 && findSettings(options))) {
+            var text = fs.readFileSync(context.options[0], "utf8");
+            options = commentParser(text);
+        }
+
+        var commentType = options[0].toLowerCase();
+        var headerLines, fixLines = [];
+        // If any of the lines are regular expressions, then we can't
+        // automatically fix them. We set this to true below once we
+        // ensure none of the lines are of type RegExp
+        var canFix = false;
+        if (Array.isArray(options[1])) {
+            canFix = true;
+            headerLines = options[1].map(function(line) {
+                var isRegex = isPattern(line);
+                // Can only fix regex option if a template is also provided
+                if (isRegex && !line.template) {
+                    canFix = false;
+                }
+                fixLines.push(line.template || line);
+                return isRegex ? new RegExp(line.pattern) : line;
+            });
+        } else if (isPattern(options[1])) {
+            var line = options[1];
+            headerLines = [new RegExp(line.pattern)];
+            fixLines.push(line.template || line);
+            // Same as above for regex and template
+            canFix = !!line.template;
+        } else {
+            canFix = true;
+            headerLines = options[1].split(/\r?\n/);
+            fixLines = headerLines;
+        }
+
+        return {
+            Program: function(node) {
+                if (!hasHeader(context.getSourceCode().getText())) {
+                    context.report({
+                        loc: node.loc,
+                        message: "missing header",
+                        fix: genPrependFixer(commentType, node, fixLines, eol, numNewlines)
+                    });
+                } else {
+                    var leadingComments = getLeadingComments(context, node);
+
+                    if (!leadingComments.length) {
+                        context.report({
+                            loc: node.loc,
+                            message: "missing header",
+                            fix: canFix ? genPrependFixer(commentType, node, fixLines, eol, numNewlines) : null
+                        });
+                    } else if (leadingComments[0].type.toLowerCase() !== commentType) {
+                        context.report({
+                            loc: node.loc,
+                            message: "header should be a {{commentType}} comment",
+                            data: {
+                                commentType: commentType
+                            },
+                            fix: canFix ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines) : null
+                        });
+                    } else {
+                        if (commentType === "line") {
+                            if (leadingComments.length < headerLines.length) {
+                                context.report({
+                                    loc: node.loc,
+                                    message: "incorrect header",
+                                    fix: canFix ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines) : null
+                                });
+                                return;
+                            }
+                            for (var i = 0; i < headerLines.length; i++) {
+                                if (!match(leadingComments[i].value, headerLines[i])) {
+                                    context.report({
+                                        loc: node.loc,
+                                        message: "incorrect header",
+                                        fix: canFix ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines) : null
+                                    });
+                                    return;
+                                }
+                            }
+
+                            var postLineHeader = context.getSourceCode().text.substr(leadingComments[headerLines.length - 1].range[1], numNewlines * 2);
+                            if (!matchesLineEndings(postLineHeader, numNewlines)) {
+                                context.report({
+                                    loc: node.loc,
+                                    message: "no newline after header",
+                                    fix: canFix ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines) : null
+                                });
+                            }
+
+                        } else {
+                            // if block comment pattern has more than 1 line, we also split the comment
+                            var leadingLines = [leadingComments[0].value];
+                            if (headerLines.length > 1) {
+                                leadingLines = leadingComments[0].value.split(/\r?\n/);
+                            }
+
+                            var hasError = false;
+                            if (leadingLines.length > headerLines.length) {
+                                hasError = true;
+                            }
+                            for (i = 0; !hasError && i < headerLines.length; i++) {
+                                if (!match(leadingLines[i], headerLines[i])) {
+                                    hasError = true;
+                                }
+                            }
+
+                            if (hasError) {
+                                if (canFix && headerLines.length > 1) {
+                                    fixLines = [fixLines.join(eol)];
+                                }
+                                context.report({
+                                    loc: node.loc,
+                                    message: "incorrect header",
+                                    fix: canFix ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines) : null
+                                });
+                            } else {
+                                var postBlockHeader = context.getSourceCode().text.substr(leadingComments[0].range[1], numNewlines * 2);
+                                if (!matchesLineEndings(postBlockHeader, numNewlines)) {
+                                    context.report({
+                                        loc: node.loc,
+                                        message: "no newline after header",
+                                        fix: canFix ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines) : null
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+};

package/eslint/plugins/header/index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = {
+    rules: {
+        "header": require("./header.cjs")
+    },
+    rulesConfig: {
+        "header": 0
+    }
+};