@atlaskit/eslint-plugin-platform 2.4.2 → 2.6.0

package/src/rules/no-direct-document-usage/index.tsx

@@ -0,0 +1,109 @@
+import type { Rule } from 'eslint';
+import { skipForExampleFiles, skipForTestFiles } from '../util/file-exclusions';
+
+const rule: Rule.RuleModule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Enforce using getDocument from @atlaskit/browser-apis instead of direct document usage',
+			recommended: true,
+		},
+		messages: {
+			useGetDocument:
+				'Use getDocument from @atlaskit/browser-apis instead of direct document usage',
+		},
+		schema: [],
+	},
+	create(context) {
+		let hasGetDocumentImport = false;
+		const filename = context.filename;
+
+		// Skip test files
+		const skipResult = skipForTestFiles(context);
+		if (skipResult) {
+			return skipResult;
+		}
+
+		// Skip example files
+		const skipResult2 = skipForExampleFiles(context);
+		if (skipResult2) {
+			return skipResult2;
+		}
+
+		// Skip the getDocument.ts file itself
+		if (filename.endsWith('getDocument.ts')) {
+			return {};
+		}
+
+		return {
+			ImportDeclaration(node) {
+				if (
+					node.source.value === '@atlaskit/browser-apis' &&
+					node.specifiers.some(
+						(specifier) =>
+							specifier.type === 'ImportSpecifier' && specifier.imported.name === 'getDocument',
+					)
+				) {
+					hasGetDocumentImport = true;
+				}
+			},
+			Identifier(node) {
+				if (node.name === 'document' && !hasGetDocumentImport) {
+					const parent = node.parent;
+
+					// Skip if 'document' is used as a property key in an object literal
+					if (parent?.type === 'Property' && parent.key === node) {
+						return;
+					}
+
+					// Skip if 'document' is used as a shorthand property value
+					if (parent?.type === 'Property' && parent.value === node && parent.shorthand) {
+						return;
+					}
+
+					// Skip if 'document' is used as a property being accessed in a member expression
+					if (parent?.type === 'MemberExpression' && parent.property === node && !parent.computed) {
+						return;
+					}
+
+					// Skip if 'document' is being declared as a variable
+					if (parent?.type === 'VariableDeclarator' && parent.id === node) {
+						return;
+					}
+
+					// Skip if 'document' is a function name
+					if (parent?.type === 'FunctionDeclaration' && 'id' in parent && parent.id === node) {
+						return;
+					}
+
+					if (parent?.type === 'FunctionExpression' && 'id' in parent && parent.id === node) {
+						return;
+					}
+
+					// Skip if 'document' is a method name in a class or object
+					if (parent?.type === 'MethodDefinition' && parent.key === node) {
+						return;
+					}
+
+					// Skip if 'document' is being assigned to (shadowing the global)
+					if (parent?.type === 'AssignmentExpression' && parent.left === node) {
+						return;
+					}
+
+					// Skip if 'document' is in a destructuring pattern (could be destructuring from an object)
+					if (parent?.type === 'ObjectPattern' || parent?.type === 'ArrayPattern') {
+						return;
+					}
+
+					context.report({
+						node,
+						messageId: 'useGetDocument',
+					});
+				}
+			},
+		};
+	},
+};
+
+export default rule;

package/src/rules/no-sparse-checkout/__tests__/unit/rule.test.tsx

@@ -0,0 +1,48 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+describe('test no-sparse-checkout rule', () => {
+	tester.run('no-sparse-checkout', rule, {
+		valid: [
+			{
+				code: `
+					const config = {
+						clone: alias.afmClone({ sparseCheckout: false })
+					};
+				`,
+				filename: 'hello/foo.ts',
+			},
+			{
+				code: `
+					const config = {
+						clone: alias.afmClone({ cloneDepth: 1})
+					};
+				`,
+				filename: 'hello/foo.ts',
+			},
+		],
+		invalid: [
+			{
+				code: `
+					const config = {
+						clone: alias.afmClone({ sparseCheckout: true })
+					};
+				`,
+				filename: 'hello/foo.ts',
+				errors: [{ messageId: 'noSparseCheckout' }],
+			},
+			{
+				code: `
+					const config = {
+						clone: alias.afmClone({ 
+							cloneDepth: 'full',
+							sparseCheckout: true 
+						})
+					};
+				`,
+				filename: 'hello/foo.ts',
+				errors: [{ messageId: 'noSparseCheckout' }],
+			},
+		],
+	});
+});

package/src/rules/no-sparse-checkout/index.tsx

@@ -0,0 +1,54 @@
+import type { Rule } from 'eslint';
+import type { Property } from 'estree';
+
+// We will be removing sparse checkout from pipelines in CI completely due to the load it causes on BBC.
+// We will be incrementally removing sparse-checkout from the files below as it is probably unnecessasry.
+// If you must add an exception below, please go through the chopper process before doing so
+const sparseCheckoutExceptions = [
+	'bitbucket-pipelines/pipelines/custom/run-issue-automat.ts',
+	'bitbucket-pipelines/pipelines/custom/marketplace/utils.ts',
+	'bitbucket-pipelines/pipelines/custom/confluence/utils/index.ts',
+	'bitbucket-pipelines/pipelines/custom/afm-tools/upload-afm-dependency-graph-cache.ts',
+	'bitbucket-pipelines/pipelines/custom/afm-tools/default-afm-tools.ts',
+	'bitbucket-pipelines/pipelines/custom/marketplace/utils.ts',
+	'bitbucket-pipelines/pipelines/custom/afm-git-hooks.ts',
+	'bitbucket-pipelines/pipelines/custom/update-codeowners-and-teams-gen.ts',
+	'bitbucket-pipelines/pipelines/custom/run-issue-automat.ts',
+];
+
+const rule: Rule.RuleModule = {
+	meta: {
+		docs: {
+			recommended: false,
+		},
+		type: 'problem',
+		messages: {
+			noSparseCheckout:
+				'Sparse checkout is not allowed in pipeline configurations. Use git-alternates instead by setting sparseCheckout to false or add this file to exceptions.',
+		},
+	},
+
+	create(context) {
+		const fileName = context.filename;
+		if (sparseCheckoutExceptions.some((exception) => fileName.endsWith(exception))) {
+			return {};
+		}
+
+		return {
+			// Look for calls to afmClone or objects that match AFMCloneConfig type
+			'CallExpression[callee.object.name=alias][callee.property.name=afmClone] ObjectExpression Property':
+				(node: Property) => {
+					if (node.key.type === 'Identifier' && node.key.name === 'sparseCheckout') {
+						if (node.value.type === 'Literal' && node.value.value === true) {
+							context.report({
+								node,
+								messageId: 'noSparseCheckout',
+							});
+						}
+					}
+				},
+		};
+	},
+};
+
+export default rule;

package/src/rules/util/file-exclusions.ts

@@ -0,0 +1,39 @@
+import type { Rule } from 'eslint';
+
+/**
+ * Common patterns for test files that should be excluded from rules
+ */
+const TEST_FILE_PATTERNS = ['__tests__', 'test', 'spec'] as const;
+
+/**
+ * Checks if a file should be excluded from rules based on test file patterns
+ * @param filename The filename to check
+ * @returns true if the file should be excluded, false otherwise
+ */
+const isTestFile = (filename: string): boolean => {
+	return TEST_FILE_PATTERNS.some((pattern) => filename.includes(pattern));
+};
+
+/**
+ * Helper function to skip rules for test files
+ * @param context The ESLint rule context
+ * @returns An empty RuleListener if the file is a test file, undefined otherwise
+ */
+export const skipForTestFiles = (context: Rule.RuleContext): Rule.RuleListener | undefined => {
+	if (isTestFile(context.filename)) {
+		return {};
+	}
+	return undefined;
+};
+
+/**
+ * Helper function to skip rules for example files
+ * @param context The ESLint rule context
+ * @returns An empty RuleListener if the file is an example file, undefined otherwise
+ */
+export const skipForExampleFiles = (context: Rule.RuleContext): Rule.RuleListener | undefined => {
+	if (context.filename.includes('example')) {
+		return {};
+	}
+	return undefined;
+};