@ohmyts/vite/dist/index.cjs

Proxy request to get response data and transform to TypeScript code.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

const events = require('events');
const httpProxy = require('http-proxy');
const parse = require('url-parse');
const fs = require('fs');
const JsonToTS = require('json-to-ts');
const MagicString = require('magic-string');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  const n = Object.create(null);
  if (e) {
    for (const k in e) {
      n[k] = e[k];
    }
  }
  n["default"] = e;
  return n;
}

const events__default = /*#__PURE__*/_interopDefaultLegacy(events);
const httpProxy__default = /*#__PURE__*/_interopDefaultLegacy(httpProxy);
const parse__default = /*#__PURE__*/_interopDefaultLegacy(parse);
const fs__namespace = /*#__PURE__*/_interopNamespace(fs);
const JsonToTS__default = /*#__PURE__*/_interopDefaultLegacy(JsonToTS);
const MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);

function writeFileSyncRecursive(filename, content, charset = "utf-8") {
  let filepath = filename.replace(/\\/g, "/");
  let root = "";
  if (filepath[0] === "/") {
    root = "/";
    filepath = filepath.slice(1);
  } else if (filepath[1] === ":") {
    root = filepath.slice(0, 3);
    filepath = filepath.slice(3);
  }
  const folders = filepath.split("/").slice(0, -1);
  folders.reduce(
    (acc, folder) => {
      const folderPath = `${acc + folder}/`;
      if (!fs__namespace.existsSync(folderPath))
        fs__namespace.mkdirSync(folderPath);
      return folderPath;
    },
    root
  );
  fs__namespace.writeFileSync(root + filepath, content, charset);
}

const parseUrl = (req) => {
  const parsedUrl = parse__default(req.url).pathname.split("/").map((name) => `${(name[0] || "").toUpperCase()}${name.slice(1)}`).join("");
  return `${req.method.toString().toUpperCase()}_${parsedUrl}.d.ts`;
};

const transformJSONToTs = (req, chunks, options) => {
  const {
    suffix = "ResponseType",
    encoding = "utf-8",
    rootDir = "@types",
    overwrite = true,
    declare = true
  } = options;
  const name = parseUrl(req);
  let dir = rootDir;
  if (rootDir.endsWith("/")) {
    const splitDir = rootDir.split("/");
    dir = splitDir.slice(0, splitDir.length - 1).join("");
  }
  dir = `${dir}/${name}`;
  const isFileExist = fs__namespace.existsSync(dir);
  if (overwrite || !isFileExist) {
    try {
      const json = JSON.parse(Buffer.concat(chunks).toString(encoding));
      const code = new MagicString__default(JsonToTS__default(json).toLocaleString().replaceAll("},interface", "}\ninterface"));
      const typename = name.split("_");
      code.replace("interface RootObject", `${declare ? "declare" : "export"} interface I${typename[0]}${typename[1].replace(".d.ts", "")}${suffix}`);
      writeFileSyncRecursive(dir, code.toString());
    } catch (err) {
      console.log(`[ohmyts Error] ${err}`);
    }
  }
};

const ee = events__default.EventEmitter;
function ohmytsVite(options) {
  return {
    name: "ohmyts",
    configureServer(server) {
      const proxy = httpProxy__default.createProxyServer();
      const proxyWeb = (req, res, pathname, option) => {
        proxy.web(req, res, {
          changeOrigin: true,
          ...option.proxyOptions
        });
      };
      ee.setMaxListeners(0);
      return () => {
        if (!Array.isArray(options))
          options = [options];
        for (const option of options) {
          server.middlewares.use(option.target, (req, res) => {
            const pathname = parse__default(req.url).pathname;
            proxyWeb(req, res, pathname, option);
            proxy.on("proxyRes", (proxyRes) => {
              const chunks = [];
              proxyRes.on("data", (chunk) => {
                chunks.push(chunk);
              });
              proxyRes.on("end", () => {
                transformJSONToTs(req, chunks, option);
              });
            });
          });
        }
      };
    }
  };
}

exports.ohmytsVite = ohmytsVite;