@remotion/eslint-plugin 4.0.255 → 4.0.257

package/package.json

@@ -3,7 +3,7 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/eslint-plugin"
   },
   "name": "@remotion/eslint-plugin",
-  "version": "4.0.255",
+  "version": "4.0.257",
   "description": "Rules for writing Remotion code",
   "main": "dist/index.js",
   "bugs": {
@@ -11,9 +11,7 @@
   },
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "ISC",
-  "dependencies": {
-    "@typescript-eslint/utils": "5.19.0"
-  },
+  "dependencies": {},
   "keywords": [
     "eslint",
     "eslintplugin"
@@ -22,12 +20,22 @@
     "eslint": ">=7.0.0"
   },
   "devDependencies": {
+    "@typescript-eslint/utils": "5.19.0",
     "vitest": "0.31.1"
   },
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.mjs",
+      "module": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
   "private": false,
   "homepage": "https://www.remotion.dev/docs/brownfield#install-the-eslint-plugin",
   "scripts": {
     "test": "vitest --run",
-    "make": "tsc -d"
+    "make": "tsc -d && bun --env-file=../.env.bundle bundle.ts"
   }
 }

package/dist/rules/missing-import.d.ts

@@ -1,24 +0,0 @@
-declare const _default: {
-    meta: {
-        type: string;
-        fixable: boolean;
-        docs: {
-            description: string;
-            category: string;
-            recommended: boolean;
-            url: string;
-        };
-        schema: {
-            type: string;
-            properties: {
-                imports: {
-                    type: string;
-                    default: {};
-                };
-            };
-            additionalProperties: boolean;
-        }[];
-    };
-    create(context: any): any;
-};
-export = _default;

package/dist/rules/missing-import.js

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Rule to flag references to undeclared variables.
- * @author Mark Macdonald
- */
-'use strict';
-const jsx_1 = require("../util/jsx");
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-/**
- * Checks if the given node is the argument of a typeof operator.
- * @param {ASTNode} node The AST node being checked.
- * @returns {boolean} Whether or not the node is the argument of a typeof operator.
- */
-function hasTypeOfOperator(node) {
-    const { parent } = node;
-    return parent.type === 'UnaryExpression' && parent.operator === 'typeof';
-}
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-const allowGlobals = false;
-module.exports = {
-    meta: {
-        type: 'problem',
-        fixable: true,
-        docs: {
-            description: 'Automatically imports stuff that you specify',
-            category: 'Variables',
-            recommended: true,
-            url: 'https://eslint.org/docs/rules/no-undef',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    imports: {
-                        type: 'object',
-                        default: {},
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    create(context) {
-        const options = context.options[0] || {};
-        const considerTypeOf = (options && options.typeof === true) || false;
-        const map = options.imports || {};
-        function checkIdentifierInJSX(node) {
-            let scope = context.getScope();
-            const sourceCode = context.getSourceCode();
-            const { sourceType } = sourceCode.ast;
-            let { variables } = scope;
-            let scopeType = 'global';
-            let i;
-            let len;
-            // Ignore 'this' keyword (also maked as JSXIdentifier when used in JSX)
-            if (node.name === 'this') {
-                return;
-            }
-            if (!allowGlobals && sourceType === 'module') {
-                scopeType = 'module';
-            }
-            while (scope.type !== scopeType) {
-                scope = scope.upper;
-                variables = scope.variables.concat(variables);
-            }
-            if (scope.childScopes.length) {
-                variables = scope.childScopes[0].variables.concat(variables);
-                // Temporary fix for babel-eslint
-                if (scope.childScopes[0].childScopes.length) {
-                    variables =
-                        scope.childScopes[0].childScopes[0].variables.concat(variables);
-                }
-            }
-            for (i = 0, len = variables.length; i < len; i++) {
-                if (variables[i].name === node.name) {
-                    return;
-                }
-            }
-            const fixable = Boolean(map[node.name]);
-            if (fixable) {
-                context.report({
-                    node,
-                    message: [
-                        `'${node.name}' is not defined.`,
-                        `Run --fix to add \`${map[node.name]}\``,
-                    ]
-                        .filter(Boolean)
-                        .join(' '),
-                    ...(map[node.name]
-                        ? {
-                            fix: (fixer) => {
-                                return fixer.insertTextBefore(sourceCode.ast, map[node.name] + '\n');
-                            },
-                        }
-                        : {}),
-                });
-            }
-        }
-        return {
-            JSXOpeningElement(node) {
-                switch (node.name.type) {
-                    case 'JSXIdentifier':
-                        if ((0, jsx_1.isDOMComponent)(node)) {
-                            return;
-                        }
-                        node = node.name;
-                        break;
-                    case 'JSXMemberExpression':
-                        node = node.name;
-                        do {
-                            node = node.object;
-                        } while (node && node.type !== 'JSXIdentifier');
-                        break;
-                    case 'JSXNamespacedName':
-                        node = node.name.namespace;
-                        break;
-                    default:
-                        break;
-                }
-                checkIdentifierInJSX(node);
-            },
-            'Program:exit'( /* node */) {
-                const globalScope = context.getScope();
-                const sourceCode = context.getSourceCode();
-                if (Object.keys(map).length === 0) {
-                    context.report({
-                        node: sourceCode.ast,
-                        data: sourceCode.ast,
-                        message: 'Rule tenx/auto-import is enabled but there are no replacements specified. Get started by specifying an object as an option to the ESLint rule: ["error", {imports: {sortBy: `import sortBy from "lodash/sortBy"`}}]',
-                    });
-                    return;
-                }
-                globalScope.through.forEach((ref) => {
-                    const { identifier } = ref;
-                    if (!considerTypeOf && hasTypeOfOperator(identifier)) {
-                        return;
-                    }
-                    const fixable = Boolean(map[identifier.name]);
-                    if (fixable) {
-                        context.report({
-                            node: identifier,
-                            data: identifier,
-                            message: [
-                                `'${identifier.name}' is not defined.`,
-                                `Run --fix to add \`${map[identifier.name]}\``,
-                            ]
-                                .filter(Boolean)
-                                .join(' '),
-                            ...(fixable
-                                ? {
-                                    fix: (fixer) => {
-                                        return fixer.insertTextBefore(sourceCode.ast, map[identifier.name] + '\n');
-                                    },
-                                }
-                                : {}),
-                        });
-                    }
-                });
-            },
-        };
-    },
-};

package/dist/rules/no-mp4-import.d.ts

@@ -1,2 +0,0 @@
-declare const rule: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"NoMP4Import", [], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
-export default rule;

package/dist/rules/no-mp4-import.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@typescript-eslint/utils");
-const createRule = utils_1.ESLintUtils.RuleCreator(() => {
-    return `https://github.com/remotion-dev/remotion`;
-});
-const NoMP4Import = 'Importing MP4 will work while you are previewing the video, but will not work while rendering since Puppeteer does not include the codecs necessary for MP4 videos. Convert the video to WebM first.';
-const rule = createRule({
-    name: 'no-mp4-import',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: NoMP4Import,
-            recommended: 'warn',
-        },
-        fixable: undefined,
-        schema: [],
-        messages: {
-            NoMP4Import,
-        },
-    },
-    defaultOptions: [],
-    create: (context) => {
-        return {
-            ImportDeclaration: (node) => {
-                if (node.source.raw.includes('.mp4')) {
-                    context.report({
-                        messageId: 'NoMP4Import',
-                        node,
-                    });
-                }
-            },
-            CallExpression: (node) => {
-                var _a, _b, _c, _d;
-                // @ts-expect-error
-                if (node.callee.name !== 'require') {
-                    return;
-                }
-                // @ts-expect-error
-                const firstArgument = (_d = (_c = (_b = (_a = node.callee) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.arguments) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.raw;
-                if (!firstArgument) {
-                    const sourceCode = context.getSourceCode().getText(node);
-                    if (sourceCode.includes('.mp4')) {
-                        context.report({
-                            messageId: 'NoMP4Import',
-                            node,
-                        });
-                    }
-                    return;
-                }
-                if (firstArgument.includes('.mp4')) {
-                    context.report({
-                        messageId: 'NoMP4Import',
-                        node,
-                    });
-                }
-            },
-        };
-    },
-});
-exports.default = rule;