@storm-stack/core/dist/lib/chunk-EXLTFVJD.cjs

A build toolkit and runtime used by Storm Software in TypeScript applications

'use strict';

var chunkGRNJVY7I_cjs = require('./chunk-GRNJVY7I.cjs');
var listFiles = require('@stryke/fs/list-files');
var readFile = require('@stryke/fs/read-file');
var resolve = require('@stryke/fs/resolve');
var filePathFns = require('@stryke/path/file-path-fns');
var joinPaths = require('@stryke/path/join-paths');
var defu = require('defu');
var minimatch = require('minimatch');
var ts = require('typescript');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var defu__default = /*#__PURE__*/_interopDefault(defu);
var ts__default = /*#__PURE__*/_interopDefault(ts);

var SourcesMap = Map;
async function loadLibFiles() {
  const libLocation = await resolve.resolvePackage("typescript");
  if (!libLocation) {
    throw new Error("Could not resolve TypeScript package location.");
  }
  const libFiles = await listFiles.listFiles(joinPaths.joinPaths(libLocation, "lib", "**", "lib.*.d.ts"));
  if (libFiles.length === 0) {
    throw new Error("No TypeScript library files found.");
  }
  const lib = /* @__PURE__ */ new Map();
  for (const file of libFiles) {
    lib.set(`/node_modules/typescript/lib/${filePathFns.findFileName(file)}`, await readFile.readFile(file));
  }
  return lib;
}
chunkGRNJVY7I_cjs.__name(loadLibFiles, "loadLibFiles");
function getDefaultCompilerOptions() {
  return {
    ...ts__default.default.getDefaultCompilerOptions(),
    jsx: ts__default.default.JsxEmit.React,
    strict: true,
    esModuleInterop: true,
    module: ts__default.default.ModuleKind.ESNext,
    suppressOutputPathCheck: true,
    skipLibCheck: true,
    skipDefaultLibCheck: true,
    moduleResolution: ts__default.default.ModuleResolutionKind.Node10
  };
}
chunkGRNJVY7I_cjs.__name(getDefaultCompilerOptions, "getDefaultCompilerOptions");
async function createVirtualProgram(rootNames, context, compilerOptions = {}) {
  const options = defu__default.default(compilerOptions, getDefaultCompilerOptions());
  const host = {
    name: "storm-vfs",
    root: context.options.workspaceRoot,
    ...ts__default.default.sys,
    realpath: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((path) => {
      if (context.vfs.existsSync(path)) {
        return context.vfs.resolvePath(path);
      }
      return ts__default.default.sys.realpath?.(path) ?? path;
    }, "realpath"),
    getCurrentDirectory() {
      return context.options.workspaceRoot;
    },
    getCanonicalFileName(fileName) {
      return fileName;
    },
    getDefaultLibFileName(_options) {
      return ts__default.default.getDefaultLibFileName(options);
    },
    getDefaultLibLocation() {
      return "/";
    },
    getNewLine() {
      return "\n";
    },
    useCaseSensitiveFileNames() {
      return true;
    },
    fileExists(fileName) {
      return context.vfs.existsSync(fileName);
    },
    readFile(fileName) {
      if (context.vfs.existsSync(fileName)) {
        return context.vfs.readFileSync(fileName);
      }
      return void 0;
    },
    readDirectory: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((path, extensions = [], exclude = [], include = []) => {
      let results = [];
      if (context.vfs.existsSync(path)) {
        results = context.vfs.readdirSync(path, {
          encoding: "utf8",
          recursive: true
        });
        if (extensions.length > 0) {
          results = results.filter((file) => extensions.some((ext) => file.endsWith(ext.startsWith(".") ? ext : `.${ext}`)));
        }
        if (exclude.length > 0) {
          results = results.filter((file) => !exclude.some((pattern) => minimatch.minimatch(file, pattern)));
        }
        if (include.length > 0) {
          results = results.filter((file) => include.some((pattern) => minimatch.minimatch(file, pattern)));
        }
      }
      return results;
    }, "readDirectory"),
    writeFile(fileName, data) {
      context.vfs.writeFileSync(fileName, data);
    },
    resolvePath: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((fileName) => {
      if (context.vfs.existsSync(fileName)) {
        return context.vfs.resolvePath(fileName);
      }
      return ts__default.default.sys.resolvePath(fileName);
    }, "resolvePath"),
    getSourceFile(fileName, languageVersionOrOptions, _, shouldCreateNewSourceFile) {
      if (context.vfs.existsSync(fileName)) {
        return ts__default.default.createSourceFile(fileName, context.vfs.readFileSync(fileName), languageVersionOrOptions ?? compilerOptions.target ?? getDefaultCompilerOptions().target, false);
      } else if (shouldCreateNewSourceFile) {
        const sourceFile = ts__default.default.createSourceFile(fileName, "", languageVersionOrOptions ?? compilerOptions.target ?? getDefaultCompilerOptions().target, false);
        context.vfs.writeFileSync(fileName, sourceFile.text);
        return sourceFile;
      }
      return void 0;
    }
  };
  return ts__default.default.createProgram(rootNames, options, host);
}
chunkGRNJVY7I_cjs.__name(createVirtualProgram, "createVirtualProgram");
function createVirtualCompilerHost(sys, compilerOptions) {
  const sourceFiles = /* @__PURE__ */ new Map();
  const save = /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((sourceFile) => {
    sourceFiles.set(sourceFile.fileName, sourceFile);
    return sourceFile;
  }, "save");
  const vHost = {
    compilerHost: {
      ...sys,
      getCanonicalFileName: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((fileName) => fileName, "getCanonicalFileName"),
      getDefaultLibFileName: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name(() => `/${ts__default.default.getDefaultLibFileName(compilerOptions)}`, "getDefaultLibFileName"),
      // getDefaultLibLocation: () => '/',
      getNewLine: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name(() => sys.newLine, "getNewLine"),
      getSourceFile: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((fileName, languageVersionOrOptions) => {
        return sourceFiles.get(fileName) ?? save(ts__default.default.createSourceFile(fileName, sys.readFile(fileName), languageVersionOrOptions ?? compilerOptions.target, false));
      }, "getSourceFile"),
      useCaseSensitiveFileNames: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name(() => sys.useCaseSensitiveFileNames, "useCaseSensitiveFileNames")
    },
    updateFile: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((sourceFile) => {
      const alreadyExists = sourceFiles.has(sourceFile.fileName);
      sys.writeFile(sourceFile.fileName, sourceFile.text);
      sourceFiles.set(sourceFile.fileName, sourceFile);
      return alreadyExists;
    }, "updateFile"),
    deleteFile: /* @__PURE__ */ chunkGRNJVY7I_cjs.__name((sourceFile) => {
      const alreadyExists = sourceFiles.has(sourceFile.fileName);
      sourceFiles.delete(sourceFile.fileName);
      sys.deleteFile(sourceFile.fileName);
      return alreadyExists;
    }, "deleteFile")
  };
  return vHost;
}
chunkGRNJVY7I_cjs.__name(createVirtualCompilerHost, "createVirtualCompilerHost");

exports.SourcesMap = SourcesMap;
exports.createVirtualCompilerHost = createVirtualCompilerHost;
exports.createVirtualProgram = createVirtualProgram;
exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
exports.loadLibFiles = loadLibFiles;