@atlaskit/eslint-plugin-platform 2.7.0 → 2.7.2

package/src/rules/ensure-valid-platform-yarn-protocol-usage/__tests__/unit/rule.test.ts

@@ -1,147 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-
-const cwd = process.cwd();
-
-describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
-	tester.run('workspace protocol', rule, {
-		valid: [
-			// Workspace protocol 'workspace:*' is allowed in packages as dependencies
-			{
-				code: `const foo = {
-	        "dependencies": {
-	          "@atlaskit/button": "workspace:*",
-	          "@atlaskit/primitives": "workspace:*",
-	          "@atlaskit/tokens": "workspace:*"
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-			},
-			// Workspace protocol 'workspace:*' is allowed in packages as devDependencies
-			{
-				code: `const foo = {
-	        "devDependencies": {
-	          "@atlaskit/button": "workspace:*",
-	          "@atlaskit/primitives": "workspace:*"
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-			},
-			// Workspace protocol is allowed in packages dependencies and devDependencies
-			{
-				code: `const foo = {
-	        "dependencies": {
-	          "@atlaskit/button": "workspace:*",
-	          "@atlaskit/primitives": "workspace:*"
-	        },
-	        "devDependencies": {
-	          "@atlaskit/button": "workspace:*",
-	          "@atlaskit/primitives": "workspace:*"
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-			},
-		],
-		invalid: [],
-	});
-
-	tester.run('root: protocol', rule, {
-		// 'root:' protocol is not allowed in any platform package
-		valid: [],
-		invalid: [
-			// 'root:' protocol is not allowed in packages as dependencies
-			{
-				code: `const foo = {
-	        "dependencies": {
-	          "react": "root:*",
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidRootProtocolUsage',
-					},
-				],
-			},
-			// 'root:' protocol is not allowed in private packages as dependencies
-			{
-				code: `const foo = {
-	        "private": true,
-	        "dependencies": {
-	          "react": "root:*",
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidRootProtocolUsage',
-					},
-				],
-			},
-			// 'root:' protocol is not allowed in public packages as devDependencies
-			{
-				code: `const foo = {
-	        "devDependencies": {
-	          "react": "root:*",
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidRootProtocolUsage',
-					},
-				],
-			},
-			// 'root:' protocol is not allowed in private packages as devDependencies
-			{
-				code: `const foo = {
-	        "private": true,
-	        "devDependencies": {
-	          "react": "root:*",
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidRootProtocolUsage',
-					},
-				],
-			},
-			// 'root:' protocol is not allowed in public packages as dependencies and devDependencies
-			{
-				code: `const foo = {
-	        "dependencies": {
-	          "lodash": "root:*"
-	        },
-	        "devDependencies": {
-	          "react": "root:*"
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidRootProtocolUsage',
-					},
-				],
-			},
-			// 'root:' protocol is not allowed in private packages as dependencies and devDependencies
-			{
-				code: `const foo = {
-	        "private": true,
-	        "dependencies": {
-	          "lodash": "root:*"
-	        },
-	        "devDependencies": {
-	          "react": "root:*"
-	        }
-	    }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidRootProtocolUsage',
-					},
-				],
-			},
-		],
-	});
-});

package/src/rules/ensure-valid-platform-yarn-protocol-usage/index.ts

@@ -1,67 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { Rule } from 'eslint';
-import type { ObjectExpression } from 'estree';
-import { getObjectPropertyAsObject } from '../util/handle-ast-object';
-
-const rootProtocolRegex = /^root:[\^~\*]$/;
-
-/**
- * Checks if the 'workspace:' and 'root:' protocol are used as either dependencies or devDependencies
- */
-function getYarnProtocolsUsed(node: ObjectExpression) {
-	const protocolsUsed = { workspace: false, root: false };
-
-	const dependencies = getObjectPropertyAsObject(node, 'dependencies');
-	const devDependencies = getObjectPropertyAsObject(node, 'devDependencies');
-	const peerDependencies = getObjectPropertyAsObject(node, 'peerDependencies');
-
-	for (const obj of [dependencies, devDependencies, peerDependencies]) {
-		for (const p of obj?.properties || []) {
-			if (p.type === 'Property' && p.value.type === 'Literal') {
-				if (typeof p.value.value === 'string') {
-					if (rootProtocolRegex.test(p.value.value)) {
-						protocolsUsed.root = true;
-					}
-				}
-			}
-		}
-	}
-
-	return protocolsUsed;
-}
-
-const rule: Rule.RuleModule = {
-	meta: {
-		type: 'problem',
-		docs: {
-			description: `Ensures that yarn protocols 'workspace:' and 'root:' are used correctly.`,
-			recommended: true,
-		},
-		hasSuggestions: false,
-		messages: {
-			invalidWorkspaceProtocolUsage: `The 'workspace:^'protocol is Used. To resolve this error, please use the 'workspace:*' protocol instead.`,
-			invalidRootProtocolUsage: `The 'root:' protocol is not allowed in platform packages. To resolve this error, replace the 'root:' protocol with specific package versions (e.g. '^1.0.0').`,
-		},
-	},
-	create(context) {
-		return {
-			ObjectExpression: (node: Rule.Node) => {
-				if (!context.filename.endsWith('package.json') || node.type !== 'ObjectExpression') {
-					return;
-				}
-
-				const yarnProtocolsUsed = getYarnProtocolsUsed(node);
-
-				// The 'root:' protocol can not be used in any platform packages
-				if (yarnProtocolsUsed.root) {
-					context.report({
-						node,
-						messageId: 'invalidRootProtocolUsage',
-					});
-				}
-			},
-		};
-	},
-};
-
-export default rule;

package/src/rules/feature-gating/README.md

@@ -1,8 +0,0 @@
-### Notes
-
-- feature-gating/\* rules are copied from
-  [eslint-plugin-jira/rules/ff](https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/jira/dev-tooling/packages/eslint-plugin-jira/rules/ff)
-  with small variations as mentioned in this
-  [PR](https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/pull-requests/115546/overview)
-- these rules could be a WIP since they are still targeting JFE libraries- see
-  [discussion](https://atlassian.slack.com/archives/C026LTWFZ47/p1730776455371799?thread_ts=1730715221.742919&cid=C026LTWFZ47)

package/src/rules/feature-gating/inline-usage/README.md

@@ -1,53 +0,0 @@
-# Inline feature flags/gates and experiments usages (feature-flags/inline-usage)
-
-Ensure feature flags/gates and experiments are inlined so that they can be statically analyzable.
-
-## Examples
-
-👎 Examples of **incorrect** code for this rule: Feature flag call is assigned to a variable
-
-```tsx
-import { ff } from '@atlassian/jira-feature-flagging';
-
-const myFF = () => ff('my_flag');
-
-export const doSomething = () => {
-	if (myFF()) {
-		doSomethingNew();
-	} else {
-		doSomethingOld();
-	}
-};
-```
-
-👍 Examples of **correct** code for this rule: Usage is inlined
-
-```tsx
-import { ff } from '@atlassian/jira-feature-flagging';
-import { fg } from '@atlassian/jira-feature-gating';
-import { expValEquals } from '@atlassian/jira-feature-experiments';
-
-export const doSomething = () => {
-	if (ff('my_flag')) {
-		doSomethingNew();
-	} else {
-		doSomethingOld();
-	}
-};
-
-export const doSomething = () => {
-	if (fg('my_gate')) {
-		doSomethingNew();
-	} else {
-		doSomethingOld();
-	}
-};
-
-export const doSomething = () => {
-	if (expValEquals('my_exp', 'on', true)) {
-		doSomethingNew();
-	} else {
-		doSomethingOld();
-	}
-};
-```

package/src/rules/feature-gating/inline-usage/__tests__/rule.test.tsx

@@ -1,106 +0,0 @@
-import outdent from 'outdent';
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../index';
-
-const options = ['ssOnly'];
-
-tester.run('feature-flags/inline-usage', rule, {
-	valid: [
-		{
-			name: 'Valid API usage',
-			code: outdent`
-                import { ff } from '@atlassian/jira-feature-flagging';
-                import { fg } from '@atlassian/jira-feature-gating';
-                import { expVal, expValEquals } from '@atlassian/jira-feature-experiments';
-
-                export const FFComponent = () => ff('is.enabled') && <>Valid</>;
-                export const FGComponent = () => fg('is.enabled') && <>Valid</>;
-
-                export const ExpValComponent = function() {
-                    return expVal('is.enabled', 'on', false) && <>Valid</>;
-                };
-
-                export function ExpValEqualsComponent() {
-                    expValEquals('is.enabled', 'on', true) && <>Valid</>;
-                }
-
-                const valid1 = () => {
-                    console.log('valid');
-                };
-
-                const valid2 = () => 'valid';
-            `,
-		},
-		{
-			name: 'When using ssOnly option, ff() can avoid inline-usage',
-			options,
-			code: outdent`
-            import { ff } from '@atlassian/jira-feature-flagging';
-            import { fg } from '@atlassian/jira-feature-gating';
-
-            const invalidFF = () => ff('is.enabled');
-            export const FGComponent = () => fg('is.enabled') && <>Valid</>;
-        `,
-		},
-		{
-			name: 'Edge cases',
-			code: outdent`
-                import { ff } from '@atlassian/jira-feature-flagging';
-
-                function edgeCase1() {
-                    console.log('workAround');
-                    return ff('is.enabled');
-                }
-
-                const edgeCase2 = function() {
-                    console.log('workAround');
-                    return ff('is.enabled');
-                };
-
-                const edgeCase3 = () => {
-                    console.log('workAround');
-                    return ff('is.enabled');
-                };
-
-                const edgeCase4 = () => {
-                    ff('is.enabled');
-                };
-            `,
-		},
-	],
-	invalid: [
-		{
-			name: 'Invalid API usage',
-			code: outdent`
-                import { ff } from '@atlassian/jira-feature-flagging';
-                import { fg } from '@atlassian/jira-feature-gating';
-                import { expVal, expValEquals, UNSAFE_noExposureExp } from '@atlassian/jira-feature-experiments';
-
-                const invalidFF = () => ff('is.enabled');
-                const invalidFG = () => fg('is.enabled');
-                const invalidExpVal = () => expVal('is.enabled', 'on', false);
-                const invalidExpValBinary = () => expVal('is.enabled', 'cohort', null) === 'variation';
-                const invalidExpValBinary2 = () => expVal('is.enabled', 'count', 0) >= 0;
-
-                const invalidExpValEquals = function() {
-                    return expValEquals('is.enabled', 'on', true);
-                };
-
-                function invalidUnsafe() {
-                    return UNSAFE_noExposureExp('is.enabled');
-                }
-            `,
-			errors: Array.from(Array(7), () => ({ messageId: 'inlineUsage' })),
-		},
-		{
-			name: 'When using ssOnly option, Statsig functions should be inlined',
-			options,
-			code: outdent`
-                import { fg } from '@atlassian/jira-feature-gating';
-
-                const invalidFG = () => fg('is.enabled');
-            `,
-			errors: [{ messageId: 'inlineUsage' }],
-		},
-	],
-});

package/src/rules/feature-gating/inline-usage/index.tsx

@@ -1,135 +0,0 @@
-import type { Rule } from 'eslint';
-import { isAPIimport, type Node } from '../utils';
-
-const FUNCTION_NAMES = new Set(['ff', 'fg', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp']);
-const STATSIG_ONLY_FUNCTION_NAMES = new Set([
-	'fg',
-	'expVal',
-	'expValEquals',
-	'UNSAFE_noExposureExp',
-]);
-
-const findDefinitionDeclaration = (
-	node: Rule.Node,
-): (Node<'VariableDeclaration'> | Node<'FunctionDeclaration'>) & Rule.NodeParentExtension =>
-	node.type === 'VariableDeclaration' || node.type === 'FunctionDeclaration'
-		? node
-		: findDefinitionDeclaration(node.parent);
-
-const validateCallExpression = (
-	node: Node<'CallExpression'> & Rule.NodeParentExtension,
-	context: Rule.RuleContext,
-) => {
-	const targetedFunctionsSwitch =
-		context.options[0] === 'ssOnly' ? STATSIG_ONLY_FUNCTION_NAMES : FUNCTION_NAMES;
-
-	const { callee } = node;
-	const shouldWarn =
-		callee.type === 'Identifier' &&
-		targetedFunctionsSwitch.has(callee.name) &&
-		isAPIimport(callee.name, context, node);
-
-	if (shouldWarn) {
-		const defDeclaration = findDefinitionDeclaration(node.parent);
-
-		context.report({
-			messageId: 'inlineUsage',
-			node:
-				defDeclaration.parent.type === 'ExportNamedDeclaration'
-					? defDeclaration.parent
-					: defDeclaration,
-		});
-
-		return true;
-	}
-
-	return false;
-};
-
-const validateBinaryExpression = (
-	node: Node<'BinaryExpression'> & Rule.NodeParentExtension,
-	context: Rule.RuleContext,
-) => {
-	// Match all comparator operators i.e ===, >=, <
-	if (node.operator.match(/^[=|<|>]/)) {
-		if (
-			node.left.type === 'CallExpression' &&
-			validateCallExpression(node.left as Node<'CallExpression'>, context)
-		) {
-			return;
-		}
-
-		if (node.right.type === 'CallExpression') {
-			validateCallExpression(node.right as Node<'CallExpression'>, context);
-		}
-	}
-};
-
-const validateReturnExpression = ({ body }: Node<'BlockStatement'>, context: Rule.RuleContext) => {
-	if (body.length !== 1) {
-		return;
-	}
-
-	const [statement] = body;
-
-	if (statement.type === 'ReturnStatement') {
-		const { argument } = statement;
-
-		if (argument && argument.type === 'CallExpression') {
-			validateCallExpression(argument as Node<'CallExpression'>, context);
-		} else if (argument && argument.type === 'BinaryExpression') {
-			validateBinaryExpression(argument as Node<'BinaryExpression'>, context);
-		}
-	}
-};
-
-const validateFunctionBody = (
-	body: Node<'BinaryExpression'> | Node<'CallExpression'> | Node<'BlockStatement'>,
-	context: Rule.RuleContext,
-) => {
-	switch (body.type) {
-		case 'CallExpression':
-			validateCallExpression(body, context);
-			break;
-		case 'BinaryExpression':
-			validateBinaryExpression(body, context);
-			break;
-		case 'BlockStatement':
-			validateReturnExpression(body, context);
-			break;
-		default:
-	}
-};
-
-const rule: Rule.RuleModule = {
-	meta: {
-		type: 'problem',
-		docs: {
-			description:
-				'Ensure feature flags/gates and experiments are inlined so that they can be statically analyzable.',
-			url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/inline-usage/README.md',
-		},
-		schema: [
-			{
-				enum: ['ssOnly'],
-			},
-		],
-		messages: {
-			inlineUsage:
-				'Do not export or wrap feature flags/gates and experiments usages. Inline calls at the callsite to ensure it is statically analyzable.',
-		},
-	},
-	create(context) {
-		return {
-			'VariableDeclaration[declarations.length=1] > VariableDeclarator[id.type="Identifier"]:matches([init.type="ArrowFunctionExpression"], [init.type="FunctionExpression"]) > *.init':
-				({ body }: Node<'FunctionDeclaration'>) => {
-					validateFunctionBody(body as Node<'BlockStatement'> & Rule.NodeParentExtension, context);
-				},
-			FunctionDeclaration: ({ body }: Node<'FunctionDeclaration'>) => {
-				validateFunctionBody(body as Node<'BlockStatement'> & Rule.NodeParentExtension, context);
-			},
-		};
-	},
-};
-
-export default rule;

package/src/rules/feature-gating/no-alias/README.md

@@ -1,29 +0,0 @@
-# Avoid aliasing feature flag utils (feature-flags/no-alias)
-
-Ensure feature flag usage is statically analyzable. This applies to all methods, weather you are
-writing production code, unit testing or storybooks.
-
-## Examples
-
-👎 Examples of **incorrect** code for this rule:
-
-```tsx
-// Do not alias utils
-import { ff as getBoolean } from '@atlassian/jira-feature-flagging';
-
-// Do not reassign utils
-import { fg } from '@atlassian/jira-feature-gating';
-const aliasedFG = fg;
-```
-
-👍 Examples of **correct** code for this rule: Do not alias utils
-
-```tsx
-import { ff } from '@atlassian/jira-feature-flagging';
-
-export const doSomething = () => {
-	if (ff('my.flag')) {
-		console.log('hello');
-	}
-};
-```

package/src/rules/feature-gating/no-alias/__tests__/rule.test.tsx

@@ -1,76 +0,0 @@
-import outdent from 'outdent';
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../index';
-
-tester.run('feature-flags/no-alias', rule, {
-	valid: [
-		{
-			name: '`@atlassian/jira-feature-flagging` imports are not aliased',
-			code: outdent`
-                import { ff, ffVal } from '@atlassian/jira-feature-flagging';
-            `,
-		},
-		{
-			name: '`@atlassian/jira-feature-flagging-utils` imports are not aliased',
-			code: outdent`
-                import { componentWithFF } from '@atlassian/jira-feature-flagging-utils';
-            `,
-		},
-		{
-			name: '`@atlassian/jira-feature-gating` imports are not aliased',
-			code: outdent`
-                import { fg } from '@atlassian/jira-feature-gating';
-            `,
-		},
-		{
-			name: '`@atlassian/jira-feature-gates-test-mocks` imports are not aliased',
-			code: outdent`
-                import { passGate } from '@atlassian/jira-feature-gates-test-mocks';
-            `,
-		},
-		{
-			name: '`@atlassian/jira-feature-gates-storybook-mocks` imports are not aliased',
-			code: outdent`
-                import { withGate } from '@atlassian/jira-feature-gates-storybook-mocks';
-            `,
-		},
-		{
-			name: 'Aliases for non related imports are allowed',
-			code: outdent`
-                import { memo as m } from 'react';
-                import * as r from 'redux';
-            `,
-		},
-	],
-	invalid: [
-		{
-			name: 'Do not alias utils',
-			code: outdent`
-                import { ff as getBoolean } from '@atlassian/jira-feature-flagging';
-            `,
-			errors: [{ messageId: 'noSpecifierAlias' }],
-		},
-		{
-			name: 'Do not alias multiple utils',
-			code: outdent`
-                import { ff as getBoolean, ffVal as getFeatureFlagValue } from '@atlassian/jira-feature-flagging';
-            `,
-			errors: [{ messageId: 'noSpecifierAlias' }, { messageId: 'noSpecifierAlias' }],
-		},
-		{
-			name: 'Do not allow namespace imports',
-			code: outdent`
-                import * as ffUtils from '@atlassian/jira-feature-flagging';
-            `,
-			errors: [{ messageId: 'noNamespaceSpecifier' }],
-		},
-		{
-			name: 'Do not reassign utils',
-			code: outdent`
-                import { fg } from '@atlassian/jira-feature-gating';
-                const aliasedFG = fg;
-            `,
-			errors: [{ messageId: 'noReassignment' }],
-		},
-	],
-});