@10stars/config 11.0.2 → 11.0.3

package/package.json

@@ -4,7 +4,7 @@
     "access": "public"
   },
   "name": "@10stars/config",
-  "version": "11.0.2",
+  "version": "11.0.3",
   "author": "10stars.dev <web@alexandrov.co> (https://alexandrov.co)",
   "license": "MIT",
   "bin": {

package/src/index.ts

@@ -1,12 +1,12 @@
 import { execSync } from "node:child_process"
 import { join } from "node:path"
 
-import { linkPackages } from "./link-packages"
+import { linkPackages, checkIsMonorepo } from "./link-packages"
 
 const cwd = process.env.PWD!
 
 interface Config {
-  linkPackages: { relativePath: string; isMonorepo?: true }[]
+  linkPackages: string[]
 }
 
 const exec = (cmd: string) => {
@@ -21,13 +21,8 @@ const getConfig = async (): Promise<Config> =>
     )
   })
 
-const checkIsMonorepo = async () => {
-  const pkgJson = await import(join(cwd, "package.json"))
-  return Boolean(pkgJson.workspaces)
-}
-
 const getESLintPaths = async () => {
-  const isMonorepo = await checkIsMonorepo()
+  const isMonorepo = await checkIsMonorepo(cwd)
   return isMonorepo ? `*/src */*.ts` : `src *.ts`
 }
 
@@ -47,7 +42,7 @@ const actions = {
   format: {
     info: "Format code",
     action: async () => {
-      const isMonorepo = await checkIsMonorepo()
+      const isMonorepo = await checkIsMonorepo(cwd)
       exec(
         `prettier -l --write './${isMonorepo ? `*/` : ``}src/**/*.{t,j}s{x,}'`,
       )

package/src/link-packages.ts

@@ -1,76 +1,75 @@
-import {
-  lstat,
-  realpath,
-  rm,
-  unlink,
-  symlink as symlinkRaw,
-  readdir,
-} from "node:fs/promises"
-import { join } from "node:path"
+import fs from "node:fs/promises"
+import path from "node:path"
 
 import type * as TF from "type-fest"
 
 const symlink = async (pathTarget: string, pathSymlink: string) => {
-  const stats = await lstat(pathSymlink).catch(() => null)
+  const stats = await fs.lstat(pathSymlink).catch(() => null)
   if (!stats) return
 
   if (stats.isSymbolicLink()) {
-    const symlinkRealpath = await realpath(pathSymlink).catch(() => null)
+    const symlinkRealpath = await fs.realpath(pathSymlink).catch(() => null)
     if (pathTarget === symlinkRealpath) return
   }
 
-  if (stats.isDirectory()) await rm(pathSymlink, { recursive: true })
-  else await unlink(pathSymlink)
+  if (stats.isDirectory()) await fs.rm(pathSymlink, { recursive: true })
+  else await fs.unlink(pathSymlink)
 
-  await symlinkRaw(pathTarget, pathSymlink)
+  await fs.symlink(pathTarget, pathSymlink)
 }
 
-export const linkPackages = async (
-  cwd: string,
-  packagesToLink: { relativePath: string; isMonorepo?: boolean }[],
-) => {
+export const checkIsMonorepo = async (pathPkg: string) => {
+  const pkgJson = await import(path.join(pathPkg, "package.json"))
+  return Boolean(pkgJson.workspaces)
+}
+
+export const linkPackages = async (cwd: string, packagesToLink: string[]) => {
   console.info(`Linking local packages`)
 
   const linkPackage = async (pathPkg: string) => {
     const pkgJson: TF.PackageJson = await import(
-      join(pathPkg, `package.json`)
+      path.join(pathPkg, `package.json`)
     ).catch(() => null)
     if (!pkgJson) return
 
     const [orgName, pkgName] = pkgJson.name!.split(`/`)
 
-    const pathSymlink = join(cwd, `node_modules`, orgName, pkgName)
+    const pathSymlink = path.join(cwd, `node_modules`, orgName, pkgName)
     return symlink(pathPkg, pathSymlink)
   }
 
   const promises: Promise<unknown>[] = []
-  for (const packageToLink of packagesToLink) {
-    if (!packageToLink.isMonorepo) {
-      promises.push(linkPackage(join(cwd, packageToLink.relativePath)))
-      continue
-    }
-
-    const files = await readdir(packageToLink.relativePath, {
-      withFileTypes: true,
-    }).catch(() => null)
-    if (!files) continue
-
-    const directories = files.filter((v) => v.isDirectory()).map((v) => v.name)
-    const packages = (
-      await Promise.all(
-        directories.map(async (v) => {
-          const pathPkg = join(cwd, packageToLink.relativePath, v)
-          const pkgJson: TF.PackageJson = await import(
-            join(pathPkg, `package.json`)
-          ).catch(() => null)
-          if (pkgJson) return v
-        }),
-      )
-    ).filter(Boolean)
-    for (const pkg of packages) {
-      const relativePathToPkg = join(cwd, packageToLink.relativePath, pkg!)
-      promises.push(linkPackage(relativePathToPkg))
-    }
+  for (const relativePath of packagesToLink) {
+    const pathPkg = path.join(cwd, relativePath)
+    const promise = checkIsMonorepo(pathPkg).then(async (isMonorepo) => {
+      if (!isMonorepo) return linkPackage(pathPkg)
+
+      const files = await fs
+        .readdir(relativePath, { withFileTypes: true })
+        .catch(() => null)
+      if (!files) return
+
+      const directories = files
+        .filter((v) => v.isDirectory())
+        .map((v) => v.name)
+      const packages = (
+        await Promise.all(
+          directories.map(async (v) => {
+            const pathPkg = path.join(cwd, relativePath, v)
+            const pkgJson: TF.PackageJson = await import(
+              path.join(pathPkg, `package.json`)
+            ).catch(() => null)
+            if (pkgJson) return v
+          }),
+        )
+      ).filter(Boolean)
+      for (const pkg of packages) {
+        const relativePathToPkg = path.join(cwd, relativePath, pkg!)
+        promises.push(linkPackage(relativePathToPkg))
+      }
+    })
+
+    promises.push(promise)
   }
 
   await Promise.all(promises)