@snowtop/ent 0.1.0-alpha3 → 0.1.0-alpha34

package/tsc/ast.js

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomInfo = exports.transformRelative = exports.getImportInfo = exports.isSrcGeneratedImport = exports.isRelativeGeneratedImport = exports.isRelativeImport = exports.updateImportPath = exports.transformImport = exports.getClassInfo = exports.getPreText = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const path = __importStar(require("path"));
+const js_yaml_1 = require("js-yaml");
+const fs = __importStar(require("fs"));
+function getPreText(fileContents, node, sourceFile) {
+    return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
+}
+exports.getPreText = getPreText;
+function getClassInfo(fileContents, sourceFile, node) {
+    let className = node.name?.text;
+    let classExtends;
+    let impl = [];
+    if (node.heritageClauses) {
+        for (const hc of node.heritageClauses) {
+            switch (hc.token) {
+                case typescript_1.default.SyntaxKind.ImplementsKeyword:
+                    for (const type of hc.types) {
+                        impl.push(type.expression.getText(sourceFile));
+                    }
+                    break;
+                case typescript_1.default.SyntaxKind.ExtendsKeyword:
+                    // can only extend one class
+                    for (const type of hc.types) {
+                        const text = type.expression.getText(sourceFile);
+                        classExtends = text;
+                    }
+                    break;
+            }
+        }
+    }
+    if (!className) {
+        return undefined;
+    }
+    let hasExport = false;
+    let hasDefault = false;
+    let comment = getPreText(fileContents, node, sourceFile);
+    const wrapClassContents = (inner) => {
+        let ret = `${comment}`;
+        if (hasExport) {
+            ret += "export ";
+        }
+        if (hasDefault) {
+            ret += "default ";
+        }
+        ret += `class ${className} `;
+        if (classExtends) {
+            ret += `extends ${classExtends} `;
+        }
+        if (impl.length) {
+            ret += `implements ${impl.join(", ")}`;
+        }
+        return `${ret}{
+      ${inner}
+    }`;
+    };
+    if (node.modifiers) {
+        for (const mod of node.modifiers) {
+            const text = mod.getText(sourceFile);
+            if (text === "export") {
+                hasExport = true;
+            }
+            else if (text === "default") {
+                hasDefault = true;
+            }
+        }
+    }
+    return {
+        name: className,
+        extends: classExtends,
+        comment,
+        implements: impl,
+        wrapClassContents,
+        export: hasExport,
+        default: hasDefault,
+    };
+}
+exports.getClassInfo = getClassInfo;
+function transformImport(fileContents, importNode, sourceFile, opts) {
+    // remove quotes too
+    const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    if (text != opts.transformPath) {
+        return;
+    }
+    const impInfo = getImportInfo(importNode, sourceFile);
+    if (!impInfo) {
+        return;
+    }
+    let { imports, start, end, importText, default: def } = impInfo;
+    let removeImportsMap = {};
+    if (opts?.removeImports) {
+        opts.removeImports.forEach((imp) => {
+            removeImportsMap[imp] = true;
+            if (def === imp) {
+                def = "";
+            }
+        });
+    }
+    let finalImports = new Set();
+    for (let i = 0; i < imports.length; i++) {
+        let imp = imports[i].trim();
+        if (imp === "") {
+            continue;
+        }
+        if (opts?.transform) {
+            imp = opts.transform(imp);
+        }
+        if (removeImportsMap[imp]) {
+            continue;
+        }
+        finalImports.add(imp);
+    }
+    if (opts?.newImports) {
+        opts.newImports.forEach((imp) => finalImports.add(imp));
+    }
+    const comment = getPreText(fileContents, importNode, sourceFile);
+    return (comment +
+        "import " +
+        // add default
+        (def || "") +
+        // should probably always be "{" now that we support default
+        (start >= 0 ? importText.substring(0, start + 1) : "{") +
+        Array.from(finalImports).join(", ") +
+        // should probably always be "}"
+        (end >= 0 ? importText.substring(end) : "}") +
+        ' from "' +
+        text +
+        '";');
+}
+exports.transformImport = transformImport;
+function updateImportPath(fileContents, importNode, sourceFile, newPath) {
+    const comment = getPreText(fileContents, importNode, sourceFile);
+    // all this copied from above...
+    const importText = importNode.importClause?.getText(sourceFile) || "";
+    const start = importText.indexOf("{");
+    const end = importText.lastIndexOf("}");
+    if (start === -1 || end === -1) {
+        return;
+    }
+    const imports = importText
+        .substring(start + 1, end)
+        //    .trim()
+        .split(",");
+    return (comment +
+        "import " +
+        importText.substring(0, start + 1) +
+        Array.from(imports).join(", ") +
+        importText.substring(end) +
+        ' from "' +
+        newPath +
+        '";');
+}
+exports.updateImportPath = updateImportPath;
+function isRelativeImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return text.startsWith("..") || text.startsWith("./");
+}
+exports.isRelativeImport = isRelativeImport;
+function isRelativeGeneratedImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return ((text.startsWith("..") || text.startsWith("./")) &&
+        text.indexOf("/generated") !== -1);
+}
+exports.isRelativeGeneratedImport = isRelativeGeneratedImport;
+function isSrcGeneratedImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return text.startsWith("src") && text.includes("/generated");
+}
+exports.isSrcGeneratedImport = isSrcGeneratedImport;
+// TODO doesn't support default + {} yet
+function getImportInfo(imp, sourceFile) {
+    const importText = imp.importClause?.getText(sourceFile) || "";
+    const start = importText.indexOf("{");
+    const end = importText.lastIndexOf("}");
+    const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    if ((start === -1 || end === -1) && !importText.length) {
+        return;
+    }
+    let imports = [];
+    let def;
+    if (start !== -1 && end !== -1) {
+        imports = importText
+            .substring(start + 1, end)
+            //.trim()
+            .split(",");
+    }
+    else {
+        def = importText;
+    }
+    return {
+        importPath: text,
+        importText,
+        start,
+        end,
+        imports,
+        default: def,
+    };
+}
+exports.getImportInfo = getImportInfo;
+function transformRelative(file, importPath, relative) {
+    if (!relative || !importPath.startsWith("src")) {
+        return importPath;
+    }
+    const fileFullPath = path.join(process.cwd(), file);
+    const impFullPath = path.join(process.cwd(), importPath);
+    // relative path is from directory
+    return normalizePath(path.relative(path.dirname(fileFullPath), impFullPath));
+}
+exports.transformRelative = transformRelative;
+function normalizePath(p) {
+    if (p.endsWith("..")) {
+        return p + "/";
+    }
+    return p;
+}
+function getCustomInfo() {
+    let yaml = {};
+    let relativeImports = false;
+    try {
+        yaml = (0, js_yaml_1.load)(fs.readFileSync(path.join(process.cwd(), "ent.yml"), {
+            encoding: "utf8",
+        }));
+        relativeImports = yaml?.codegen?.relativeImports || false;
+        if (yaml?.codegen?.templatizedViewer) {
+            return {
+                viewerInfo: yaml.codegen.templatizedViewer,
+                relativeImports,
+            };
+        }
+    }
+    catch (e) { }
+    return {
+        viewerInfo: {
+            path: "@snowtop/ent",
+            name: "Viewer",
+        },
+        relativeImports,
+    };
+}
+exports.getCustomInfo = getCustomInfo;

package/tsc/compilerOptions.d.ts

@@ -1,2 +1,8 @@
 import ts from "typescript";
 export declare function readCompilerOptions(filePath: string): ts.CompilerOptions;
+export declare function getTarget(target?: string): ts.ScriptTarget;
+export declare function getTargetFromCurrentDir(): ts.ScriptTarget;
+export declare function createSourceFile(target: ts.ScriptTarget, file: string): {
+    contents: string;
+    sourceFile: ts.SourceFile;
+};

package/tsc/compilerOptions.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCompilerOptions = void 0;
+exports.createSourceFile = exports.getTargetFromCurrentDir = exports.getTarget = exports.readCompilerOptions = void 0;
 const fs = __importStar(require("fs"));
 const json5_1 = __importDefault(require("json5"));
 const typescript_1 = __importDefault(require("typescript"));
@@ -59,3 +59,42 @@ function readCompilerOptions(filePath) {
     return options;
 }
 exports.readCompilerOptions = readCompilerOptions;
+function getTarget(target) {
+    switch (target?.toLowerCase()) {
+        case "es2015":
+            return typescript_1.default.ScriptTarget.ES2015;
+        case "es2016":
+            return typescript_1.default.ScriptTarget.ES2016;
+        case "es2017":
+            return typescript_1.default.ScriptTarget.ES2017;
+        case "es2018":
+            return typescript_1.default.ScriptTarget.ES2018;
+        case "es2019":
+            return typescript_1.default.ScriptTarget.ES2019;
+        case "es2020":
+            return typescript_1.default.ScriptTarget.ES2020;
+        case "es2021":
+            return typescript_1.default.ScriptTarget.ES2021;
+        case "es3":
+            return typescript_1.default.ScriptTarget.ES3;
+        case "es5":
+            return typescript_1.default.ScriptTarget.ES5;
+        case "esnext":
+            return typescript_1.default.ScriptTarget.ESNext;
+        default:
+            return typescript_1.default.ScriptTarget.ESNext;
+    }
+}
+exports.getTarget = getTarget;
+function getTargetFromCurrentDir() {
+    const options = readCompilerOptions(".");
+    return getTarget(options.target?.toString());
+}
+exports.getTargetFromCurrentDir = getTargetFromCurrentDir;
+function createSourceFile(target, file) {
+    let contents = fs.readFileSync(file).toString();
+    // go through the file and print everything back if not starting immediately after other position
+    const sourceFile = typescript_1.default.createSourceFile(file, contents, target, false, typescript_1.default.ScriptKind.TS);
+    return { contents, sourceFile };
+}
+exports.createSourceFile = createSourceFile;

package/tsc/move_generated.d.ts

@@ -0,0 +1 @@
+export declare function moveGenerated(relativeImports: boolean): void;

package/tsc/move_generated.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveGenerated = void 0;
+const glob_1 = require("glob");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("./ast");
+const transform_1 = require("./transform");
+class MoveFiles {
+    constructor(globPath) {
+        this.globPath = globPath;
+    }
+    move() {
+        const files = glob_1.glob.sync(this.globPath);
+        moveFiles(files);
+    }
+}
+class TransformImports {
+    constructor(glob, prettierGlob, relativeImports, checkRelativeImportsValid) {
+        this.glob = glob;
+        this.prettierGlob = prettierGlob;
+        this.relativeImports = relativeImports;
+        this.checkRelativeImportsValid = checkRelativeImportsValid;
+        this.globOptions = {
+            ignore: ["node_modules/**"],
+        };
+        this.cwd = process.cwd();
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!typescript_1.default.isImportDeclaration(node)) {
+            return { node };
+        }
+        let dirPath = path.join(this.cwd, file, "..");
+        const newImportPath = this.getNewImportPath(node, file, sourceFile, dirPath);
+        if (!newImportPath) {
+            return { node };
+        }
+        const v = (0, ast_1.updateImportPath)(contents, node, sourceFile, newImportPath);
+        return {
+            traversed: true,
+            rawString: v,
+        };
+    }
+    getNewImportPath(node, file, sourceFile, dirPath) {
+        const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+        // it's relative and has generated in there, continue
+        // do relative imports path regardless of if relative imports is on or not
+        if ((0, ast_1.isRelativeGeneratedImport)(node, sourceFile)) {
+            const oldPath = path.join(dirPath, text);
+            const relFromRoot = path.relative(".", oldPath);
+            const conv = transformPath(relFromRoot);
+            if (!conv || conv.newFile === relFromRoot) {
+                return;
+            }
+            return path.relative(dirPath, conv.newFile);
+        }
+        if (this.checkRelativeImportsValid && (0, ast_1.isRelativeImport)(node, sourceFile)) {
+            const parts = file.split(path.sep);
+            if (parts.length === 5 &&
+                parts.slice(0, 3).join(path.sep) ===
+                    ["src", "graphql", "generated"].join(path.sep)) {
+                // we have custom graphql import paths
+                // src/graphql/generated/mutations|resolvers/foo_type.ts
+                // which used to be
+                // src/graphql/mutations|resolvers/generated/foo_type.ts
+                // we probably have a broken import.
+                // try and fix it...
+                let temp = parts[2];
+                parts[2] = parts[3];
+                parts[3] = temp;
+                const oldPath = parts.join(path.sep);
+                let oldDir = path.join(this.cwd, oldPath, "..");
+                let importPath = path.join(oldDir, text);
+                let exists = fs.statSync(importPath + ".ts", { throwIfNoEntry: false });
+                if (!exists) {
+                    // doesn't exist. sadly has to be fixed manually. could theoretically also be a directory but we shouldn't have that
+                    return;
+                }
+                return path.relative(dirPath, importPath);
+            }
+        }
+        // if relative imports, we done.
+        if (this.relativeImports) {
+            return;
+        }
+        // non relative, only transform src paths with generated
+        if ((0, ast_1.isSrcGeneratedImport)(node, sourceFile)) {
+            const conv = transformPath(text);
+            if (!conv || conv.newFile === text) {
+                return;
+            }
+            return conv.newFile;
+        }
+        return;
+    }
+}
+function transformPath(old) {
+    const parts = old.split(path.sep);
+    if (parts.length < 3) {
+        return;
+    }
+    const changedParts = parts
+        .slice(0, 2)
+        .concat("generated")
+        .concat(parts.slice(2).filter((v) => v !== "generated"));
+    const newFile = changedParts.join(path.sep);
+    return { changedParts, newFile };
+}
+function moveFiles(files) {
+    files.forEach((file) => {
+        const conv = transformPath(file);
+        if (!conv) {
+            return;
+        }
+        const { changedParts, newFile } = conv;
+        if (file === newFile) {
+            return;
+        }
+        // check if directory exists, if not, create recursive dir
+        const p = changedParts.slice(0, changedParts.length - 1).join(path.sep);
+        const statInfo = fs.statSync(p, { throwIfNoEntry: false });
+        if (!statInfo) {
+            fs.mkdirSync(p, {
+                recursive: true,
+            });
+        }
+        // move file to new location
+        fs.renameSync(file, newFile);
+    });
+}
+function moveGenerated(relativeImports) {
+    new MoveFiles("src/ent/**/generated/**/**.ts").move();
+    new MoveFiles("src/graphql/**/generated/**/**.ts").move();
+    (0, transform_1.transform)(new TransformImports("src/ent/**/*.ts", "src/ent/**/*.ts", relativeImports));
+    (0, transform_1.transform)(new TransformImports("src/graphql/**/*.ts", "src/graphql/**/*.ts", relativeImports, true));
+}
+exports.moveGenerated = moveGenerated;

package/tsc/transform.d.ts

@@ -0,0 +1,21 @@
+import { IOptions } from "glob";
+import ts from "typescript";
+interface TraverseChildResponse {
+    node?: ts.Node;
+    rawString?: string;
+    traversed?: boolean;
+    imports?: Map<string, string[]>;
+    removeImports?: string[];
+}
+export interface TransformFile {
+    glob: string;
+    globOptions?: IOptions;
+    preprocessFile?: (contents: string, file: string, sourceFile: ts.SourceFile) => boolean;
+    traverseChild(sourceFile: ts.SourceFile, contents: string, file: string, node: ts.Node): TraverseChildResponse | undefined;
+    filter?(files: string[]): string[];
+    fileToWrite?(file: string): string;
+    postProcess?(file: string): void;
+    prettierGlob?: string;
+}
+export declare function transform(transform: TransformFile): void;
+export {};

package/tsc/transform.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = void 0;
+const glob_1 = require("glob");
+const typescript_1 = __importDefault(require("typescript"));
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const ast_1 = require("./ast");
+const compilerOptions_1 = require("./compilerOptions");
+function normalizePath(p) {
+    if (p.endsWith("..")) {
+        return p + "/";
+    }
+    return p;
+}
+function transform(transform) {
+    let files = glob_1.glob.sync(transform.glob, transform.globOptions);
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    if (transform.filter) {
+        files = transform.filter(files);
+    }
+    files.forEach((file) => {
+        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
+        let nodes = [];
+        let imports = new Map();
+        let removeImports = [];
+        let traversed = false;
+        let seenImports = new Map();
+        typescript_1.default.forEachChild(sourceFile, function (node) {
+            if (typescript_1.default.isImportDeclaration(node)) {
+                const imp = (0, ast_1.getImportInfo)(node, sourceFile);
+                if (imp) {
+                    imp.imports.forEach((v) => {
+                        v = v.trim();
+                        v && seenImports.set(v, true);
+                    });
+                }
+            }
+            const ret = transform.traverseChild(sourceFile, contents, file, node);
+            if (!ret) {
+                return;
+            }
+            if (ret.node || ret.rawString) {
+                nodes.push(ret);
+            }
+            if (ret.imports) {
+                for (const [k, v] of ret.imports) {
+                    imports.set(k, v);
+                }
+            }
+            if (ret.traversed) {
+                traversed = ret.traversed;
+            }
+            if (ret.removeImports?.length) {
+                removeImports.push(...ret.removeImports);
+            }
+        });
+        if (!traversed) {
+            return;
+        }
+        let newContents = "";
+        let afterProcessed = false;
+        let seen = new Map();
+        const processAfterImport = () => {
+            // do this for the first non-import node we see
+            // we want to add new imports to end of imports and there's an assumption that imports are ordered
+            // at top of file
+            if (!afterProcessed) {
+                for (const [imp, list] of imports) {
+                    if (seen.has(imp)) {
+                        continue;
+                    }
+                    const final = list.filter((v) => !seenImports.has(v));
+                    if (final.length) {
+                        newContents += `\nimport { ${final.join(", ")} } from "${imp}"`;
+                    }
+                }
+                afterProcessed = true;
+            }
+        };
+        for (const node of nodes) {
+            if (node.node) {
+                if (typescript_1.default.isImportDeclaration(node.node)) {
+                    const impInfo = (0, ast_1.getImportInfo)(node.node, sourceFile);
+                    //          console.debug(impInfo);
+                    if (impInfo) {
+                        const impPath = normalizePath(impInfo.importPath);
+                        const list = imports.get(impPath);
+                        // path exists, we care about it
+                        if (list !== undefined) {
+                            let transformed = (0, ast_1.transformImport)(contents, node.node, sourceFile, {
+                                // if we've done this path before, don't try and add
+                                // but still try and do any removals since we don't know which of the imports
+                                // has it
+                                newImports: seen.has(impPath) ? undefined : list,
+                                removeImports,
+                                // don't use normalized path here, we wanna use the path that's in code...
+                                transformPath: impInfo.importPath,
+                            });
+                            if (transformed) {
+                                newContents += transformed;
+                                seen.set(impPath, true);
+                                continue;
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (!typescript_1.default.isExportDeclaration(node.node) &&
+                        !isRequireStatement(node.node, sourceFile)) {
+                        processAfterImport();
+                    }
+                }
+                newContents += node.node.getFullText(sourceFile);
+            }
+            else if (node.rawString) {
+                processAfterImport();
+                newContents += node.rawString;
+            }
+            else {
+                throw new Error(`malformed node with no node or rawString`);
+            }
+        }
+        let writeFile = file;
+        if (transform.fileToWrite) {
+            writeFile = transform.fileToWrite(file);
+        }
+        fs.writeFileSync(writeFile, newContents);
+        if (transform.postProcess) {
+            transform.postProcess(file);
+        }
+    });
+    if (transform.prettierGlob) {
+        (0, child_process_1.execSync)(`prettier ${transform.prettierGlob} --write`);
+    }
+}
+exports.transform = transform;
+function isRequireStatement(node, sourceFile) {
+    if (node.kind !== typescript_1.default.SyntaxKind.VariableStatement) {
+        return false;
+    }
+    const v = node;
+    const text = v.declarationList.declarations[0].getFullText(sourceFile);
+    return text.includes("require(");
+}