@hyperweb/telescope 1.15.0

package/main/protod/bufbuild.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllBufDeps = exports.findAllBufLockFiles = exports.findAllBufYamlFiles = exports.parseBufYamlFile = exports.parseBufLockFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const yaml_1 = __importDefault(require("yaml"));
+const utils_1 = require("./utils");
+const utils_2 = require("@cosmology/utils");
+function parseBufLockFile(filePath) {
+    if (!(0, utils_1.isPathExist)(filePath)) {
+        console.warn(`No such file ${filePath}`);
+        return [];
+    }
+    const bufLock = fs_1.default.readFileSync(filePath, "utf8");
+    const deps = bufLock.split(/-\s/);
+    const repos = [];
+    deps.forEach((dep) => {
+        if (!dep.startsWith("remote")) {
+            return;
+        }
+        const bufDep = {
+            owner: /owner:\s(.+)/.exec(dep)?.[1],
+            repo: /repository:\s(.+)/.exec(dep)?.[1],
+        };
+        if (!bufDep.owner || !bufDep.repo) {
+            throw new Error("owner or repository is missing.");
+        }
+        repos.push(bufDep);
+    });
+    return repos;
+}
+exports.parseBufLockFile = parseBufLockFile;
+function parseBufYamlFile(filePath) {
+    if (!(0, utils_1.isPathExist)(filePath)) {
+        console.warn(`No such file ${filePath}`);
+        return [];
+    }
+    const { deps } = yaml_1.default.parse(fs_1.default.readFileSync(filePath, "utf8"));
+    if (deps) {
+        return deps.map((dep) => {
+            const [_, owner, repo] = dep.split("/");
+            return {
+                owner,
+                repo: repo.split(":")[0],
+            };
+        });
+    }
+    return [];
+}
+exports.parseBufYamlFile = parseBufYamlFile;
+function findAllBufYamlFiles(dir) {
+    return (0, utils_2.crossGlob)(`${dir}/**/buf.yaml`, {
+        ignore: `${dir}/node_modules/**`,
+    });
+}
+exports.findAllBufYamlFiles = findAllBufYamlFiles;
+function findAllBufLockFiles(dir) {
+    return (0, utils_2.crossGlob)(`${dir}/**/buf.lock`, {
+        ignore: `${dir}/node_modules/**`,
+    });
+}
+exports.findAllBufLockFiles = findAllBufLockFiles;
+function getAllBufDeps(dir) {
+    const bufDeps = [];
+    const bufLockFiles = findAllBufLockFiles(dir);
+    bufLockFiles.map(async (filePath) => {
+        const deps = parseBufLockFile(filePath);
+        deps.forEach((dep) => {
+            if (bufDeps.findIndex((_dep) => _dep.owner == dep.owner && _dep.repo == dep.repo) == -1) {
+                bufDeps.push(dep);
+            }
+        });
+    });
+    const bufYamlFiles = findAllBufYamlFiles(dir);
+    bufYamlFiles.map(async (filePath) => {
+        const deps = await parseBufYamlFile(filePath);
+        deps.forEach((dep) => {
+            if (bufDeps.findIndex((_dep) => _dep.owner == dep.owner && _dep.repo == dep.repo) == -1) {
+                bufDeps.push(dep);
+            }
+        });
+    });
+    return bufDeps;
+}
+exports.getAllBufDeps = getAllBufDeps;

package/main/protod/config.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetProtoDirMapping = exports.bufInfo = void 0;
+exports.bufInfo = [
+    {
+        owner: "protocolbuffers",
+        repo: "wellknowntypes",
+        git: [
+            {
+                owner: "protocolbuffers",
+                repo: "protobuf",
+            },
+        ],
+    },
+    {
+        owner: "cosmos",
+        repo: "gogo-proto",
+        git: [
+            {
+                owner: "cosmos",
+                repo: "gogoproto",
+            },
+        ],
+    },
+];
+exports.presetProtoDirMapping = {
+    "gogo/protobuf/master": ".",
+    "googleapis/googleapis/master": ".",
+    "protocolbuffers/protobuf/main": "src",
+};

package/main/protod/git-repo.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRepo = void 0;
+const utils_1 = require("./utils");
+const branchCache = {};
+class GitRepo {
+    owner;
+    repo;
+    ssh;
+    constructor(owner, repo, ssh = false) {
+        this.owner = owner;
+        this.repo = repo;
+        this.ssh = ssh;
+    }
+    get fullName() {
+        return `${this.owner}/${this.repo}`;
+    }
+    get httpsUrl() {
+        return `https://github.com/${this.fullName}.git`;
+    }
+    get sshUrl() {
+        return `git@github.com:${this.fullName}.git`;
+    }
+    async getMainBranchName() {
+        const url = this.ssh ? this.sshUrl : this.httpsUrl;
+        if (branchCache[url]) {
+            return branchCache[url];
+        }
+        branchCache[url] = await (0, utils_1.getMainBranchName)(url);
+        return branchCache[url];
+    }
+    clone(branch, depth = 1, outDir = "./git-modules", isOverride) {
+        const dir = `${outDir}/${this.fullName}/${branch}`;
+        try {
+            if (!isOverride && (0, utils_1.isPathExist)(dir)) {
+                console.log(`Folder ${dir} already exists, skip cloning`);
+                return dir;
+            }
+            else {
+                console.log(`Cloning to ${dir}`);
+            }
+            (0, utils_1.removeFolder)(dir);
+            (0, utils_1.makeDir)(dir);
+            (0, utils_1.exec)(`git clone ${this.ssh ? this.sshUrl : this.httpsUrl} --depth ${depth} --branch ${branch} --single-branch ${dir}`);
+            console.log(`Cloned ${this.fullName}/${branch} to ${dir}`);
+            return dir;
+        }
+        catch (error) {
+            if (error.message.startsWith("Cloning into")) {
+                return dir;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+exports.GitRepo = GitRepo;

package/main/protod/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./recursive"), exports);

package/main/protod/recursive.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractProto = exports.clone = exports.cloneAll = void 0;
+const bufbuild_1 = require("./bufbuild");
+const git_repo_1 = require("./git-repo");
+const path_1 = require("path");
+const utils_1 = require("./utils");
+const fs_1 = __importDefault(require("fs"));
+const utils_2 = require("@cosmology/utils");
+async function cloneAll({ repos, gitModulesDir, protoDirMapping, ssh, }) {
+    let clonedResult = {};
+    for (const { owner, repo, branch } of repos) {
+        const cloned = await clone({
+            owner,
+            repo,
+            branch,
+            gitModulesDir,
+            protoDirMapping,
+            ssh,
+            cloned: clonedResult,
+        });
+        for (const [key, value] of Object.entries(cloned)) {
+            clonedResult[key] = value;
+        }
+    }
+    return clonedResult;
+}
+exports.cloneAll = cloneAll;
+async function clone({ owner, repo, branch, gitModulesDir: outDir, protoDirMapping, ssh, cloned, }) {
+    let clonedResult = cloned ?? {};
+    const gitRepo = new git_repo_1.GitRepo(owner, repo, ssh);
+    const gitBranch = branch ?? (await gitRepo.getMainBranchName());
+    const resultKey = `${owner}/${repo}/${gitBranch}`;
+    if (clonedResult[resultKey]) {
+        console.log(`Skip cloning ${resultKey}`);
+        return clonedResult;
+    }
+    const gitDir = gitRepo.clone(gitBranch, 1, outDir);
+    const protoDir = protoDirMapping?.[`${owner}/${repo}/${gitBranch}`] ?? "proto";
+    clonedResult[`${owner}/${repo}/${gitBranch}`] = {
+        owner,
+        repo,
+        branch: gitBranch,
+        protoDir,
+        protoPath: (0, path_1.resolve)(`${outDir}/${owner}/${repo}/${gitBranch}/${protoDir}`),
+    };
+    const bufDeps = await (0, bufbuild_1.getAllBufDeps)(gitDir);
+    await Promise.all(bufDeps.map(async (bufRepo) => {
+        const gitRepos = (0, utils_1.getCorrespondingGit)(bufRepo);
+        await Promise.all(gitRepos.map(async (gitRepo) => {
+            const gitRepoObj = new git_repo_1.GitRepo(gitRepo.owner, gitRepo.repo, ssh);
+            const branch = await gitRepoObj.getMainBranchName();
+            const depsClonedResult = await clone({
+                ...gitRepo,
+                gitModulesDir: outDir,
+                branch,
+                protoDirMapping,
+                ssh,
+                cloned: clonedResult,
+            });
+            for (const [key, value] of Object.entries(depsClonedResult)) {
+                clonedResult[key] = value;
+            }
+        }));
+    }));
+    return clonedResult;
+}
+exports.clone = clone;
+function extractProto({ sources, targets, outDir }) {
+    const extractProtoFiles = extractProtoFromDirs({
+        targets,
+        sources,
+    });
+    extractProtoFiles.map(({ sourceFile, target }) => {
+        const targetFile = (0, path_1.join)(outDir, target);
+        const deepTargetDir = (0, path_1.dirname)(targetFile);
+        (0, utils_1.makeDir)(deepTargetDir);
+        fs_1.default.copyFileSync(sourceFile, targetFile);
+        console.info(`Copied ${target} from ${sourceFile.replace(target, "")}`);
+    });
+}
+exports.extractProto = extractProto;
+function extractProtoFromDirs({ targets, sources, }) {
+    const extractProtoFiles = [];
+    const existingFiles = new Set();
+    if (!targets || targets.length === 0) {
+        return [];
+    }
+    if (!sources || Object.keys(sources).length === 0) {
+        return [];
+    }
+    for (const target of targets) {
+        for (const source of Object.values(sources)) {
+            const sourceProtoPath = (0, path_1.resolve)(source.protoPath);
+            const files = (0, utils_2.crossGlob)((0, path_1.join)(sourceProtoPath, target));
+            extractProtoFiles.push(...files
+                .map((file) => {
+                const copyTarget = (0, path_1.relative)(sourceProtoPath, file);
+                const duplicate = existingFiles.has(copyTarget);
+                existingFiles.add(copyTarget);
+                if (!duplicate) {
+                    const resultFiles = [
+                        {
+                            sourceFile: file,
+                            target: copyTarget,
+                        },
+                    ];
+                    const newTargets = (0, utils_1.parseProtoFile)(file);
+                    if (newTargets && newTargets.length > 0) {
+                        const deps = extractProtoFromDirs({
+                            targets: newTargets,
+                            sources,
+                        });
+                        const filteredDeps = deps?.filter((dep) => {
+                            const depDuplicate = existingFiles.has(dep.target);
+                            existingFiles.add(dep.target);
+                            return !depDuplicate;
+                        });
+                        if (filteredDeps && filteredDeps.length > 0) {
+                            resultFiles.push(...filteredDeps);
+                        }
+                    }
+                    return resultFiles;
+                }
+            })
+                .flat()
+                .filter(Boolean));
+        }
+    }
+    return extractProtoFiles;
+}

package/main/protod/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/main/protod/utils.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDir = exports.removeFolder = exports.findAllProtoFiles = exports.isPathExist = exports.parseProtoFile = exports.getCorrespondingGit = exports.getMainBranchName = exports.exec = void 0;
+const shelljs_1 = require("shelljs");
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("./config");
+const utils_1 = require("@cosmology/utils");
+function exec(command, verbose = false) {
+    const { code, stdout, stderr } = (0, shelljs_1.exec)(command);
+    if (code === 0) {
+        if (verbose) {
+            console.log(stdout);
+        }
+    }
+    else {
+        console.error(`Failed: ${command}`);
+        throw new Error(stderr);
+    }
+    return { stdout };
+}
+exports.exec = exec;
+async function getMainBranchName(url) {
+    console.log(`Checking main branch for ${url}`);
+    const { stdout } = exec(`git ls-remote -h ${url} main`);
+    if (stdout) {
+        return "main";
+    }
+    const { stdout: stdout2 } = exec(`git ls-remote -h ${url} master`);
+    if (stdout2) {
+        return "master";
+    }
+    throw new Error("Can't find `main` or `master` branch");
+}
+exports.getMainBranchName = getMainBranchName;
+function getCorrespondingGit(bufRepo) {
+    const bufItem = config_1.bufInfo.find((repo) => repo.owner === bufRepo.owner && repo.repo === bufRepo.repo);
+    if (bufItem) {
+        return bufItem.git;
+    }
+    else {
+        return [bufRepo];
+    }
+}
+exports.getCorrespondingGit = getCorrespondingGit;
+function parseProtoFile(filePath) {
+    if (!isPathExist(filePath)) {
+        console.warn(`No such file ${filePath}`);
+        return [];
+    }
+    let proto;
+    try {
+        proto = fs_1.default.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        console.log(filePath);
+        throw new Error(error);
+    }
+    const deps = [];
+    proto?.split("\n").forEach((line) => {
+        if (line.trim().startsWith("import ")) {
+            const dep = /import\s"(.+)";?/.exec(line)?.[1];
+            if (!dep) {
+                throw Error(`Failed to parse line: ${line}`);
+            }
+            deps.push(dep);
+        }
+    });
+    return deps;
+}
+exports.parseProtoFile = parseProtoFile;
+function isPathExist(path) {
+    return fs_1.default.existsSync(path);
+}
+exports.isPathExist = isPathExist;
+function findAllProtoFiles(dir) {
+    return (0, utils_1.crossGlob)(`${dir}/**/*.proto`, {
+        ignore: `${dir}/node_modules/**`,
+    });
+}
+exports.findAllProtoFiles = findAllProtoFiles;
+function removeFolder(dir) {
+    fs_1.default.rmSync(dir, { recursive: true, force: true });
+}
+exports.removeFolder = removeFolder;
+function makeDir(dir) {
+    fs_1.default.mkdirSync(dir, { recursive: true });
+}
+exports.makeDir = makeDir;

package/main/telescope.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+var argv = require('minimist')(process.argv.slice(2), {
+    boolean: ['ssh']
+});
+(async () => {
+    await (0, cli_1.cli)(argv);
+})();

package/main/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/main/utils/common-create-bundle.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonBundlePlugin = void 0;
+const imports_1 = require("../imports");
+const path_1 = require("path");
+const build_1 = require("../build");
+const files_1 = require("../utils/files");
+const utils_1 = require("../utils");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const commonBundlePlugin = (builder, bundleFilename, packageMappings, astFn) => {
+    const localname = bundleFilename;
+    // create proto ref for context
+    const pkg = '@root';
+    const ref = (0, proto_parser_1.createEmptyProtoRef)(pkg, localname);
+    // create context
+    const pCtx = new build_1.TelescopeParseContext(ref, builder.store, builder.options);
+    // generate code for createRpcQueryHooks and imports of related packages.
+    const ast = astFn(pCtx.proto, packageMappings);
+    // generate imports added by context.addUtil
+    const imports = (0, utils_1.fixlocalpaths)((0, imports_1.aggregateImports)(pCtx, {}, localname));
+    const importStmts = (0, imports_1.getImportStatements)(localname, imports, builder.options);
+    // construct the AST
+    const prog = [].concat(importStmts).concat(ast);
+    // write the file.
+    const filename = (0, path_1.join)(builder.outPath, localname);
+    builder.files.push(localname);
+    (0, files_1.writeAstToFile)(builder.outPath, builder.options, prog, filename);
+};
+exports.commonBundlePlugin = commonBundlePlugin;

package/main/utils/contracts.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContractSchemata = exports.getContracts = exports.getDirectories = void 0;
+const ts_codegen_1 = require("@cosmwasm/ts-codegen");
+const case_1 = require("case");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const getDirectories = source => (0, fs_1.readdirSync)(source, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+exports.getDirectories = getDirectories;
+const getContracts = () => {
+    const contracts = (0, exports.getDirectories)('./contracts')
+        .map(contractDirname => {
+        return {
+            name: `${contractDirname}`,
+            value: `./contracts/${contractDirname}`
+        };
+    });
+    return contracts;
+};
+exports.getContracts = getContracts;
+const getContractSchemata = async (schemata, out, argv) => {
+    const s = [];
+    for (let i = 0; i < schemata.length; i++) {
+        const path = schemata[i];
+        const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(path, 'package.json'), 'utf-8'));
+        const name = (0, path_1.basename)(path);
+        const folder = (0, path_1.basename)((0, path_1.dirname)(path));
+        const contractName = (0, case_1.pascal)(pkg.contract) || (0, case_1.pascal)(name);
+        const schemas = await (0, ts_codegen_1.readSchemas)({ schemaDir: path });
+        const outPath = (0, path_1.join)(out, folder);
+        s.push({
+            contractName, schemas, outPath
+        });
+    }
+    return s;
+};
+exports.getContractSchemata = getContractSchemata;

package/main/utils/files.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.writeContentToFile = exports.writeAstToFile = exports.getExportedTypeNames = void 0;
+const t = __importStar(require("@babel/types"));
+const parser_1 = require("@babel/parser");
+const mkdirp_1 = require("mkdirp");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const minimatch_1 = __importDefault(require("minimatch"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const unused_1 = require("./unused");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const utils_1 = require("@cosmology/utils");
+function getExportedTypeNames(program) {
+    const exportedNames = [];
+    const ast = t.program(program);
+    const content = (0, generator_1.default)(ast).code;
+    const plugins = ["typescript"];
+    const newAst = (0, parser_1.parse)(content, {
+        sourceType: "module",
+        plugins,
+    });
+    (0, traverse_1.default)(newAst, {
+        ExportNamedDeclaration(path) {
+            const node = path.node;
+            // Handle direct declarations (type aliases, interfaces, enums)
+            if (node.declaration) {
+                const decl = node.declaration;
+                const isTypeExport = node.exportKind === "type";
+                const isTypeDecl = [
+                    "TSTypeAliasDeclaration",
+                    "TSInterfaceDeclaration",
+                    "TSEnumDeclaration",
+                ].includes(decl.type);
+                if (isTypeExport || isTypeDecl) {
+                    if ("id" in decl && decl.id?.type === "Identifier") {
+                        exportedNames.push(decl.id.name);
+                    }
+                }
+                // Handle const declarations that might be types (e.g., const schemas)
+                if (decl.type === "VariableDeclaration" && decl.kind === "const") {
+                    decl.declarations.forEach((declarator) => {
+                        if (declarator.id?.type === "Identifier") {
+                            exportedNames.push(declarator.id.name);
+                        }
+                    });
+                }
+            }
+            // Handle export specifiers (e.g., export { SomeType })
+            if (node.specifiers && node.specifiers.length > 0) {
+                const isTypeExport = node.exportKind === "type";
+                if (isTypeExport) {
+                    node.specifiers.forEach((spec) => {
+                        if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") {
+                            exportedNames.push(spec.exported.name);
+                        }
+                    });
+                }
+            }
+        },
+    });
+    return exportedNames;
+}
+exports.getExportedTypeNames = getExportedTypeNames;
+const writeAstToFile = (outPath, options, program, filename) => {
+    const ast = t.program(program);
+    const content = (0, generator_1.default)(ast).code;
+    if (options.removeUnusedImports) {
+        const plugins = ["typescript"];
+        const newAst = (0, parser_1.parse)(content, {
+            sourceType: "module",
+            plugins,
+        });
+        (0, traverse_1.default)(newAst, unused_1.unused);
+        const content2 = (0, generator_1.default)(newAst).code;
+        (0, exports.writeContentToFile)((0, utils_1.toPosixPath)(outPath), options, content2, (0, utils_1.toPosixPath)(filename));
+    }
+    else {
+        (0, exports.writeContentToFile)((0, utils_1.toPosixPath)(outPath), options, content, (0, utils_1.toPosixPath)(filename));
+    }
+};
+exports.writeAstToFile = writeAstToFile;
+const writeContentToFile = (outPath, options, content, filename) => {
+    let esLintPrefix = "";
+    let tsLintPrefix = "";
+    let nameWithoutPath = filename.replace(outPath, "");
+    // strip off leading slash
+    if (nameWithoutPath.startsWith("/"))
+        nameWithoutPath = nameWithoutPath.replace(/^\//, "");
+    options.tsDisable.patterns.forEach((pattern) => {
+        if ((0, minimatch_1.default)(nameWithoutPath, pattern)) {
+            tsLintPrefix = `//@ts-nocheck\n`;
+        }
+    });
+    options.eslintDisable.patterns.forEach((pattern) => {
+        if ((0, minimatch_1.default)(nameWithoutPath, pattern)) {
+            esLintPrefix = `/* eslint-disable */\n`;
+        }
+    });
+    if (options.tsDisable.files.includes(nameWithoutPath) ||
+        options.tsDisable.disableAll) {
+        tsLintPrefix = `//@ts-nocheck\n`;
+    }
+    if (options.eslintDisable.files.includes(nameWithoutPath) ||
+        options.eslintDisable.disableAll) {
+        esLintPrefix = `/* eslint-disable */\n`;
+    }
+    const text = tsLintPrefix + esLintPrefix + content;
+    mkdirp_1.mkdirp.sync((0, path_1.dirname)(filename));
+    (0, fs_1.writeFileSync)(filename, text);
+};
+exports.writeContentToFile = writeContentToFile;