@atlaskit/eslint-plugin-platform 2.6.0 → 2.7.1

package/src/rules/no-invalid-feature-flag-usage/__tests__/unit/rule.test.tsx

@@ -1,69 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-
-describe('enforce-feature-flag-usage-structure tests', () => {
-	tester.run('ensure-feature-flag-registration', rule, {
-		valid: [
-			{
-				// IfStatement
-				code: `if(getBooleanFF('test-flag')) { }`,
-			},
-			{
-				// negated IfStatement
-				code: `if(!getBooleanFF('test-flag')) { }`,
-			},
-			{
-				// ConditionalExpression
-				code: `const val = getBooleanFF('test-flag') ? 'yay' : 'no';`,
-			},
-			{
-				// LogicalExpression
-				code: `const val = 100 + (getBooleanFF('test-flag') && 50 || 10);`,
-			},
-		],
-		invalid: [
-			{
-				code: `getBooleanFF('test-flag')`,
-				errors: [{ messageId: 'onlyInlineIf' }],
-			},
-			{
-				code: `const val = getBooleanFF('test-flag')`,
-				errors: [{ messageId: 'onlyInlineIf' }],
-			},
-			{
-				code: `const ff = "test-flag"; if(getBooleanFF(ff)) { }`,
-				errors: [{ messageId: 'onlyStringLiteral' }],
-			},
-			{
-				code: `if(getBooleanFF('test-flag') && getBooleanFF('test-flag')) { }`,
-				errors: [
-					{ messageId: 'multipleFlagCheckInExpression' },
-					{ messageId: 'multipleFlagCheckInExpression' },
-				],
-			},
-			{
-				code: `if(!getBooleanFF('test-flag') && !getBooleanFF('test-flag')) { }`,
-				errors: [
-					{ messageId: 'multipleFlagCheckInExpression' },
-					{ messageId: 'multipleFlagCheckInExpression' },
-				],
-			},
-			{
-				code: `if((!getBooleanFF('test-flag') || 1 == true) && getBooleanFF('test-flag')) { }`,
-				errors: [
-					{ messageId: 'multipleFlagCheckInExpression' },
-					{ messageId: 'multipleFlagCheckInExpression' },
-				],
-			},
-			{
-				code: `export default getBooleanFF('test-flag') ? "this is" : "not good";`,
-				errors: [{ messageId: 'noModuleScope' }],
-			},
-			{
-				only: true,
-				code: `export const foo = getBooleanFF('test-flag') ? "this is" : "not good";`,
-				errors: [{ messageId: 'noModuleScope' }],
-			},
-		],
-	});
-});

package/src/rules/no-invalid-feature-flag-usage/index.tsx

@@ -1,128 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { Rule } from 'eslint';
-import type { Node, Expression } from 'estree';
-
-const FF_GETTER_BOOLEAN_IDENTIFIER = 'getBooleanFF' as const;
-
-const __isOnlyOneFlagCheckInExpression = (root: Node | Expression, ignoredNode: Node): boolean => {
-	switch (root.type) {
-		case 'IfStatement':
-			return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
-		case 'UnaryExpression':
-			return __isOnlyOneFlagCheckInExpression(root.argument, ignoredNode);
-
-		case 'CallExpression':
-			if (root === ignoredNode) {
-				return true;
-			}
-			return !(
-				root.callee.type === 'Identifier' && root.callee.name === FF_GETTER_BOOLEAN_IDENTIFIER
-			);
-
-		// shouldn't ever get here but just in case
-		case 'Identifier':
-			return root.name !== FF_GETTER_BOOLEAN_IDENTIFIER;
-
-		case 'BinaryExpression':
-		case 'LogicalExpression':
-			return (
-				__isOnlyOneFlagCheckInExpression(root.left, ignoredNode) &&
-				__isOnlyOneFlagCheckInExpression(root.right, ignoredNode)
-			);
-
-		default:
-			return true;
-	}
-};
-
-const isOnlyOneFlagCheckInExpression = (node: Rule.Node): boolean => {
-	let root = node.parent;
-	// find the root node of the expression
-	// NOTE: This is not an exhaustive check for all ESTree.Expression types but is good enough
-	while (root.type.endsWith('Expression')) {
-		root = root.parent;
-	}
-
-	return __isOnlyOneFlagCheckInExpression(root, node);
-};
-
-const rule: Rule.RuleModule = {
-	meta: {
-		hasSuggestions: false,
-		docs: {
-			recommended: false,
-		},
-		type: 'problem',
-		messages: {
-			onlyInlineIf:
-				"Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
-			onlyStringLiteral:
-				"Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
-			multipleFlagCheckInExpression: `Only check one flag per expression! See http://go/pff-eslint for more details`,
-			noModuleScope: `Don't use platform feature flags in module scope! See http://go/pff-eslint for more details`,
-		},
-	},
-	create(context) {
-		return {
-			[`CallExpression[callee.name=/${FF_GETTER_BOOLEAN_IDENTIFIER}/]`]: (node: Rule.Node) => {
-				// to make typescript happy
-				if (node.type === 'CallExpression') {
-					const args = node.arguments;
-
-					if (args.length === 1 && args[0].type !== 'Literal') {
-						return context.report({
-							node,
-							messageId: 'onlyStringLiteral',
-						});
-					}
-
-					switch (node.parent?.type) {
-						case 'IfStatement':
-							break;
-						case 'ConditionalExpression':
-							switch (node.parent?.parent.type) {
-								case 'ExportDefaultDeclaration':
-									// handles "export default getBooleanFF('test-flag') ? "this is" : "not good";"
-									context.report({
-										node,
-										messageId: 'noModuleScope',
-									});
-									break;
-								case 'VariableDeclarator':
-									// handles "export const foo = getBooleanFF('test-flag') ? 'this is' : 'not good';"
-									if (
-										node.parent.parent.parent.type === 'VariableDeclaration' &&
-										node.parent.parent.parent.parent.type === 'ExportNamedDeclaration'
-									) {
-										context.report({
-											node,
-											messageId: 'noModuleScope',
-										});
-									}
-									break;
-							}
-							break;
-						case 'UnaryExpression':
-						case 'LogicalExpression':
-							if (!isOnlyOneFlagCheckInExpression(node)) {
-								context.report({
-									node,
-									messageId: 'multipleFlagCheckInExpression',
-								});
-							}
-							break;
-						default:
-							return context.report({
-								node,
-								messageId: 'onlyInlineIf',
-							});
-					}
-				}
-
-				return {};
-			},
-		};
-	},
-};
-
-export default rule;

package/src/rules/no-invalid-storybook-decorator-usage/__tests__/unit/rule.test.tsx

@@ -1,18 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-
-describe('no-invalid-storybook-decorator-usage tests', () => {
-	tester.run('no-invalid-storybook-decorator-usage', rule, {
-		valid: [
-			{
-				code: `withPlatformFeatureFlags({})(<SampleComponent/>)`,
-			},
-		],
-		invalid: [
-			{
-				code: `const flags = {'uip.sample.color': true}; withPlatformFeatureFlags(flags)(<SampleComponent/>)`,
-				errors: [{ messageId: 'onlyObjectExpression' }],
-			},
-		],
-	});
-});

package/src/rules/no-invalid-storybook-decorator-usage/index.tsx

@@ -1,39 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { Rule } from 'eslint';
-
-const STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureFlags' as const;
-
-const rule: Rule.RuleModule = {
-	meta: {
-		hasSuggestions: false,
-		docs: {
-			recommended: false,
-		},
-		type: 'problem',
-		messages: {
-			onlyObjectExpression:
-				'Only object literals allowed in the storybook decorator! See http://go/pff-eslint for more details',
-		},
-	},
-	create(context) {
-		return {
-			[`CallExpression[callee.name=/${STORYBOOK_DECORATOR_IDENTIFIER}/]`]: (node: Rule.Node) => {
-				// to make typescript happy
-				if (node.type === 'CallExpression') {
-					const args = node.arguments;
-
-					if (args.length === 1 && args[0].type !== 'ObjectExpression') {
-						return context.report({
-							node,
-							messageId: 'onlyObjectExpression',
-						});
-					}
-				}
-
-				return {};
-			},
-		};
-	},
-};
-
-export default rule;

package/src/rules/no-pre-post-installs/__tests__/unit/rule.test.ts

@@ -1,41 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-
-describe('test no-pre-post-installs rule', () => {
-	tester.run('no-pre-post-installs', rule, {
-		valid: [
-			{
-				code: `const foo = { "scripts": { "preinstall": 1, "postinstall": 2 }}`,
-				filename: 'hello/foo.ts',
-			},
-			{
-				code: `const foo = { "scripts": { "preinstall": 1, "postinstall": 2 }}`,
-				filename: 'foo/dummy.json',
-			},
-			{
-				code: `const foo = { "scripts": { "bar": 1, "dummy": 'echo 1' }}`,
-				filename: 'foo/package.json',
-			},
-			{
-				code: `module.exports = { "scripts": { "fakePreinstall": 1 }};`,
-				filename: 'bar/package.json',
-			},
-			{
-				code: `module.exports = { "scripts": { "fakePostinstall": 1 }};`,
-				filename: 'bar/package.json',
-			},
-		],
-		invalid: [
-			{
-				code: `module.exports = { "scripts": { "preinstall": 1 }};`,
-				filename: 'bar/package.json',
-				errors: [{ messageId: 'prePostInstallScriptsNotAllowed' }],
-			},
-			{
-				code: `const foo = { "scripts": { "postinstall": 1 }}`,
-				filename: 'baz/package.json',
-				errors: [{ messageId: 'prePostInstallScriptsNotAllowed' }],
-			},
-		],
-	});
-});

package/src/rules/no-pre-post-installs/index.ts

@@ -1,35 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { Rule } from 'eslint';
-
-const rule: Rule.RuleModule = {
-	meta: {
-		type: 'problem',
-		docs: {
-			description:
-				'This rule disallows public packages to have pre/post install scripts as installations can happen on different environments',
-			recommended: false,
-		},
-		hasSuggestions: false,
-		messages: {
-			prePostInstallScriptsNotAllowed: 'pre/post install scripts not allowed in package.json',
-		},
-	},
-	create(context) {
-		return {
-			'ObjectExpression Property[key.value=scripts] Property[key.value=/^(pre|post)install$/]': (
-				node: Rule.Node,
-			) => {
-				if (!context.getFilename().endsWith('/package.json')) {
-					return;
-				}
-
-				return context.report({
-					node,
-					messageId: 'prePostInstallScriptsNotAllowed',
-				});
-			},
-		};
-	},
-};
-
-export default rule;

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

@@ -1,48 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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/use-entrypoints-in-examples/README.md

@@ -1,27 +0,0 @@
-Using public entrypoints in our examples ensures that they reflect public API.
-
-It also has benefits for:
-
-- readability
-- bundle and code analysis
-
-## Examples
-
-This rule marks imports as violations when they reach into the `src` folder through relative file
-paths.
-
-### Incorrect
-
-```js
-import Button from '../../../src';
-
-import { IconButton } from '../../../src/new';
-```
-
-### Correct
-
-```js
-import Button from '@atlaskit/button';
-
-import { ExampleHelper } from '../not-src';
-```

package/src/rules/use-entrypoints-in-examples/__tests__/rule.test.tsx

@@ -1,34 +0,0 @@
-import { tester } from '../../../__tests__/utils/_tester';
-import rule from '../index';
-
-const exampleFilename = 'packages/design-system/button/examples/0-basic.tsx';
-const nonExampleFilename = 'packages/design-system/button/scripts/my-script.tsx';
-
-tester.run('use-entrypoints-in-examples', rule, {
-	valid: [
-		{
-			code: `import Button from '@atlaskit/button';`,
-			filename: exampleFilename,
-		},
-		{
-			code: `import { ExampleHelper } from '../not-src';`,
-			filename: exampleFilename,
-		},
-		{
-			code: `import Button from '../src';`,
-			filename: nonExampleFilename,
-		},
-	],
-	invalid: [
-		{
-			code: `import Button from '../../../src';`,
-			filename: exampleFilename,
-			errors: [{ messageId: 'useEntrypointsInExamples' }],
-		},
-		{
-			code: `import { IconButton } from '../../../src/new';`,
-			filename: exampleFilename,
-			errors: [{ messageId: 'useEntrypointsInExamples' }],
-		},
-	],
-});

package/src/rules/use-entrypoints-in-examples/index.tsx

@@ -1,43 +0,0 @@
-import type { Rule } from 'eslint';
-
-const rule: Rule.RuleModule = {
-	meta: {
-		docs: {
-			url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/use-entrypoints-in-examples/README.md',
-			description: 'Encourage usage of package entrypoints in examples.',
-		},
-		messages: {
-			useEntrypointsInExamples:
-				'Use the package entrypoints instead of importing from src. This ensures examples reflect public API.\n\nFor example, use `@atlaskit/button/new` instead of `../../src/new`',
-		},
-		type: 'problem',
-	},
-	create(context) {
-		/**
-		 * Even if it's enabled on non-example files it will ignore them.
-		 *
-		 * This is a defensive check, the rule should be configured to only run on examples.
-		 */
-		if (!context.filename.includes('/examples/')) {
-			return {};
-		}
-
-		return {
-			ImportDeclaration(node) {
-				const moduleName = node.source.value;
-				if (typeof moduleName !== 'string') {
-					return;
-				}
-
-				if (/^(\.\.\/)+src(\/|$)/.test(moduleName)) {
-					context.report({
-						node: node.source,
-						messageId: 'useEntrypointsInExamples',
-					});
-				}
-			},
-		};
-	},
-};
-
-export default rule;

package/src/rules/util/__tests__/context-compat.test.ts

@@ -1,122 +0,0 @@
-import type { Rule, Scope, SourceCode } from 'eslint';
-import type { Node } from 'estree';
-
-import { getAncestors, getScope } from '../context-compat';
-
-describe('context-compat', () => {
-	describe('getAncestors', () => {
-		let context: Rule.RuleContext;
-		let node: Node;
-		let sourceCode: SourceCode;
-		let ancestors: Node[];
-
-		beforeEach(() => {
-			node = {} as Node;
-			ancestors = [];
-			sourceCode = {
-				getAncestors: jest.fn().mockReturnValue(ancestors),
-			} as unknown as SourceCode;
-		});
-
-		it('should return ancestor nodes from context.sourceCode.getAncestors if available', () => {
-			context = {
-				sourceCode,
-			} as unknown as Rule.RuleContext;
-
-			const result = getAncestors(context, node);
-			expect(result).toBe(ancestors);
-			expect(sourceCode.getAncestors).toHaveBeenCalledWith(node);
-		});
-
-		it('should return ancestors from context.getSourceCode().getAncestors if context.sourceCode is not available', () => {
-			context = {
-				getSourceCode: jest.fn().mockReturnValue(sourceCode),
-			} as unknown as Rule.RuleContext;
-
-			const result = getAncestors(context, node);
-			expect(result).toBe(ancestors);
-			expect(context.getSourceCode).toHaveBeenCalled();
-			expect(sourceCode.getAncestors).toHaveBeenCalledWith(node);
-		});
-
-		it('should return scope from context.getAncestors if neither context.sourceCode nor context.getSourceCode().getAncestors is available', () => {
-			context = {
-				getSourceCode: jest.fn().mockReturnValue({}),
-				getAncestors: jest.fn().mockReturnValue(ancestors),
-			} as unknown as Rule.RuleContext;
-
-			const result = getAncestors(context, node);
-			expect(result).toBe(ancestors);
-			expect(context.getAncestors).toHaveBeenCalled();
-		});
-
-		it('should return scope from context.getAncestors if context.sourceCode does not have getAncestors', () => {
-			context = {
-				sourceCode: {},
-				getAncestors: jest.fn().mockReturnValue(ancestors),
-			} as unknown as Rule.RuleContext;
-
-			const result = getAncestors(context, node);
-			expect(result).toBe(ancestors);
-			expect(context.getAncestors).toHaveBeenCalled();
-		});
-	});
-
-	describe('getScope', () => {
-		let context: Rule.RuleContext;
-		let node: Node;
-		let sourceCode: SourceCode;
-		let scope: Scope.Scope;
-
-		beforeEach(() => {
-			node = {} as Node;
-			scope = {} as Scope.Scope;
-			sourceCode = {
-				getScope: jest.fn().mockReturnValue(scope),
-			} as unknown as SourceCode;
-		});
-
-		it('should return scope from context.sourceCode.getScope if available', () => {
-			context = {
-				sourceCode,
-			} as unknown as Rule.RuleContext;
-
-			const result = getScope(context, node);
-			expect(result).toBe(scope);
-			expect(sourceCode.getScope).toHaveBeenCalledWith(node);
-		});
-
-		it('should return scope from context.getSourceCode().getScope if context.sourceCode is not available', () => {
-			context = {
-				getSourceCode: jest.fn().mockReturnValue(sourceCode),
-			} as unknown as Rule.RuleContext;
-
-			const result = getScope(context, node);
-			expect(result).toBe(scope);
-			expect(context.getSourceCode).toHaveBeenCalled();
-			expect(sourceCode.getScope).toHaveBeenCalledWith(node);
-		});
-
-		it('should return scope from context.getScope if neither context.sourceCode nor context.getSourceCode().getScope is available', () => {
-			context = {
-				getSourceCode: jest.fn().mockReturnValue({}),
-				getScope: jest.fn().mockReturnValue(scope),
-			} as unknown as Rule.RuleContext;
-
-			const result = getScope(context, node);
-			expect(result).toBe(scope);
-			expect(context.getScope).toHaveBeenCalled();
-		});
-
-		it('should return scope from context.getScope if context.sourceCode does not have getScope', () => {
-			context = {
-				sourceCode: {},
-				getScope: jest.fn().mockReturnValue(scope),
-			} as unknown as Rule.RuleContext;
-
-			const result = getScope(context, node);
-			expect(result).toBe(scope);
-			expect(context.getScope).toHaveBeenCalled();
-		});
-	});
-});

package/src/rules/util/compiled-utils.ts

@@ -1,27 +0,0 @@
-import type { Node } from 'estree';
-import { getAncestors, getScope } from './context-compat';
-import type { Rule } from 'eslint';
-import {
-	getImportSources,
-	isCompiled,
-	isAtlasKitCSS,
-} from '@atlaskit/eslint-utils/is-supported-import';
-
-// Checks if the function that holds the property is using a Compiled import package that this rule is targeting
-export const isCompiledAPI = (context: Rule.RuleContext, node: Node): boolean => {
-	const importSources = getImportSources(context);
-	const { references } = getScope(context, node);
-	const ancestors = getAncestors(context, node);
-	if (
-		ancestors.some(
-			(ancestor) =>
-				ancestor.type === 'CallExpression' &&
-				ancestor.callee &&
-				(isCompiled(ancestor.callee, references, importSources) ||
-					isAtlasKitCSS(ancestor.callee, references, importSources)),
-		)
-	) {
-		return true;
-	}
-	return false;
-};