@react-lib-tech/react-tsx-to-jsx/dist/index.cjs

A tiny React component library (JS) for converting TSX → JSX and extracting text

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.js
var index_exports = {};
__export(index_exports, {
  LovableDownload: () => LovableDownload,
  convertFolder: () => rename_js_to_jsx_default
});
module.exports = __toCommonJS(index_exports);

// src/utils/restore-project.jsx
var import_axios = __toESM(require("axios"), 1);
var import_fs = __toESM(require("fs"), 1);
var import_path = __toESM(require("path"), 1);
var import_https = __toESM(require("https"), 1);
var httpsAgent = new import_https.default.Agent({ rejectUnauthorized: false });
var API_URL = "https://lovable-api.com/projects/";
async function LovableDownload({
  PROJECT_Id = "5b9f446c-d608-4948-aed1-7e5ba9ad04c0",
  Authorization = "",
  outputDir = process.cwd(),
  allowBinary = false
} = {}) {
  const baseOut = import_path.default.resolve(outputDir);
  function safeResolve(rel) {
    const resolved = import_path.default.resolve(baseOut, rel);
    if (resolved === baseOut || resolved.startsWith(baseOut + import_path.default.sep)) {
      return resolved;
    }
    throw new Error(`Unsafe path detected: ${rel}`);
  }
  try {
    const res = await import_axios.default.get(API_URL + PROJECT_Id + "/source-code", {
      httpsAgent,
      headers: { Authorization }
    });
    const data = res == null ? void 0 : res.data;
    if (!data || !Array.isArray(data.files)) {
      console.log("No files returned by API");
      return;
    }
    for (const file of data == null ? void 0 : data.files) {
      try {
        const destPath = safeResolve(file.name);
        if (file.binary && !allowBinary) {
          console.log(`\u26A0\uFE0F Skipping binary file: ${file.name}`);
          continue;
        }
        import_fs.default.mkdirSync(import_path.default.dirname(destPath), { recursive: true });
        if (file.binary) {
          const contents = file.contents ?? "";
          try {
            const buffer = Buffer.from(contents, "base64");
            import_fs.default.writeFileSync(destPath, buffer);
          } catch (e) {
            console.warn(`\u26A0\uFE0F Failed to write binary file ${file.name}: ${e.message}`);
            continue;
          }
        } else {
          const contents = typeof file.contents === "string" ? file.contents : JSON.stringify(file.contents ?? "", null, 2);
          import_fs.default.writeFileSync(destPath, contents, "utf8");
        }
        console.log(`\u2705 Created: ${destPath}`);
      } catch (innerErr) {
        console.warn(`\u26A0\uFE0F Skipped file ${file.name}: ${innerErr.message}`);
      }
    }
    console.log("\u{1F389} Project restored with correct folder structure!");
    console.log(`Files written to: ${baseOut}`);
  } catch (err) {
    console.error("\u274C Error:", (err == null ? void 0 : err.message) ?? err);
  }
}

// src/utils/rename-js-to-jsx.jsx
var import_fs2 = __toESM(require("fs"), 1);
var import_path2 = __toESM(require("path"), 1);
var import_core = __toESM(require("@babel/core"), 1);
function loadGitignore(rootPath = ".") {
  const gitignorePath = import_path2.default.join(rootPath, ".gitignore");
  if (!import_fs2.default.existsSync(gitignorePath)) return [];
  return import_fs2.default.readFileSync(gitignorePath, "utf8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
}
function patternToRegex(pattern) {
  let regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
  if (pattern.endsWith("/")) {
    regexStr = regexStr + ".*";
  }
  return new RegExp(regexStr);
}
function createIgnoreMatcher(rootPath, userSkips = []) {
  const patterns = [
    ...loadGitignore(rootPath).map(patternToRegex),
    ...userSkips.map(patternToRegex)
  ];
  return function isIgnored(relPath) {
    const normalized = relPath.replace(/\\/g, "/");
    return patterns.some((regex) => regex.test(normalized));
  };
}
var defaultReplacementRules = [
  { find: /@\/components\//g, replace: "../components/" },
  { find: /@\/lib\//g, replace: "../../lib/" },
  { find: /@\/utils\//g, replace: "../utils/" },
  { find: /@\/assets\//g, replace: "../public/assets/" }
];
async function tsxToJsx(tsPath, outPath, isTsx, InputreplacementRules = []) {
  try {
    const code = import_fs2.default.readFileSync(tsPath, "utf-8");
    const result = await import_core.default.transformAsync(code, {
      filename: tsPath,
      presets: ["@babel/preset-typescript"]
    });
    let output = result.code || "";
    const replacementRules = [
      ...defaultReplacementRules,
      ...InputreplacementRules
    ];
    replacementRules.forEach((rule) => {
      output = output.replace(rule.find, rule.replace);
    });
    import_fs2.default.mkdirSync(import_path2.default.dirname(outPath), { recursive: true });
    import_fs2.default.writeFileSync(outPath, output, "utf-8");
    console.log(`\u2705 Converted: ${tsPath} -> ${outPath}`);
  } catch (err) {
    console.error(`\u274C Error converting ${tsPath}:`, err.message);
  }
}
var convertFolder = async ({
  srcFolder = "src",
  outFolder = "dist",
  InputreplacementRules = [],
  typeConvert = ".jsx",
  skipFiles = []
}) => {
  if (!import_fs2.default.existsSync(srcFolder)) {
    console.error(`\u274C Source folder not found: ${srcFolder}`);
    return;
  }
  const isIgnored = createIgnoreMatcher(process.cwd(), skipFiles);
  const entries = import_fs2.default.readdirSync(srcFolder, { withFileTypes: true });
  for (const entry of entries) {
    const srcPath = import_path2.default.join(srcFolder, entry.name);
    const relPath = import_path2.default.relative(process.cwd(), srcPath);
    if (isIgnored(relPath)) {
      console.log(`\u23ED\uFE0F Skipped: ${relPath}`);
      continue;
    }
    const outPath = import_path2.default.join(outFolder, entry.name);
    if (entry.isDirectory()) {
      await convertFolder({
        srcFolder: srcPath,
        outFolder: outPath,
        InputreplacementRules,
        typeConvert,
        skipFiles
      });
    } else if (entry.isFile()) {
      if (entry.name.endsWith(".tsx")) {
        const jsxPath = outPath.replace(/\.tsx$/, typeConvert);
        await tsxToJsx(srcPath, jsxPath, true, InputreplacementRules);
      } else if (entry.name.endsWith(".ts")) {
        const jsPath = outPath.replace(/\.ts$/, ".js");
        await tsxToJsx(srcPath, jsPath, false, InputreplacementRules);
      }
    }
  }
};
var rename_js_to_jsx_default = convertFolder;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  LovableDownload,
  convertFolder
});
//# sourceMappingURL=index.cjs.map