@zxyycom/vibe-check 0.0.1 → 0.0.3

package/dist/esm/package-checks/function-metrics/analyzer/readers/typescript.mjs

@@ -0,0 +1,612 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/typescript.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import { CodeReader, CodeStateMachine } from "../shared/code-reader.mjs";
+import { js_style_regex_expression } from "../shared/js-style-regex.mjs";
+const _TS_TYPE_KEYWORDS = new Set([
+    "string",
+    "number",
+    "boolean",
+    "void",
+    "any",
+    "object",
+    "unknown",
+    "never"
+]);
+export class TypeScriptReader extends CodeReader {
+    static ext = ["ts"];
+    static languageNames = ["typescript", "ts"];
+    static controlFlowKeywords = new Set(["if", "elseif", "for", "while", "catch"]);
+    static logicalOperators = new Set(["&&", "||"]);
+    static caseKeywords = new Set(["case"]);
+    static ternaryOperators = new Set(["?"]);
+    constructor(context) {
+        super(context);
+        this.parallelStates = [new TypeScriptStates(context)];
+    }
+    static generateTokens = js_style_regex_expression(function* (sourceCode, addition = "", tokenFactory) {
+        function* splitTemplateLiteral(token) {
+            let content = token.slice(1, -1);
+            yield "`";
+            if (!content.includes("${")) {
+                if (content)
+                    yield `\`${content}\``;
+                yield "`";
+                return;
+            }
+            let index = 0;
+            while (index < content.length) {
+                const expressionIndex = content.indexOf("${", index);
+                if (expressionIndex === -1) {
+                    if (index < content.length)
+                        yield `\`${content.slice(index)}\``;
+                    break;
+                }
+                if (expressionIndex > index)
+                    yield `\`${content.slice(index, expressionIndex)}\``;
+                yield "${";
+                index = expressionIndex + 2;
+                const expressionStart = index;
+                let braceCount = 1;
+                while (index < content.length && braceCount > 0) {
+                    if (content[index] === "{")
+                        braceCount += 1;
+                    else if (content[index] === "}")
+                        braceCount -= 1;
+                    index += 1;
+                }
+                if (braceCount > 0) {
+                    yield token;
+                    return;
+                }
+                yield content.slice(expressionStart, index - 1);
+                yield "}";
+                content = content.slice(index);
+                index = 0;
+            }
+            yield "`";
+        }
+        const typeScriptAddition = `${addition}|(?:#\\w+)|(?:\\$\\w+)|(?:\\w+\\?)|\`.*?\``;
+        for (const token of CodeReader.generateTokens(sourceCode, typeScriptAddition, tokenFactory)) {
+            if (token.startsWith("`") && token.endsWith("`") && token.length > 1) {
+                yield* splitTemplateLiteral(token);
+            }
+            else {
+                yield token;
+            }
+        }
+    });
+    get_comment_from_token(token) {
+        if (token.startsWith("//"))
+            return token.slice(2);
+        if (token.startsWith("/*") && token.endsWith("*/"))
+            return token.slice(2, -2);
+        return undefined;
+    }
+}
+/** Source-aligned tokenizer base shared with the TSX reader. */
+export class Tokenizer {
+    sub_tokenizer;
+    _ended;
+    constructor() {
+        this.sub_tokenizer = undefined;
+        this._ended = false;
+    }
+    *__call__(token) {
+        if (this.sub_tokenizer) {
+            yield* this.sub_tokenizer.__call__(token);
+            if (this.sub_tokenizer._ended)
+                this.sub_tokenizer = undefined;
+            return;
+        }
+        yield* this.process_token(token);
+    }
+    stop() {
+        this._ended = true;
+    }
+    *process_token(_token) { }
+}
+/** Source-aligned JavaScript brace tokenizer used by TSX embedded expressions. */
+export class JSTokenizer extends Tokenizer {
+    depth;
+    constructor() {
+        super();
+        this.depth = 1;
+    }
+    *process_token(token) {
+        if (token === "{")
+            this.depth += 1;
+        else if (token === "}") {
+            this.depth -= 1;
+            if (this.depth === 0) {
+                this.stop();
+                return;
+            }
+        }
+        yield token;
+    }
+}
+class TypeScriptStates extends CodeStateMachine {
+    last_tokens = "";
+    function_name = "";
+    started_function = false;
+    as_object = false;
+    _getter_setter_prefix;
+    _ts_declare = false;
+    _static_seen = false;
+    _async_seen = false;
+    _prev_token = "";
+    _in_prop_value = false;
+    _in_abstract_context = false;
+    _generic_depth_in_dec = 0;
+    constructor(context) {
+        super(context);
+    }
+    statemachine_before_return() {
+        this._pop_function_from_stack();
+    }
+    _state_global(token) {
+        if (token === "declare") {
+            this._ts_declare = true;
+            return;
+        }
+        if (token === "function" && this._ts_declare) {
+            this._ts_declare = false;
+            this.next(this.skipDeclaredFunction);
+            return;
+        }
+        this._ts_declare = false;
+        if (token === "type" && !this.as_object) {
+            let phase = 0;
+            let braceCount = 0;
+            let genericDepth = 0;
+            const handleTypeAlias = (nextToken) => {
+                if (phase === 0) {
+                    if (/\p{L}/u.test(nextToken[0] ?? ""))
+                        phase = 1;
+                    else {
+                        this.last_tokens = "type";
+                        this.next(this.globalState, nextToken);
+                        return true;
+                    }
+                }
+                else if (phase === 1) {
+                    if (nextToken === "<") {
+                        genericDepth = 1;
+                        phase = 3;
+                    }
+                    else if (nextToken === "=")
+                        phase = 2;
+                    else if (nextToken === ";") {
+                        this.next(this.globalState);
+                        return true;
+                    }
+                }
+                else if (phase === 2) {
+                    if (nextToken === "{") {
+                        braceCount = 1;
+                        phase = 4;
+                    }
+                    else if (nextToken === ";" || this.context.newline) {
+                        this.next(this.globalState);
+                        if (nextToken !== ";")
+                            this._state_global(nextToken);
+                        return true;
+                    }
+                }
+                else if (phase === 3) {
+                    if (nextToken === "<")
+                        genericDepth += 1;
+                    else if (nextToken === ">") {
+                        genericDepth -= 1;
+                        if (genericDepth === 0)
+                            phase = 1;
+                    }
+                }
+                else if (phase === 4) {
+                    if (nextToken === "{")
+                        braceCount += 1;
+                    else if (nextToken === "}") {
+                        braceCount -= 1;
+                        if (braceCount === 0) {
+                            this.next(this.globalState);
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            };
+            this.next(handleTypeAlias);
+            return;
+        }
+        if (token === "interface") {
+            let braceCount = 0;
+            let interfaceStarted = false;
+            const skipInterface = (nextToken) => {
+                if (nextToken === "{") {
+                    interfaceStarted = true;
+                    braceCount += 1;
+                }
+                else if (nextToken === "}" && interfaceStarted) {
+                    braceCount -= 1;
+                    if (braceCount === 0) {
+                        this.next(this.globalState);
+                        return true;
+                    }
+                }
+                return false;
+            };
+            this.next(skipInterface);
+            return;
+        }
+        if (token === "abstract" && this.as_object) {
+            this._in_abstract_context = true;
+            return;
+        }
+        if (token === "static") {
+            this._static_seen = true;
+            this._prev_token = token;
+            return;
+        }
+        if (token === "async") {
+            this._async_seen = true;
+            this._prev_token = token;
+            return;
+        }
+        if (token === "new") {
+            this._prev_token = token;
+            return;
+        }
+        if (this.as_object) {
+            if (token === "get" || token === "set") {
+                this._getter_setter_prefix = token;
+                return;
+            }
+            if (this._getter_setter_prefix) {
+                this.last_tokens = `${this._getter_setter_prefix} ${token}`;
+                this._getter_setter_prefix = undefined;
+                return;
+            }
+            if (token === "[") {
+                this._collect_computed_name();
+                return;
+            }
+            if (token === ":") {
+                if (isFunctionName(this.last_tokens))
+                    this.function_name = this.last_tokens;
+                this._in_prop_value = true;
+                return;
+            }
+            if (token === "<" || (token.startsWith("<") && token.endsWith(">") && token.length > 1)) {
+                if (token === "<")
+                    this._consume_generic_type_params();
+                return;
+            }
+            if (token === "(") {
+                if (this._prev_token === "." || this._prev_token === "new") {
+                    this.subState(this.cloneState());
+                    this._prev_token = token;
+                    return;
+                }
+                if (this._in_prop_value &&
+                    (!this.function_name || this.last_tokens !== this.function_name)) {
+                    this.subState(this.cloneState());
+                    this._prev_token = token;
+                    return;
+                }
+                if (!this.started_function) {
+                    if (this.last_tokens === "=" && this.function_name)
+                        this._function(this.function_name);
+                    else
+                        this._function(this.last_tokens);
+                }
+                this.next(this._function, token);
+                return;
+            }
+            if ((this._async_seen || this._static_seen) && !["*", "function", "=>"].includes(token)) {
+                if (token === "=") {
+                    this._static_seen = false;
+                    this._async_seen = false;
+                }
+                else {
+                    this.last_tokens = token;
+                    return;
+                }
+            }
+        }
+        if (token === ".") {
+            this.next(this._field);
+            this.last_tokens += token;
+            this._prev_token = token;
+            return;
+        }
+        if (token === "function") {
+            if (this.started_function && !this.as_object)
+                this._pop_function_from_stack();
+            this.next(this._function);
+        }
+        else if (["if", "switch", "for", "while", "catch"].includes(token)) {
+            this.next(this._expecting_condition_and_statement_block);
+        }
+        else if (["else", "do", "try", "final"].includes(token)) {
+            this.next(this._expecting_statement_or_block);
+        }
+        else if (token === "=>") {
+            this.next(this._arrow_function);
+        }
+        else if (token === "=") {
+            if (isFunctionName(this.last_tokens))
+                this.function_name = this.last_tokens;
+        }
+        else if (token === "(") {
+            if (this._prev_token === "." || this._prev_token === "new") {
+                this.subState(this.cloneState());
+            }
+            else if (this.function_name) {
+                if (this.last_tokens !== this.function_name &&
+                    !["=", "async", ">"].includes(this._prev_token)) {
+                    this.function_name = "";
+                    this.subState(this.cloneState());
+                }
+                else {
+                    if (!this.started_function)
+                        this._function(this.function_name);
+                    this.next(this._function, token);
+                }
+            }
+            else {
+                this.subState(this.cloneState());
+            }
+        }
+        else if (token === "{") {
+            if (this.started_function)
+                this.subState(this.cloneState(), this._pop_function_from_stack);
+            else
+                this.read_object();
+        }
+        else if (token === "}" || token === ")") {
+            this.returnFromState();
+        }
+        else if (this.context.newline || token === ";") {
+            this.function_name = "";
+            this._pop_function_from_stack();
+            this._static_seen = false;
+            this._async_seen = false;
+            this._in_abstract_context = false;
+            this._in_prop_value = false;
+            this._prev_token = "";
+        }
+        if (token === "`")
+            this.next(this._state_template_literal);
+        if (!this.as_object && token === ":") {
+            this._consume_type_annotation();
+            this._prev_token = token;
+            return;
+        }
+        if (this.as_object && token === ",")
+            this._in_prop_value = false;
+        this.last_tokens = token;
+        if (this._prev_token !== "new" && this._prev_token !== ".")
+            this._prev_token = token;
+    }
+    read_object() {
+        const objectReader = this.cloneState();
+        if (!(objectReader instanceof TypeScriptStates)) {
+            throw new TypeError("TypeScriptStates clone did not preserve the concrete state class.");
+        }
+        objectReader.as_object = true;
+        objectReader._static_seen = this._static_seen;
+        objectReader._async_seen = this._async_seen;
+        this.subState(objectReader, () => this.next(this.globalState));
+        this._static_seen = false;
+        this._async_seen = false;
+    }
+    _push_function_to_stack() {
+        if (this._in_abstract_context)
+            return;
+        this.started_function = true;
+        this.context.pushNewFunction(this.function_name || "(anonymous)");
+    }
+    _pop_function_from_stack = () => {
+        if (this.started_function)
+            this.context.endOfFunction();
+        this.started_function = false;
+        this._in_prop_value = false;
+    };
+    skipDeclaredFunction = (token) => {
+        if (token === ";" || this.context.newline) {
+            this.next(this.globalState);
+            return true;
+        }
+        return false;
+    };
+    _expecting_condition_and_statement_block = (token) => {
+        if (token === "await")
+            return;
+        if (token !== "(") {
+            this.next(this.globalState, token);
+            return;
+        }
+        this.subState(this.cloneState(), () => this.next(this._expecting_statement_or_block));
+    };
+    _expecting_statement_or_block = (token) => {
+        if (token === "{")
+            this.subState(this.cloneState(), () => this.next(this.globalState));
+        else
+            this.next(this.globalState, token);
+    };
+    _arrow_function = (token) => {
+        if (!this.started_function)
+            this._push_function_to_stack();
+        this.function_name = "";
+        this._async_seen = false;
+        this._static_seen = false;
+        this.next(this.globalState, token);
+    };
+    _function = (token) => {
+        if (token === "*")
+            return;
+        if (token === "<") {
+            this._consume_generic_type_params();
+            return;
+        }
+        if (token.startsWith("<") && token.endsWith(">") && token.length > 1)
+            return;
+        if (token !== "(") {
+            this.function_name = isFunctionName(token) ? token : "";
+            this._static_seen = false;
+            this._async_seen = false;
+            return;
+        }
+        if (!this.started_function)
+            this._push_function_to_stack();
+        this._generic_depth_in_dec = 0;
+        this.next(this._dec, token);
+    };
+    _field = (token) => {
+        this.last_tokens += token;
+        this.next(this.globalState);
+    };
+    _dec = (token) => {
+        if (token === ")") {
+            this.next(this._expecting_func_opening_bracket);
+        }
+        else if (token !== "(") {
+            if (token === ",") {
+                if (this._generic_depth_in_dec === 0)
+                    this.context.parameter(",");
+            }
+            else if (token === "<") {
+                this._generic_depth_in_dec += 1;
+            }
+            else if (token === ">") {
+                if (this._generic_depth_in_dec > 0)
+                    this._generic_depth_in_dec -= 1;
+            }
+            else if (!_TS_TYPE_KEYWORDS.has(token) &&
+                !["*", "+", "-", "/", "%", "=", "."].includes(token) &&
+                this._generic_depth_in_dec === 0 &&
+                isParameter(token)) {
+                this.context.parameter(token.replaceAll("?", ""));
+            }
+            return;
+        }
+        this.context.addToLongFunctionName(` ${token}`);
+    };
+    _expecting_func_opening_bracket = (token) => {
+        if (token === ":") {
+            this._consume_type_annotation();
+        }
+        else if (token === ";" && this.as_object && this._in_abstract_context) {
+            if (this.started_function)
+                this._pop_function_from_stack();
+            this._in_abstract_context = false;
+            this.next(this.globalState);
+        }
+        else if (token !== "{" && token !== "=>") {
+            if (this.started_function) {
+                this.context.forgive = true;
+                this.context.endOfFunction();
+            }
+            this.started_function = false;
+        }
+        this.next(this.globalState, token);
+    };
+    _state_template_literal = (token) => {
+        if (token === "`")
+            this.next(this.globalState);
+    };
+    _collect_computed_name() {
+        const tokens = [];
+        const collect = (token) => {
+            if (token === "]") {
+                this.last_tokens = this._to_camel_case(tokens.join(""));
+                this.next(this.globalState);
+                return true;
+            }
+            tokens.push(token);
+            return false;
+        };
+        this.next(collect);
+    }
+    _consume_generic_type_params() {
+        let depth = 1;
+        const consume = (token) => {
+            if (token === "<")
+                depth += 1;
+            else if (token === ">") {
+                depth -= 1;
+                if (depth === 0)
+                    this.next(this.globalState);
+            }
+        };
+        this.next(consume);
+    }
+    _consume_type_annotation() {
+        const typeStates = new TypeScriptTypeAnnotationStates(this.context);
+        this.subState(typeStates, () => {
+            if (typeStates.saved_token !== undefined)
+                this.consume(typeStates.saved_token);
+        });
+    }
+    _to_camel_case(value) {
+        const normalized = value.replace(/["'+ ]/gu, "");
+        return normalized ? `${normalized[0]?.toLowerCase()}${normalized.slice(1)}` : normalized;
+    }
+}
+class TypeScriptTypeAnnotationStates extends CodeStateMachine {
+    saved_token;
+    constructor(context) {
+        super(context);
+        this.saved_token = undefined;
+    }
+    _state_global(token) {
+        if (token === "{")
+            this.next(this._inline_type_annotation, token);
+        else
+            this.next(this._state_simple_type, token);
+    }
+    _state_simple_type = (token) => {
+        if (token === "<")
+            this.next(this._state_generic_type, token);
+        else if ("{=;)".includes(token)) {
+            this.saved_token = token;
+            this.returnFromState();
+        }
+        else if (token === "(")
+            this.next(this._function_type_annotation, token);
+        else if (token === "=>") {
+            this.saved_token = token;
+            this.returnFromState();
+        }
+    };
+    _inline_type_annotation = (token) => {
+        this.readInsideBracketsThen("{}", token, () => {
+            this.returnFromState();
+        });
+    };
+    _state_generic_type = (token) => {
+        this.readInsideBracketsThen("<>", token, () => {
+            this.returnFromState();
+        });
+    };
+    _function_type_annotation = (token) => {
+        this.readInsideBracketsThen("()", token, () => {
+            this.returnFromState();
+        });
+    };
+}
+function isFunctionName(token) {
+    return /^[\p{L}_$#]/u.test(token);
+}
+function isParameter(token) {
+    const withoutQuestionMark = token.replaceAll("?", "");
+    return (withoutQuestionMark.length > 0 &&
+        /^[\p{L}]/u.test(withoutQuestionMark) &&
+        /^[\p{L}\p{N}_]+$/u.test(withoutQuestionMark));
+}
+//# sourceMappingURL=typescript.mjs.map