@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/utils/codemods/convertCjsToEsm.js

@@ -1,27 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-export async function convertCjsToEsm(projectPath) {
-  relinka("info", `Converting CommonJS to ESM in ${projectPath}`);
-  const files = await glob("**/*.{js,jsx,ts,tsx}", {
-    cwd: path.resolve(projectPath)
-  });
-  for (const file of files) {
-    const filePath = path.join(projectPath, file);
-    const content = await fs.readFile(filePath, "utf-8");
-    let updatedContent = content;
-    updatedContent = updatedContent.replace(
-      /(?:const|let|var)\s*{\s*([^}]+)}\s*=\s*require\(['"]([^'"]+)['"]\)/g,
-      'import { $1 } from "$2"'
-    ).replace(
-      /(?:const|let|var)\s+(\w+)\s*=\s*require\(['"]([^'"]+)['"]\)/g,
-      'import $1 from "$2"'
-    );
-    updatedContent = updatedContent.replace(/module\.exports\s*=\s*([^;\n]+)/g, "export default $1").replace(/module\.exports\.(\w+)\s*=\s*([^;\n]+)/g, "export const $1 = $2").replace(/exports\.(\w+)\s*=\s*([^;\n]+)/g, "export const $1 = $2");
-    if (content !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, "utf-8");
-      relinka("info", `Converted ${filePath} to ESM`);
-    }
-  }
-}

package/bin/impl/utils/codemods/convertDatabase.d.ts

@@ -1,2 +0,0 @@
-export declare function convertPrismaToDrizzle(cwd: string, targetDbType: string): Promise<void>;
-export declare function convertDatabaseProvider(cwd: string, fromProvider: string, toProvider: string): Promise<void>;

package/bin/impl/utils/codemods/convertDatabase.js

@@ -1,229 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs, { ensuredir } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { readPackageJSON, writePackageJSON } from "pkg-types";
-function parsePrismaSchema(content) {
-  const models = [];
-  const modelRegex = /model\s+(\w+)\s*{([^}]+)}/g;
-  const fieldRegex = /(\w+)\s+(\w+)(\[\])?\s*(\?)?\s*(@[^@\n]+)?/g;
-  let match;
-  while ((match = modelRegex.exec(content)) !== null) {
-    const [_, modelName, fieldsStr] = match;
-    const fields = [];
-    let fieldMatch;
-    if (fieldsStr) {
-      while ((fieldMatch = fieldRegex.exec(fieldsStr)) !== null) {
-        const [_2, name, type, isList, isOptional, attributes] = fieldMatch;
-        if (name && type) {
-          fields.push({
-            name,
-            type,
-            isOptional: !!isOptional,
-            isList: !!isList,
-            attributes: parseAttributes(attributes ?? "")
-          });
-        }
-      }
-    }
-    if (modelName) {
-      models.push({ name: modelName, fields });
-    }
-  }
-  return models;
-}
-function parseAttributes(attributesStr) {
-  const attributes = {};
-  const attrRegex = /@(\w+)(?:\((.*?)\))?/g;
-  let match;
-  while ((match = attrRegex.exec(attributesStr)) !== null) {
-    const [_, name, args] = match;
-    if (name) {
-      attributes[name] = args ? parseAttributeArgs(args) : true;
-    }
-  }
-  return attributes;
-}
-function parseAttributeArgs(args) {
-  if (args.startsWith("[") && args.endsWith("]")) {
-    return args.slice(1, -1).split(",").map((s) => s.trim());
-  }
-  if (args === "true") {
-    return true;
-  }
-  if (args === "false") {
-    return false;
-  }
-  if (/^\d+$/.test(args)) {
-    return parseInt(args, 10);
-  }
-  return args.replace(/['"]/g, "");
-}
-function convertPrismaToDrizzleType(field, dbType) {
-  const typeMap = {
-    postgres: {
-      Int: "integer",
-      String: "text",
-      Boolean: "boolean",
-      DateTime: "timestamp",
-      Float: "real",
-      BigInt: "bigint",
-      Decimal: "decimal",
-      Json: "jsonb",
-      Bytes: "bytea"
-    },
-    mysql: {
-      Int: "int",
-      String: "text",
-      Boolean: "boolean",
-      DateTime: "timestamp",
-      Float: "float",
-      BigInt: "bigint",
-      Decimal: "decimal",
-      Json: "json",
-      Bytes: "blob"
-    },
-    sqlite: {
-      Int: "integer",
-      String: "text",
-      Boolean: "integer",
-      DateTime: "integer",
-      Float: "real",
-      BigInt: "integer",
-      Decimal: "real",
-      Json: "text",
-      Bytes: "blob"
-    }
-  };
-  return typeMap[dbType]?.[field.type] ?? "text";
-}
-function generateDrizzleSchema(models, dbType) {
-  const tablePrefix = dbType === "postgres" ? "pg" : dbType === "mysql" ? "mysql" : "sqlite";
-  const imports = /* @__PURE__ */ new Set([`${tablePrefix}Table`]);
-  const modelSchemas = models.map((model) => {
-    const fields = model.fields.map((field) => {
-      const drizzleType = convertPrismaToDrizzleType(field, dbType);
-      imports.add(drizzleType);
-      let fieldDef = `${field.name}: ${drizzleType}("${field.name}")`;
-      if (field.attributes.id) {
-        fieldDef += ".primaryKey()";
-      }
-      if (field.attributes.unique) {
-        fieldDef += ".unique()";
-      }
-      if (!field.isOptional) {
-        fieldDef += ".notNull()";
-      }
-      if (field.attributes.default) {
-        if (field.type === "DateTime" && field.attributes.default === "now()") {
-          fieldDef += ".default(sql`CURRENT_TIMESTAMP`)";
-          imports.add("sql");
-        } else {
-          fieldDef += `.default(${field.attributes.default})`;
-        }
-      }
-      return fieldDef;
-    });
-    return `export const ${model.name.toLowerCase()} = ${tablePrefix}Table("${model.name.toLowerCase()}", {
-  ${fields.join(",\n  ")}
-});`;
-  });
-  let importStatement = `import { ${Array.from(imports).join(", ")} } from "drizzle-orm/${dbType}";`;
-  if (imports.has("sql")) {
-    importStatement = `import { sql } from "drizzle-orm";
-${importStatement}`;
-  }
-  return `${importStatement}
-${modelSchemas.join("\n\n")}`;
-}
-export async function convertPrismaToDrizzle(cwd, targetDbType) {
-  const prismaSchemaPath = path.join(cwd, "prisma/schema.prisma");
-  if (!await fs.pathExists(prismaSchemaPath)) {
-    relinka("error", "No Prisma schema found");
-    return;
-  }
-  const schemaContent = await fs.readFile(prismaSchemaPath, "utf-8");
-  const models = parsePrismaSchema(schemaContent);
-  const drizzleSchema = generateDrizzleSchema(models, targetDbType);
-  const drizzleConfig = `import type { Config } from "drizzle-kit";
-export default {
-  schema: "./src/db/schema.ts",
-  out: "./drizzle",
-} satisfies Config;`;
-  await ensuredir(path.join(cwd, "src/db"));
-  await fs.writeFile(path.join(cwd, "src/db/schema.ts"), drizzleSchema);
-  await fs.writeFile(path.join(cwd, "drizzle.config.ts"), drizzleConfig);
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (await fs.pathExists(packageJsonPath)) {
-    const packageJson = await readPackageJSON(packageJsonPath);
-    if (packageJson.dependencies) {
-      packageJson.dependencies["@prisma/client"] = "";
-    }
-    if (packageJson.devDependencies) {
-      packageJson.devDependencies.prisma = "";
-    }
-    packageJson.dependencies = {
-      ...packageJson.dependencies,
-      "drizzle-orm": "latest"
-    };
-    packageJson.devDependencies = {
-      ...packageJson.devDependencies,
-      "drizzle-kit": "latest"
-    };
-    if (targetDbType === "postgres") {
-      packageJson.dependencies.postgres = "latest";
-    } else if (targetDbType === "mysql") {
-      packageJson.dependencies.mysql2 = "latest";
-    } else if (targetDbType === "sqlite") {
-      packageJson.dependencies["better-sqlite3"] = "latest";
-      packageJson.devDependencies["@types/better-sqlite3"] = "latest";
-    }
-    await writePackageJSON(packageJsonPath, packageJson);
-  }
-  relinka("success", "Converted Prisma schema to Drizzle schema");
-}
-export async function convertDatabaseProvider(cwd, fromProvider, toProvider) {
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (!await fs.pathExists(packageJsonPath)) {
-    relinka("error", "No package.json found");
-    return;
-  }
-  const packageJson = await readPackageJSON(packageJsonPath);
-  if (fromProvider === "postgres" && toProvider === "libsql") {
-    if (packageJson.dependencies) {
-      packageJson.dependencies.postgres = "";
-      packageJson.dependencies["@neondatabase/serverless"] = "";
-    }
-    packageJson.dependencies = {
-      ...packageJson.dependencies,
-      "@libsql/client": "latest"
-    };
-    const envPath = path.join(cwd, ".env");
-    if (await fs.pathExists(envPath)) {
-      let envContent = await fs.readFile(envPath, "utf-8");
-      envContent = envContent.replace(
-        /DATABASE_URL=.*postgres:\/\/.*/g,
-        "DATABASE_URL=libsql://[YOUR-DATABASE].turso.io"
-      );
-      await fs.writeFile(envPath, envContent);
-    }
-    const dbClientPaths = ["src/lib/db.ts", "src/db/client.ts", "src/database/index.ts"];
-    for (const memoryPath of dbClientPaths) {
-      const fullPath = path.join(cwd, memoryPath);
-      if (await fs.pathExists(fullPath)) {
-        let content = await fs.readFile(fullPath, "utf-8");
-        content = content.replace(
-          /import .*postgres.*/g,
-          'import { createClient } from "@libsql/client";'
-        );
-        content = content.replace(
-          /const .*= new Pool\(.*\)/g,
-          "const client = createClient({ url: process.env.DATABASE_URL! });"
-        );
-        await fs.writeFile(fullPath, content);
-        break;
-      }
-    }
-  }
-  await writePackageJSON(packageJsonPath, packageJson);
-  relinka("success", `Converted database provider from ${fromProvider} to ${toProvider}`);
-}

package/bin/impl/utils/codemods/convertDefinitions.d.ts

@@ -1 +0,0 @@
-export declare function convertTypeDefinitions(projectPath: string, targetStyle: "type" | "interface"): Promise<void>;

package/bin/impl/utils/codemods/convertDefinitions.js

@@ -1,42 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-export async function convertTypeDefinitions(projectPath, targetStyle) {
-  relinka("info", `Converting type definitions to ${targetStyle} style in ${projectPath}`);
-  const files = await glob("**/*.{ts,tsx}", {
-    cwd: path.resolve(projectPath)
-  });
-  for (const file of files) {
-    const filePath = path.join(projectPath, file);
-    const content = await fs.readFile(filePath, "utf-8");
-    let updatedContent = content;
-    if (targetStyle === "type") {
-      updatedContent = content.replace(
-        /interface\s+(\w+)(\s*extends\s*[^{]+)?\s*{([^}]*)}/g,
-        (_match, name, extends_, body) => {
-          const extendsClause = extends_ ? extends_.replace("extends", "&") : "";
-          return `type ${name} = ${extendsClause}{${body}}`;
-        }
-      );
-    } else {
-      updatedContent = content.replace(
-        /type\s+(\w+)\s*=\s*(?:{([^}]*)}|(\w+))/g,
-        (match, name, objectBody, simpleType) => {
-          if (simpleType) {
-            return match;
-          }
-          return `interface ${name} {${objectBody}}`;
-        }
-      );
-      updatedContent = updatedContent.replace(
-        /interface\s+(\w+)\s*{\s*}\s*&\s*(\w+)/g,
-        "interface $1 extends $2"
-      );
-    }
-    if (content !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, "utf-8");
-      relinka("info", `Updated type definitions in ${filePath}`);
-    }
-  }
-}

package/bin/impl/utils/codemods/convertImportStyle.d.ts

@@ -1 +0,0 @@
-export declare function convertImportStyle(projectPath: string, targetStyle: "import" | "require"): Promise<void>;

package/bin/impl/utils/codemods/convertImportStyle.js

@@ -1,30 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-export async function convertImportStyle(projectPath, targetStyle) {
-  relinka("info", `Converting to ${targetStyle} style in ${projectPath}`);
-  const files = await glob("**/*.{js,jsx,ts,tsx}", {
-    cwd: path.resolve(projectPath)
-  });
-  for (const file of files) {
-    const filePath = path.join(projectPath, file);
-    const content = await fs.readFile(filePath, "utf-8");
-    let updatedContent = content;
-    if (targetStyle === "import") {
-      updatedContent = content.replace(
-        /(?:const|let|var)\s*{\s*([^}]+)}\s*=\s*require\(['"]([^'"]+)['"]\)/g,
-        'import { $1 } from "$2"'
-      ).replace(
-        /(?:const|let|var)\s+(\w+)\s*=\s*require\(['"]([^'"]+)['"]\)/g,
-        'import $1 from "$2"'
-      );
-    } else {
-      updatedContent = content.replace(/import\s*{\s*([^}]+)}\s*from\s*['"]([^'"]+)['"]/g, "const { $1 } = require('$2')").replace(/import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g, "const $1 = require('$2')");
-    }
-    if (content !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, "utf-8");
-      relinka("info", `Updated import style in ${filePath}`);
-    }
-  }
-}

package/bin/impl/utils/codemods/convertJsToTs.d.ts

@@ -1 +0,0 @@
-export declare function convertJsToTs(cwd: string): Promise<void>;

package/bin/impl/utils/codemods/convertJsToTs.js

@@ -1,99 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { readPackageJSON, writePackageJSON } from "pkg-types";
-import { tsconfigJson } from "../../config/constants.js";
-function generateTypeDefinitions(content) {
-  let result = content;
-  result = result.replace(
-    /function\s+(\w+)\s*\((.*?)\)/g,
-    (_, name, params) => {
-      const typedParams = params.split(",").map((p) => p.trim()).filter(Boolean).map((p) => `${p}: any`);
-      return `function ${name}(${typedParams.join(", ")})`;
-    }
-  );
-  result = result.replace(/function\s+(\w+)\s*\((.*?)\)\s*{/g, (match) => `${match}: any`);
-  result = result.replace(
-    /(const|let|var)\s+(\w+)\s*=/g,
-    (_, dec, name) => `${dec} ${name}: any =`
-  );
-  result = result.replace(/class\s+(\w+)\s*{([^}]+)}/g, (_, name, body) => {
-    const typedBody = body.replace(
-      /(\w+)\s*=/g,
-      (_2, propName) => `${propName}: any =`
-    );
-    return `class ${name} {${typedBody}}`;
-  });
-  result = result.replace(
-    /const\s+(\w+)\s*=\s*{([^}]+)}/g,
-    (_, name, props) => {
-      const interfaceProps = props.split(",").map((p) => p.trim()).filter(Boolean).map((p) => {
-        const [propName] = p.split(":");
-        return `  ${propName}: any;`;
-      });
-      return `interface ${name}Type {
-${interfaceProps.join("\n")}
-}
-const ${name}: ${name}Type = {${props}}`;
-    }
-  );
-  return result;
-}
-export async function convertJsToTs(cwd) {
-  const jsFiles = await fs.readdir(cwd, { recursive: true });
-  const jsFilePaths = jsFiles.filter((file) => typeof file === "string").filter(
-    (file) => file.endsWith(".js") && !file.endsWith(".config.js") && !file.endsWith(".test.js") && !file.includes("node_modules")
-  );
-  for (const jsFile of jsFilePaths) {
-    const fullPath = path.join(cwd, jsFile);
-    const tsFile = jsFile.replace(/\.js$/, ".ts");
-    const tsPath = path.join(cwd, tsFile);
-    try {
-      const content = await fs.readFile(fullPath, "utf-8");
-      const tsContent = generateTypeDefinitions(content);
-      await fs.writeFile(tsPath, tsContent);
-      relinka("success", `Converted ${jsFile} to TypeScript`);
-      await fs.remove(fullPath);
-    } catch (error) {
-      relinka(
-        "error",
-        `Failed to convert ${jsFile}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  const tsconfigPath = path.join(cwd, tsconfigJson);
-  if (!await fs.pathExists(tsconfigPath)) {
-    const tsconfig = {
-      compilerOptions: {
-        target: "ES2020",
-        module: "ESNext",
-        moduleResolution: "node",
-        esModuleInterop: true,
-        strict: true,
-        skipLibCheck: true,
-        forceConsistentCasingInFileNames: true,
-        outDir: "dist"
-      },
-      include: ["src/**/*"],
-      exclude: ["node_modules", "dist"]
-    };
-    await fs.writeJson(tsconfigPath, tsconfig, { spaces: 2 });
-    relinka("success", "Created tsconfig.json");
-  }
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (await fs.pathExists(packageJsonPath)) {
-    const packageJson = await readPackageJSON(packageJsonPath);
-    packageJson.devDependencies = {
-      ...packageJson.devDependencies,
-      typescript: "latest",
-      "@types/node": "latest"
-    };
-    packageJson.scripts = {
-      ...packageJson.scripts,
-      build: "tsc",
-      "type-check": "tsc --noEmit"
-    };
-    await writePackageJSON(packageJsonPath, packageJson);
-    relinka("success", "Updated package.json with TypeScript configuration");
-  }
-}

package/bin/impl/utils/codemods/convertQuoteStyle.d.ts

@@ -1 +0,0 @@
-export declare function convertQuoteStyle(projectPath: string, targetQuoteStyle: "single" | "double"): Promise<void>;

package/bin/impl/utils/codemods/convertQuoteStyle.js

@@ -1,31 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-export async function convertQuoteStyle(projectPath, targetQuoteStyle) {
-  relinka("info", `Converting quotes to ${targetQuoteStyle} quotes in ${projectPath}`);
-  const files = await glob("**/*.{js,jsx,ts,tsx}", {
-    cwd: path.resolve(projectPath)
-  });
-  for (const file of files) {
-    const filePath = path.join(projectPath, file);
-    const content = await fs.readFile(filePath, "utf-8");
-    const updatedContent = content.replace(
-      /(['"])((?:\\\1|(?!\1).)*?)\1/g,
-      (_match, _quote, content2) => {
-        const targetQuote = targetQuoteStyle === "single" ? "'" : '"';
-        const escapedContent = content2.replace(new RegExp(targetQuote, "g"), `\\${targetQuote}`);
-        const otherQuote = targetQuoteStyle === "single" ? '"' : "'";
-        const unescapedContent = escapedContent.replace(
-          new RegExp(`\\\\${otherQuote}`, "g"),
-          otherQuote
-        );
-        return `${targetQuote}${unescapedContent}${targetQuote}`;
-      }
-    );
-    if (content !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, "utf-8");
-      relinka("info", `Updated quotes in ${filePath}`);
-    }
-  }
-}

package/bin/impl/utils/codemods/convertRuntime.d.ts

@@ -1 +0,0 @@
-export declare function convertRuntime(projectPath: string, targetRuntime: "bun" | "deno"): Promise<void>;

package/bin/impl/utils/codemods/convertRuntime.js

@@ -1,116 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { destr } from "destr";
-import { glob } from "tinyglobby";
-import { tsconfigJson } from "../../config/constants.js";
-const RUNTIME_REPLACEMENTS = {
-  bun: {
-    // Node.js fs to Bun's fs
-    'import fs from "@reliverse/relifso"': 'import { readFile, writeFile, readdir, mkdir, stat } from "@reliverse/relifso"',
-    'import fs from "fs/promises"': 'import { readFile, writeFile, readdir, mkdir, stat } from "@reliverse/relifso"',
-    "import { promises as fs }": 'import { readFile, writeFile, readdir, mkdir, stat } from "@reliverse/relifso"',
-    // Node.js path to Bun's path
-    'import path from "path"': 'import { join, resolve, dirname, basename } from "path"',
-    // Node.js crypto to Bun's crypto
-    'import crypto from "uncrypto"': 'import { crypto } from "bun"',
-    // Node.js buffer to Bun's buffer
-    "import { Buffer }": "// Bun has Buffer globally available",
-    // Node.js process to Bun's process
-    "process.env": "Bun.env",
-    "process.cwd()": "import.meta.dir"
-  },
-  deno: {
-    // Node.js fs to Deno's fs
-    'import fs from "@reliverse/relifso"': 'import * as fs from "https://deno.land/std/fs/mod.ts"',
-    'import fs from "fs/promises"': 'import * as fs from "https://deno.land/std/fs/mod.ts"',
-    "import { promises as fs }": 'import * as fs from "https://deno.land/std/fs/mod.ts"',
-    // Node.js path to Deno's path
-    'import path from "path"': 'import * as path from "https://deno.land/std/path/mod.ts"',
-    // Node.js crypto to Deno's crypto
-    'import crypto from "uncrypto"': 'import * as crypto from "https://deno.land/std/crypto/mod.ts"',
-    // Node.js buffer to Deno's buffer
-    "import { Buffer }": 'import { Buffer } from "https://deno.land/std/io/buffer.ts"',
-    // Node.js process to Deno
-    "process.env": "Deno.env.toObject()",
-    "process.cwd()": "Deno.cwd()"
-  }
-};
-export async function convertRuntime(projectPath, targetRuntime) {
-  relinka("info", `Converting Node.js code to ${targetRuntime} in ${projectPath}`);
-  const files = await glob("**/*.{js,jsx,ts,tsx}", {
-    cwd: path.resolve(projectPath)
-  });
-  const runtimeReplacements = RUNTIME_REPLACEMENTS[targetRuntime];
-  for (const file of files) {
-    const filePath = path.join(projectPath, file);
-    const content = await fs.readFile(filePath, "utf-8");
-    let updatedContent = content;
-    for (const [nodePattern, runtimePattern] of Object.entries(runtimeReplacements)) {
-      updatedContent = updatedContent.replace(
-        new RegExp(nodePattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
-        runtimePattern
-      );
-    }
-    if (targetRuntime === "bun") {
-      if (file === "package.json") {
-        const packageJson = destr(updatedContent);
-        if (packageJson?.scripts) {
-          for (const [key, value] of Object.entries(packageJson.scripts)) {
-            if (typeof value === "string") {
-              packageJson.scripts[key] = value.replace(/^node\s/, "bun ").replace(/^ts-node\s/, "bun ");
-            }
-          }
-          updatedContent = JSON.stringify(packageJson, null, 2);
-        }
-      }
-    }
-    if (targetRuntime === "deno") {
-      if (file === "package.json") {
-        await fs.writeFile(
-          path.join(projectPath, "deno.json"),
-          JSON.stringify(
-            {
-              compilerOptions: {
-                allowJs: true,
-                lib: ["deno.window"]
-              },
-              importMap: "import_map.json"
-            },
-            null,
-            2
-          )
-        );
-        const packageJson = destr(content);
-        const importMap = {
-          imports: {}
-        };
-        if (packageJson?.dependencies) {
-          for (const dep of Object.keys(packageJson.dependencies)) {
-            importMap.imports[dep] = `https://esm.sh/${dep}`;
-          }
-        }
-        await fs.writeFile(
-          path.join(projectPath, "import_map.json"),
-          JSON.stringify(importMap, null, 2)
-        );
-      }
-    }
-    if (content !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, "utf-8");
-      relinka("info", `Updated runtime code in ${filePath}`);
-    }
-  }
-  if (targetRuntime === "bun") {
-    const tsconfigPath = path.join(projectPath, tsconfigJson);
-    if (await fs.pathExists(tsconfigPath)) {
-      const tsconfig = destr(await fs.readFile(tsconfigPath, "utf-8"));
-      tsconfig.compilerOptions = {
-        ...tsconfig.compilerOptions,
-        types: [...tsconfig.compilerOptions?.types ?? [], "bun-types"]
-      };
-      await fs.writeJSON(tsconfigPath, tsconfig, { spaces: 2 });
-    }
-  }
-  relinka("success", `Converted project to ${targetRuntime}`);
-}

package/bin/impl/utils/codemods/convertToMonorepo.d.ts

@@ -1,2 +0,0 @@
-import type { MonorepoType } from "../../types/mod.js";
-export declare function convertToMonorepo(projectPath: string, type: MonorepoType, packages?: string[], sharedPackages?: string[]): Promise<void>;