ai-deslop 0.2.0 → 0.2.2

package/dist/rules/no-runtime-typeof.js

@@ -0,0 +1,64 @@
+import { defineRule } from "@oxlint/plugins";
+function isRuntimeFunction(node) {
+    return (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression");
+}
+function isInsideTypeGuard(node) {
+    let current = node.parent;
+    while (current !== null && current.type !== "Program") {
+        if (isRuntimeFunction(current)) {
+            return current.returnType?.typeAnnotation.type === "TSTypePredicate";
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/** Return whether typeof safely probes for the existence of a possibly absent binding. */
+function isExistenceProbe(node) {
+    const parent = node.parent;
+    if (parent.type !== "BinaryExpression")
+        return false;
+    if (!["===", "!==", "==", "!="].includes(parent.operator))
+        return false;
+    const other = parent.left === node ? parent.right : parent.left;
+    return other.type === "Literal" && other.value === "undefined";
+}
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+export const noRuntimeTypeofRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary.",
+        },
+        messages: {
+            runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowInTypeGuards: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        defaultOptions: [{ allowInTypeGuards: false }],
+    },
+    createOnce(context) {
+        return {
+            UnaryExpression(node) {
+                const option = context.options?.[0];
+                const allowInTypeGuards = typeof option === "object" &&
+                    option !== null &&
+                    !Array.isArray(option) &&
+                    option.allowInTypeGuards === true;
+                if (node.operator === "typeof" &&
+                    !isExistenceProbe(node) &&
+                    (!allowInTypeGuards || !isInsideTypeGuard(node))) {
+                    context.report({ node, messageId: "runtimeTypeof" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-shape-in-symbol-names.d.ts

@@ -0,0 +1,2 @@
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+export declare const noForbiddenTermInSymbolNamesRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-shape-in-symbol-names.js

@@ -0,0 +1,40 @@
+import { defineRule } from "@oxlint/plugins";
+const FORBIDDEN_SYMBOL_NAME = "shape";
+function containsForbiddenSymbolName(name) {
+    return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
+}
+/** Return whether an identifier names a statically accessed member owned by another value. */
+function isBorrowedMemberName(node) {
+    const parent = node.parent;
+    if (parent === null || parent.type !== "MemberExpression")
+        return false;
+    return parent.property === node && parent.computed === false;
+}
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+export const noForbiddenTermInSymbolNamesRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: 'Disallow the case-insensitive substring "shape" in JavaScript, TypeScript, private, and JSX symbol names.',
+        },
+        messages: {
+            forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "shape" describes structure rather than ownership.',
+        },
+    },
+    createOnce(context) {
+        const reportForbiddenSymbolName = (node) => {
+            if (!containsForbiddenSymbolName(node.name) || isBorrowedMemberName(node))
+                return;
+            context.report({
+                node,
+                messageId: "forbiddenSymbolName",
+                data: { name: node.name },
+            });
+        };
+        return {
+            Identifier: reportForbiddenSymbolName,
+            PrivateIdentifier: reportForbiddenSymbolName,
+            JSXIdentifier: reportForbiddenSymbolName,
+        };
+    },
+});

package/dist/rules/no-unknown-parameters.d.ts

@@ -0,0 +1,2 @@
+/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+export declare const noUnknownParametersRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-unknown-parameters.js

@@ -0,0 +1,51 @@
+import { defineRule } from "@oxlint/plugins";
+import { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation, } from "../shared/function-parameters.js";
+function isTypePredicateSubject(owner, parameterName) {
+    const predicate = owner.returnType?.typeAnnotation;
+    return (predicate?.type === "TSTypePredicate" &&
+        predicate.parameterName.type === "Identifier" &&
+        predicate.parameterName.name === parameterName);
+}
+/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+export const noUnknownParametersRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow explicitly unknown function parameters except `cause` and type-predicate subjects; decode unknown input at its I/O boundary instead.",
+        },
+        messages: {
+            unknownParameter: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function.",
+        },
+    },
+    createOnce(context) {
+        const checkParameters = (node) => {
+            for (const parameter of node.params) {
+                const annotation = functionParameterTypeAnnotation(parameter);
+                if (annotation === null || annotation === undefined)
+                    continue;
+                if (!containsUnknownType(annotation.typeAnnotation))
+                    continue;
+                const name = functionParameterBindingName(parameter, context.sourceCode);
+                if (name === "cause" || isTypePredicateSubject(node, name))
+                    continue;
+                context.report({
+                    node: annotation.typeAnnotation,
+                    messageId: "unknownParameter",
+                    data: { parameter: name },
+                });
+            }
+        };
+        return {
+            ArrowFunctionExpression: checkParameters,
+            FunctionDeclaration: checkParameters,
+            FunctionExpression: checkParameters,
+            TSCallSignatureDeclaration: checkParameters,
+            TSConstructSignatureDeclaration: checkParameters,
+            TSConstructorType: checkParameters,
+            TSDeclareFunction: checkParameters,
+            TSEmptyBodyFunctionExpression: checkParameters,
+            TSFunctionType: checkParameters,
+            TSMethodSignature: checkParameters,
+        };
+    },
+});

package/dist/rules/no-unknown-returns.d.ts

@@ -0,0 +1,2 @@
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+export declare const noUnknownReturnsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-unknown-returns.js

@@ -0,0 +1,58 @@
+import { defineRule } from "@oxlint/plugins";
+import { createTypeAliasEnvironment, resolvedTypeMatches, } from "../shared/type-alias-resolution.js";
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+export const noUnknownReturnsRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>.",
+        },
+        messages: {
+            unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const resolvesToUnknown = (type) => environment !== null &&
+            resolvedTypeMatches(type, environment, (resolved, matches) => {
+                if (resolved.type === "TSUnknownKeyword")
+                    return true;
+                if (resolved.type === "TSParenthesizedType") {
+                    return matches(resolved.typeAnnotation);
+                }
+                if (resolved.type === "TSUnionType")
+                    return resolved.types.some(matches);
+                if (resolved.type !== "TSTypeReference" ||
+                    resolved.typeName.type !== "Identifier" ||
+                    (resolved.typeName.name !== "Promise" &&
+                        resolved.typeName.name !== "PromiseLike")) {
+                    return false;
+                }
+                const value = resolved.typeArguments?.params[0];
+                return value !== undefined && matches(value);
+            });
+        const checkReturnType = (node) => {
+            const annotation = node.returnType;
+            if (annotation === null || annotation === undefined)
+                return;
+            if (!resolvesToUnknown(annotation.typeAnnotation))
+                return;
+            context.report({ node: annotation.typeAnnotation, messageId: "unknownReturn" });
+        };
+        return {
+            Program(node) {
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            ArrowFunctionExpression: checkReturnType,
+            FunctionDeclaration: checkReturnType,
+            FunctionExpression: checkReturnType,
+            TSCallSignatureDeclaration: checkReturnType,
+            TSConstructSignatureDeclaration: checkReturnType,
+            TSConstructorType: checkReturnType,
+            TSDeclareFunction: checkReturnType,
+            TSEmptyBodyFunctionExpression: checkReturnType,
+            TSFunctionType: checkReturnType,
+            TSMethodSignature: checkReturnType,
+        };
+    },
+});

package/dist/rules/no-unknown-type-aliases.d.ts

@@ -0,0 +1,2 @@
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+export declare const noUnknownTypeAliasesRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-unknown-type-aliases.js

@@ -0,0 +1,40 @@
+import { defineRule } from "@oxlint/plugins";
+import { createTypeAliasEnvironment, resolvedTypeMatches, } from "../shared/type-alias-resolution.js";
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+export const noUnknownTypeAliasesRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow type aliases whose resolved type is unknown; unknown must remain visible at an allowed boundary.",
+        },
+        messages: {
+            unknownAlias: "Type alias `{{alias}}` hides `unknown`. Keep `unknown` explicit at the parsing boundary or on an allowed `cause` field; otherwise use the parsed owner type.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const resolvesToUnknown = (type) => environment !== null &&
+            resolvedTypeMatches(type, environment, (resolved, matches) => {
+                if (resolved.type === "TSUnknownKeyword")
+                    return true;
+                if (resolved.type === "TSParenthesizedType") {
+                    return matches(resolved.typeAnnotation);
+                }
+                return resolved.type === "TSUnionType" && resolved.types.some(matches);
+            });
+        return {
+            Program(node) {
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            TSTypeAliasDeclaration(node) {
+                if (!resolvesToUnknown(node.typeAnnotation))
+                    return;
+                context.report({
+                    node: node.id,
+                    messageId: "unknownAlias",
+                    data: { alias: node.id.name },
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-unsafe-dictionary-type.d.ts

@@ -0,0 +1,2 @@
+/** Disallow object-dictionary contracts whose direct value type is an unsafe escape hatch. */
+export declare const noUnsafeDictionaryTypeRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-unsafe-dictionary-type.js

@@ -0,0 +1,134 @@
+import { defineRule } from "@oxlint/plugins";
+import { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, createTypeEnvironment, } from "../shared/dictionary-types.js";
+import { visibleTypeAlias } from "../shared/type-alias-resolution.js";
+const typeNodeKinds = new Set([
+    "JSDocNonNullableType",
+    "JSDocNullableType",
+    "JSDocUnknownType",
+    "TSAnyKeyword",
+    "TSArrayType",
+    "TSBigIntKeyword",
+    "TSBooleanKeyword",
+    "TSConditionalType",
+    "TSConstructorType",
+    "TSFunctionType",
+    "TSImportType",
+    "TSIndexedAccessType",
+    "TSInferType",
+    "TSIntersectionType",
+    "TSIntrinsicKeyword",
+    "TSLiteralType",
+    "TSMappedType",
+    "TSNamedTupleMember",
+    "TSNeverKeyword",
+    "TSNullKeyword",
+    "TSNumberKeyword",
+    "TSObjectKeyword",
+    "TSParenthesizedType",
+    "TSStringKeyword",
+    "TSSymbolKeyword",
+    "TSTemplateLiteralType",
+    "TSThisType",
+    "TSTupleType",
+    "TSTypeLiteral",
+    "TSTypeOperator",
+    "TSTypePredicate",
+    "TSTypeQuery",
+    "TSTypeReference",
+    "TSUndefinedKeyword",
+    "TSUnionType",
+    "TSUnknownKeyword",
+    "TSVoidKeyword",
+]);
+function isTypeNode(node) {
+    return typeNodeKinds.has(node.type);
+}
+function typeReferenceName(type) {
+    return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isInsideTypeAliasDeclaration(node) {
+    let current = node.parent;
+    while (current !== null && current.type !== "Program") {
+        if (current.type === "TSTypeAliasDeclaration")
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+function isPlainAliasConsumerUse(node, environment) {
+    if (node.type !== "TSTypeReference" || node.typeArguments?.params.length)
+        return false;
+    const name = typeReferenceName(node);
+    return (name !== null &&
+        visibleTypeAlias(name, node, environment.typeAliases) !== null &&
+        !isInsideTypeAliasDeclaration(node));
+}
+function isInsideTypeParameterConstraint(node) {
+    let child = node;
+    let parent = child.parent;
+    while (parent !== null && parent.type !== "Program") {
+        if (parent.type === "TSTypeParameter" && parent.constraint === child)
+            return true;
+        child = parent;
+        parent = child.parent;
+    }
+    return false;
+}
+function shouldReportType(node, environment) {
+    if (isInsideTypeParameterConstraint(node))
+        return false;
+    if (isPlainAliasConsumerUse(node, environment))
+        return false;
+    if (classifyUnsafeDictionary(node, environment) === null)
+        return false;
+    let current = node.parent;
+    while (current !== null && current.type !== "Program") {
+        if (isTypeNode(current) && classifyUnsafeDictionary(current, environment) !== null)
+            return false;
+        current = current.parent;
+    }
+    return true;
+}
+/** Disallow object-dictionary contracts whose direct value type is an unsafe escape hatch. */
+export const noUnsafeDictionaryTypeRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow object-dictionary contracts whose direct value type is unknown, any, object, {}, or a union/alias containing one of those escape hatches.",
+        },
+        messages: {
+            unsafeDictionary: "This dictionary's {{value}} value type gives callers no concrete value contract. Use an owner/schema-derived value type; parse external payloads before insertion.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const report = (node, value) => {
+            context.report({ node, messageId: "unsafeDictionary", data: { value } });
+        };
+        const reportIfUnsafe = (node) => {
+            if (environment === null || !shouldReportType(node, environment))
+                return;
+            const unsafe = classifyUnsafeDictionary(node, environment);
+            if (unsafe === null)
+                return;
+            report(node, unsafe.unsafeValue);
+        };
+        return {
+            Program(node) {
+                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            TSTypeReference: reportIfUnsafe,
+            TSTypeLiteral: reportIfUnsafe,
+            TSMappedType: reportIfUnsafe,
+            TSIndexSignature(node) {
+                if (environment === null ||
+                    node.typeAnnotation === null ||
+                    node.parent.type === "TSTypeLiteral")
+                    return;
+                const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment);
+                if (unsafe !== null)
+                    report(node, unsafe.unsafeValue);
+            },
+        };
+    },
+});

package/dist/rules/no-widen-then-assert.d.ts

@@ -0,0 +1,2 @@
+/** Detect immutable local bindings that erase a known type and are later asserted back to a narrower type. */
+export declare const noWidenThenAssertRule: import("@oxlint/plugins").Rule;