attention-manifest-protocol 0.4.2 → 0.4.3

package/tools/eslint-rules/rules/jsdoc-comment-format.ts

@@ -1,105 +0,0 @@
-import { ESLintUtils, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-const DEFAULT_ALLOW_PATTERNS: readonly string[] = ["^!", "^#", "^eslint-", "^prettier-", "^@ts-", "^@__", "^c8\\b", "^istanbul\\b", "^v8\\b"];
-
-type Options = [
-    {
-        allowPatterns?: string[];
-    },
-];
-
-type MessageId = "notJsdoc" | "notMultiline" | "empty";
-
-/**
- * Require every source comment to be a multiline JSDoc block.
- *
- * Tooling directives (`eslint-*`, `@ts-*`, `prettier-*`, `c8`, `istanbul`,
- * `v8`, source-map and shebang comments) are exempt because they are consumed
- * by tools rather than humans. Line comments and ordinary block comments are
- * rejected; JSDoc must open and close on separate lines with a non-empty
- * description.
- */
-export const jsdocCommentFormat = createRule<Options, MessageId>({
-    name: "jsdoc-comment-format",
-    meta: {
-        type: "suggestion",
-        docs: {
-            description: "Require multiline JSDoc comments and reject non-JSDoc comments",
-        },
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowPatterns: {
-                        type: "array",
-                        items: { type: "string" },
-                        uniqueItems: true,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            notJsdoc: "所有注释必须使用 JSDoc：请改为多行 /** ... */ 块，而不是 // 或 /* ... */。",
-            notMultiline: "JSDoc 注释必须跨多行：开头的 /**、描述行和结尾的 */ 要各占一行。",
-            empty: "JSDoc 注释必须包含非空的描述文本。",
-        },
-    },
-    defaultOptions: [{ allowPatterns: [...DEFAULT_ALLOW_PATTERNS] }],
-    create(context) {
-        const configured = context.options[0]?.allowPatterns;
-        const patterns: readonly string[] = configured ?? DEFAULT_ALLOW_PATTERNS;
-        const allowed: readonly RegExp[] = patterns.flatMap((pattern) => {
-            try {
-                return [new RegExp(pattern)];
-            } catch {
-                return [];
-            }
-        });
-
-        const isAllowed = (comment: TSESTree.Comment): boolean => {
-            const value = comment.value.trim();
-            return allowed.some((pattern) => pattern.test(value));
-        };
-
-        const isShebang = (comment: TSESTree.Comment): boolean =>
-            comment.loc.start.line === 1 && comment.loc.start.column === 0 && context.sourceCode.text.replace(/^\uFEFF/, "").startsWith("#!");
-
-        const isJsdoc = (comment: TSESTree.Comment): boolean => comment.type === "Block" && comment.value.startsWith("*");
-
-        return {
-            Program(): void {
-                for (const comment of context.sourceCode.getAllComments()) {
-                    if (isAllowed(comment) || isShebang(comment)) {
-                        continue;
-                    }
-
-                    if (!isJsdoc(comment)) {
-                        context.report({
-                            loc: comment.loc,
-                            messageId: "notJsdoc",
-                        });
-                        continue;
-                    }
-
-                    if (comment.loc.start.line === comment.loc.end.line) {
-                        context.report({
-                            loc: comment.loc,
-                            messageId: "notMultiline",
-                        });
-                        continue;
-                    }
-
-                    if (comment.value.replace(/^\*+/, "").trim().length === 0) {
-                        context.report({
-                            loc: comment.loc,
-                            messageId: "empty",
-                        });
-                    }
-                }
-            },
-        };
-    },
-});

package/tools/eslint-rules/rules/no-function-keyword.ts

@@ -1,60 +0,0 @@
-import { ESLintUtils, type TSESLint, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-const isKeywordFunctionExpression = (sourceCode: Readonly<TSESLint.SourceCode>, node: TSESTree.FunctionExpression): boolean => {
-    const firstToken = sourceCode.getFirstToken(node);
-
-    if (!firstToken) {
-        return false;
-    }
-
-    if (firstToken.value === "function") {
-        return true;
-    }
-
-    if (firstToken.value !== "async") {
-        return false;
-    }
-
-    const nextToken = sourceCode.getTokenAfter(firstToken);
-
-    return nextToken?.value === "function";
-};
-
-export const noFunctionKeyword = createRule({
-    name: "no-function-keyword",
-    meta: {
-        type: "problem",
-        docs: {
-            description: "Disallow the function keyword; use arrow functions instead",
-        },
-        schema: [],
-        messages: {
-            noFunction: "禁止使用 function 关键字；请改用箭头函数，例如：const add = (a: number, b: number): number => a + b;。",
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            FunctionDeclaration(node) {
-                context.report({ node, messageId: "noFunction" });
-            },
-            FunctionExpression(node) {
-                /*
-                 * In the ESTree AST a method body is also a FunctionExpression,
-                 * even though no `function` token exists. Only report the ones
-                 * that really use the keyword.
-                 */
-                if (isKeywordFunctionExpression(sourceCode, node)) {
-                    context.report({ node, messageId: "noFunction" });
-                }
-            },
-            TSDeclareFunction(node) {
-                context.report({ node, messageId: "noFunction" });
-            },
-        };
-    },
-});

package/tools/eslint-rules/rules/no-multiline-parameters.ts

@@ -1,71 +0,0 @@
-import { ESLintUtils, type TSESLint, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-const FUNCTION_LIKE_NODE_TYPES = [
-    "FunctionDeclaration",
-    "FunctionExpression",
-    "ArrowFunctionExpression",
-    "TSDeclareFunction",
-    "TSEmptyBodyFunctionExpression",
-    "TSDeclareMethod",
-    "TSFunctionType",
-    "TSConstructorType",
-    "TSMethodSignature",
-    "TSCallSignatureDeclaration",
-    "TSConstructSignatureDeclaration",
-] as const;
-
-type FunctionLikeNode = TSESTree.Node & {
-    params?: TSESTree.Node[];
-};
-
-export const noMultilineParameters = createRule({
-    name: "no-multiline-parameters",
-    meta: {
-        type: "suggestion",
-        docs: {
-            description: "Disallow line breaks between function parameters",
-        },
-        schema: [],
-        messages: {
-            lineBreak: "参数之间禁止换行；请让所有形参保持在同一行。",
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        const check = (node: FunctionLikeNode): void => {
-            const params = node.params;
-
-            if (!Array.isArray(params) || params.length < 2) {
-                return;
-            }
-
-            for (let index = 0; index < params.length - 1; index += 1) {
-                const left = params[index];
-                const right = params[index + 1];
-                const textBetween = sourceCode.getText().slice(left.range[1], right.range[0]);
-
-                if (textBetween.includes("\n") || textBetween.includes("\r")) {
-                    context.report({
-                        node: right,
-                        messageId: "lineBreak",
-                    });
-                    return;
-                }
-            }
-        };
-
-        const listeners: Record<string, (node: TSESTree.Node) => void> = {};
-
-        for (const type of FUNCTION_LIKE_NODE_TYPES) {
-            listeners[type] = (node) => {
-                check(node as FunctionLikeNode);
-            };
-        }
-
-        return listeners as TSESLint.RuleListener;
-    },
-});

package/tools/eslint-rules/rules/no-multiline-type-parameters.ts

@@ -1,57 +0,0 @@
-import { ESLintUtils, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-/*
- * Keep this heuristic in sync with the `amp-typescript` printer in
- * tools/prettier-plugin/index.mts. A type-parameter list that contains a
- * comment is printed by the stock Prettier printer, so the rule must not
- * report a line break that Prettier itself produces.
- */
-const HAS_COMMENT = /\/[/*]/u;
-
-export const noMultilineTypeParameters = createRule({
-    name: "no-multiline-type-parameters",
-    meta: {
-        type: "suggestion",
-        docs: {
-            description: "Disallow line breaks between type parameters",
-        },
-        schema: [],
-        messages: {
-            lineBreak: "类型参数之间禁止换行；请让所有类型参数保持在同一行。",
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            TSTypeParameterDeclaration(node): void {
-                const parameters: TSESTree.TSTypeParameter[] = node.params;
-
-                if (parameters.length < 2) {
-                    return;
-                }
-
-                if (HAS_COMMENT.test(sourceCode.getText(node))) {
-                    return;
-                }
-
-                for (let index = 0; index < parameters.length - 1; index += 1) {
-                    const left = parameters[index];
-                    const right = parameters[index + 1];
-                    const textBetween = sourceCode.getText().slice(left.range[1], right.range[0]);
-
-                    if (textBetween.includes("\n") || textBetween.includes("\r")) {
-                        context.report({
-                            node: right,
-                            messageId: "lineBreak",
-                        });
-                        return;
-                    }
-                }
-            },
-        };
-    },
-});

package/tools/eslint-rules/rules/no-undefined-comparison.ts

@@ -1,115 +0,0 @@
-import { ESLintUtils, type TSESLint, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-const EQUALITY_OPERATORS = new Set(["==", "===", "!=", "!=="]);
-
-const isUndefined = (node: TSESTree.Node | null | undefined): boolean => node?.type === "Identifier" && node.name === "undefined";
-
-const isZeroLiteral = (node: TSESTree.Node | null | undefined): boolean => {
-    if (node?.type !== "Literal") {
-        return false;
-    }
-
-    return (node as TSESTree.Literal).value === 0;
-};
-
-const isVoidZero = (node: TSESTree.Node | null | undefined): boolean => {
-    if (node?.type !== "UnaryExpression") {
-        return false;
-    }
-
-    return node.operator === "void" && isZeroLiteral(node.argument);
-};
-
-const isParenthesized = (sourceCode: Readonly<TSESLint.SourceCode>, node: TSESTree.Node): boolean => {
-    const tokenBefore = sourceCode.getTokenBefore(node);
-    const tokenAfter = sourceCode.getTokenAfter(node);
-
-    return tokenBefore?.value === "(" && tokenAfter?.value === ")";
-};
-
-const isLooseOperator = (operator: string): boolean => operator === "==" || operator === "!=";
-
-const needsParentheses = (sourceCode: Readonly<TSESLint.SourceCode>, node: TSESTree.Node): boolean => isVoidZero(node) && !isParenthesized(sourceCode, node);
-
-const fixUndefined = (sourceCode: Readonly<TSESLint.SourceCode>, fixer: TSESLint.RuleFixer, node: TSESTree.Node): TSESLint.RuleFix => {
-    if (isParenthesized(sourceCode, node)) {
-        return fixer.replaceText(node, "void 0");
-    }
-
-    return fixer.replaceText(node, "(void 0)");
-};
-
-export const noUndefinedComparison = createRule({
-    name: "no-undefined-comparison",
-    meta: {
-        type: "problem",
-        fixable: "code",
-        docs: {
-            description: "Require === (void 0) or !== (void 0) instead of comparing with undefined",
-        },
-        schema: [],
-        messages: {
-            useVoidZero: "禁止与 undefined 比较；请使用 === (void 0) 或 !== (void 0)，且 (void 0) 的括号不可省略。",
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            BinaryExpression(node) {
-                if (!EQUALITY_OPERATORS.has(node.operator)) {
-                    return;
-                }
-
-                const operands = [node.left, node.right];
-                const hasUndefined = operands.some(isUndefined);
-                const hasVoidZero = operands.some(isVoidZero);
-
-                if (!hasUndefined && !hasVoidZero) {
-                    return;
-                }
-
-                const hasLooseOperator = isLooseOperator(node.operator);
-                const hasUnparenthesizedVoidZero = operands.some((operand) => needsParentheses(sourceCode, operand));
-
-                if (!hasLooseOperator && !hasUndefined && !hasUnparenthesizedVoidZero) {
-                    return;
-                }
-
-                context.report({
-                    node,
-                    messageId: "useVoidZero",
-                    fix(fixer) {
-                        const fixes: TSESLint.RuleFix[] = [];
-
-                        if (hasLooseOperator) {
-                            const operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, {
-                                filter: (token) => token.value === node.operator,
-                            });
-
-                            if (operatorToken) {
-                                fixes.push(fixer.replaceText(operatorToken, node.operator === "==" ? "===" : "!=="));
-                            }
-                        }
-
-                        for (const operand of operands) {
-                            if (isUndefined(operand)) {
-                                fixes.push(fixUndefined(sourceCode, fixer, operand));
-                                continue;
-                            }
-
-                            if (needsParentheses(sourceCode, operand)) {
-                                fixes.push(fixer.insertTextBefore(operand, "("), fixer.insertTextAfter(operand, ")"));
-                            }
-                        }
-
-                        return fixes;
-                    },
-                });
-            },
-        };
-    },
-});

package/tools/eslint-rules/rules/prefer-template-for-string-conversion.ts

@@ -1,97 +0,0 @@
-import { ESLintUtils, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-const isStringConstructorCall = (callee: TSESTree.Node): boolean => callee.type === "Identifier" && callee.name === "String";
-
-const getToStringMember = (callee: TSESTree.Node): TSESTree.MemberExpression | null => {
-    if (callee.type !== "MemberExpression") {
-        return null;
-    }
-
-    if (callee.computed) {
-        if (callee.property.type === "Literal" && callee.property.value === "toString") {
-            return callee;
-        }
-
-        return null;
-    }
-
-    if (callee.property.type === "Identifier" && callee.property.name === "toString") {
-        return callee;
-    }
-
-    return null;
-};
-
-export const preferTemplateForStringConversion = createRule({
-    name: "prefer-template-for-string-conversion",
-    meta: {
-        type: "suggestion",
-        fixable: "code",
-        docs: {
-            description: "Prefer template literals for string conversion instead of String() or toString()",
-        },
-        schema: [],
-        messages: {
-            preferTemplate: "字符串转换请使用模板字符串，例如：`${value}`；不要使用 String(value) 或 value.toString()。",
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        const reportStringCall = (node: TSESTree.CallExpression): void => {
-            const argument = node.arguments[0];
-
-            if (!argument || argument.type === "SpreadElement") {
-                return;
-            }
-
-            context.report({
-                node,
-                messageId: "preferTemplate",
-                fix(fixer) {
-                    const argumentText = sourceCode.getText(argument);
-
-                    return fixer.replaceText(node, "`${" + argumentText + "}`");
-                },
-            });
-        };
-
-        const reportToStringCall = (node: TSESTree.CallExpression, member: TSESTree.MemberExpression): void => {
-            if (member.object.type === "Super") {
-                return;
-            }
-
-            context.report({
-                node,
-                messageId: "preferTemplate",
-                fix(fixer) {
-                    const objectText = sourceCode.getText(member.object);
-
-                    return fixer.replaceText(node, "`${(" + objectText + ")}`");
-                },
-            });
-        };
-
-        return {
-            CallExpression(node) {
-                if (node.optional) {
-                    return;
-                }
-
-                if (isStringConstructorCall(node.callee) && node.arguments.length === 1) {
-                    reportStringCall(node);
-                    return;
-                }
-
-                const member = getToStringMember(node.callee);
-
-                if (member && !member.optional && node.arguments.length === 0) {
-                    reportToStringCall(node, member);
-                }
-            },
-        };
-    },
-});

package/tools/eslint-rules/rules/require-typeof-parentheses.ts

@@ -1,49 +0,0 @@
-import { ESLintUtils, type TSESLint, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-const isParenthesized = (sourceCode: Readonly<TSESLint.SourceCode>, node: TSESTree.Node): boolean => {
-    const tokenBefore = sourceCode.getTokenBefore(node);
-    const tokenAfter = sourceCode.getTokenAfter(node);
-
-    return tokenBefore?.value === "(" && tokenAfter?.value === ")";
-};
-
-export const requireTypeofParentheses = createRule({
-    name: "require-typeof-parentheses",
-    meta: {
-        type: "suggestion",
-        fixable: "code",
-        docs: {
-            description: "Require parentheses around the operand of typeof",
-        },
-        schema: [],
-        messages: {
-            parenthesize: "typeof 的操作数必须加括号；请写成 typeof(variable)。",
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            UnaryExpression(node) {
-                if (node.operator !== "typeof") {
-                    return;
-                }
-
-                if (isParenthesized(sourceCode, node.argument)) {
-                    return;
-                }
-
-                context.report({
-                    node,
-                    messageId: "parenthesize",
-                    fix(fixer) {
-                        return [fixer.insertTextBefore(node.argument, "("), fixer.insertTextAfter(node.argument, ")")];
-                    },
-                });
-            },
-        };
-    },
-});

package/tools/eslint-rules/rules/require-variable-type.ts

@@ -1,36 +0,0 @@
-import { ESLintUtils, type TSESTree } from "@typescript-eslint/utils";
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/attention-manifest-protocol/blob/main/README.md#code-style`);
-
-type AnnotatablePattern = TSESTree.Node & {
-    typeAnnotation?: TSESTree.TSTypeAnnotation | null;
-};
-
-export const requireVariableType = createRule({
-    name: "require-variable-type",
-    meta: {
-        type: "suggestion",
-        docs: {
-            description: "Require an explicit type annotation on every variable declaration",
-        },
-        schema: [],
-        messages: {
-            missingType: "变量声明必须显式标注类型，例如：let studentAge: number = 6;。",
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        return {
-            VariableDeclarator(node) {
-                const pattern = node.id as AnnotatablePattern;
-
-                if (!pattern.typeAnnotation) {
-                    context.report({
-                        node: node.id,
-                        messageId: "missingType",
-                    });
-                }
-            },
-        };
-    },
-});