@reliverse/dler 1.7.8 → 1.7.9

package/bin/libs/sdk/sdk-impl/cfg/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.8";
+const version = "1.7.9";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/utils/utils-fs.js

@@ -186,6 +186,8 @@ export async function writeFileSafe(filePath, content, reason) {
 export async function copyInsteadOfBuild(rootDir, outDir, patterns) {
   if (!patterns.length) return;
   relinka("info", "Copying files/folders that should not be built...");
+  const normalizedRootDir = path.normalize(rootDir);
+  const normalizedOutDir = path.normalize(outDir);
   const SENSITIVE_PATTERNS = [
     "node_modules",
     ".git",
@@ -209,29 +211,64 @@ export async function copyInsteadOfBuild(rootDir, outDir, patterns) {
   const RETRY_DELAY = 1e3;
   async function copyWithRetry(source, dest, relativePath, retryCount = 0) {
     try {
-      await fs.mkdir(path.dirname(dest), { recursive: true });
+      const normalizedSource = path.normalize(source);
+      const normalizedDest = path.normalize(dest);
+      if (!normalizedSource || !normalizedDest) {
+        throw new Error(`Invalid paths: source=${normalizedSource}, dest=${normalizedDest}`);
+      }
+      const destDir = path.dirname(normalizedDest);
+      try {
+        await fs.mkdir(destDir, { recursive: true });
+      } catch (error) {
+        if (error.code !== "EEXIST") {
+          throw new Error(`Failed to create directory ${destDir}: ${error.message}`);
+        }
+      }
       try {
-        await fs.access(source);
-      } catch {
-        relinka("warn", `Source not accessible: ${relativePath}`);
+        await fs.access(normalizedSource);
+      } catch (error) {
+        relinka("warn", `Source not accessible: ${relativePath} (${error.message})`);
         return;
       }
-      if (await fs.pathExists(dest)) {
-        relinka("verbose", `Removing existing destination: ${dest}`);
-        await fs.remove(dest);
+      if (await fs.pathExists(normalizedDest)) {
+        try {
+          relinka("verbose", `Removing existing destination: ${normalizedDest}`);
+          await fs.remove(normalizedDest);
+        } catch (error) {
+          if (error.code === "EBUSY" && retryCount < MAX_RETRIES) {
+            relinka("warn", `Destination ${normalizedDest} is busy, retrying in ${RETRY_DELAY}ms`);
+            await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
+            return copyWithRetry(normalizedSource, normalizedDest, relativePath, retryCount + 1);
+          }
+          throw new Error(
+            `Failed to remove existing destination ${normalizedDest}: ${error.message}`
+          );
+        }
+      }
+      try {
+        await fs.cp(normalizedSource, normalizedDest, {
+          recursive: true,
+          dereference: true,
+          force: true,
+          errorOnExist: false
+        });
+        relinka("verbose", `Copied instead of building: ${relativePath}`);
+      } catch (error) {
+        if (error.code === "EBUSY" && retryCount < MAX_RETRIES) {
+          relinka(
+            "warn",
+            `File ${relativePath} is busy, retrying in ${RETRY_DELAY}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`
+          );
+          await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
+          return copyWithRetry(normalizedSource, normalizedDest, relativePath, retryCount + 1);
+        }
+        throw new Error(`Failed to copy ${relativePath}: ${error.message}`);
       }
-      await fs.cp(source, dest, {
-        recursive: true,
-        dereference: true,
-        force: true,
-        errorOnExist: false
-      });
-      relinka("verbose", `Copied instead of building: ${relativePath}`);
     } catch (error) {
-      if (error.code === "EBUSY" && retryCount < MAX_RETRIES) {
+      if (retryCount < MAX_RETRIES) {
         relinka(
           "warn",
-          `File ${relativePath} is busy, retrying in ${RETRY_DELAY}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`
+          `Error copying ${relativePath}, retrying in ${RETRY_DELAY}ms (attempt ${retryCount + 1}/${MAX_RETRIES}): ${error.message}`
         );
         await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
         return copyWithRetry(source, dest, relativePath, retryCount + 1);
@@ -245,21 +282,29 @@ export async function copyInsteadOfBuild(rootDir, outDir, patterns) {
     const batchPatterns = filteredPatterns.slice(i, i + BATCH_SIZE);
     const batchCopyTasks = [];
     for (const pattern of batchPatterns) {
-      const matches = await glob(pattern, {
-        cwd: rootDir,
-        dot: true,
-        absolute: true,
-        onlyFiles: false,
-        followSymbolicLinks: false
-      });
-      for (const match of matches) {
-        const relativePath = path.relative(rootDir, match);
-        const destPath = path.resolve(outDir, relativePath);
-        batchCopyTasks.push(copyWithRetry(match, destPath, relativePath));
+      try {
+        const matches = await glob(pattern, {
+          cwd: normalizedRootDir,
+          dot: true,
+          absolute: true,
+          onlyFiles: false,
+          followSymbolicLinks: false
+        });
+        for (const match of matches) {
+          const relativePath = path.relative(normalizedRootDir, match);
+          const destPath = path.resolve(normalizedOutDir, relativePath);
+          batchCopyTasks.push(copyWithRetry(match, destPath, relativePath));
+        }
+      } catch (error) {
+        relinka("error", `Failed to process pattern ${pattern}: ${error.message}`);
       }
     }
     if (batchCopyTasks.length > 0) {
-      await Promise.all(batchCopyTasks);
+      try {
+        await Promise.all(batchCopyTasks);
+      } catch (error) {
+        relinka("error", `Batch processing failed: ${error.message}`);
+      }
       if (i + BATCH_SIZE < filteredPatterns.length) {
         await new Promise((resolve) => setTimeout(resolve, BATCH_DELAY));
       }

package/package.json

@@ -4,7 +4,7 @@
     "@reliverse/pathkit": "^1.2.1",
     "@reliverse/reglob": "^1.0.0",
     "@reliverse/relico": "^1.1.2",
-    "@reliverse/relifso": "^1.4.4",
+    "@reliverse/relifso": "^1.4.5",
     "@reliverse/relinka": "^1.4.7",
     "@reliverse/rempts": "^1.7.17",
     "@rollup/plugin-alias": "^5.1.1",
@@ -44,7 +44,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.8",
+  "version": "1.7.9",
   "keywords": [
     "reliverse",
     "cli",