@simplysm/sd-cli 13.0.75 → 13.0.77

package/src/sd-config.types.ts

@@ -8,13 +8,20 @@ export type BuildTarget = "node" | "browser" | "neutral";
 
 //#region Publish configuration types
 
+/**
+ * npm registry publish configuration
+ */
+export interface SdNpmPublishConfig {
+  type: "npm";
+}
+
 /**
  * Package publish configuration
- * - "npm": deploy to npm registry
+ * - SdNpmPublishConfig: deploy to npm registry
  * - SdLocalDirectoryPublishConfig: copy to local directory
  * - SdStoragePublishConfig: upload to FTP/FTPS/SFTP server
  */
-export type SdPublishConfig = "npm" | SdLocalDirectoryPublishConfig | SdStoragePublishConfig;
+export type SdPublishConfig = SdNpmPublishConfig | SdLocalDirectoryPublishConfig | SdStoragePublishConfig;
 
 /**
  * Local directory publish configuration
@@ -249,7 +256,7 @@ export interface SdConfigParams {
   /** development mode flag */
   dev: boolean;
   /** additional options (from CLI's -o flag) */
-  opt: string[];
+  options: string[];
 }
 
 /**

package/src/utils/copy-public.ts

@@ -1,12 +1,8 @@
 import path from "path";
 import {
-  fsCopy,
-  fsMkdir,
-  fsRm,
-  fsGlob,
+  fsx,
+  pathx,
   FsWatcher,
-  fsExists,
-  pathIsChildPath,
 } from "@simplysm/core-node";
 
 /**
@@ -18,30 +14,30 @@ import {
  */
 export async function copyPublicFiles(pkgDir: string, includeDev: boolean): Promise<void> {
   const distDir = path.join(pkgDir, "dist");
-  await fsMkdir(distDir);
+  await fsx.mkdir(distDir);
 
   // Copy public/
   const publicDir = path.join(pkgDir, "public");
-  if (await fsExists(publicDir)) {
-    const files = await fsGlob("**/*", { cwd: publicDir, absolute: true });
+  if (await fsx.exists(publicDir)) {
+    const files = await fsx.glob("**/*", { cwd: publicDir, absolute: true });
     for (const file of files) {
       const relativePath = path.relative(publicDir, file);
       const distPath = path.join(distDir, relativePath);
-      await fsMkdir(path.dirname(distPath));
-      await fsCopy(file, distPath);
+      await fsx.mkdir(path.dirname(distPath));
+      await fsx.copy(file, distPath);
     }
   }
 
   // Copy public-dev/ (overlay: overwrites public/)
   if (includeDev) {
     const publicDevDir = path.join(pkgDir, "public-dev");
-    if (await fsExists(publicDevDir)) {
-      const files = await fsGlob("**/*", { cwd: publicDevDir, absolute: true });
+    if (await fsx.exists(publicDevDir)) {
+      const files = await fsx.glob("**/*", { cwd: publicDevDir, absolute: true });
       for (const file of files) {
         const relativePath = path.relative(publicDevDir, file);
         const distPath = path.join(distDir, relativePath);
-        await fsMkdir(path.dirname(distPath));
-        await fsCopy(file, distPath);
+        await fsx.mkdir(path.dirname(distPath));
+        await fsx.copy(file, distPath);
       }
     }
   }
@@ -68,10 +64,10 @@ export async function watchPublicFiles(
 
   // Collect watch target paths
   const watchPaths: string[] = [];
-  if (await fsExists(publicDir)) {
+  if (await fsx.exists(publicDir)) {
     watchPaths.push(path.join(publicDir, "**/*"));
   }
-  if (includeDev && (await fsExists(publicDevDir))) {
+  if (includeDev && (await fsx.exists(publicDevDir))) {
     watchPaths.push(path.join(publicDevDir, "**/*"));
   }
 
@@ -85,7 +81,7 @@ export async function watchPublicFiles(
     for (const { event, path: filePath } of changes) {
       // Determine which source directory the change came from
       let sourceDir: string;
-      if (pathIsChildPath(filePath, publicDevDir)) {
+      if (pathx.isChildPath(filePath, publicDevDir)) {
         sourceDir = publicDevDir;
       } else {
         sourceDir = publicDir;
@@ -98,30 +94,30 @@ export async function watchPublicFiles(
         // If deleted from public, don't delete if same file exists in public-dev
         if (sourceDir === publicDir && includeDev) {
           const devOverride = path.join(publicDevDir, relPath);
-          if (await fsExists(devOverride)) {
+          if (await fsx.exists(devOverride)) {
             continue;
           }
         }
         // If deleted from public-dev, restore from public if it exists (fallback restore)
         if (sourceDir === publicDevDir && includeDev) {
           const publicFallback = path.join(publicDir, relPath);
-          if (await fsExists(publicFallback)) {
-            await fsMkdir(path.dirname(distPath));
-            await fsCopy(publicFallback, distPath);
+          if (await fsx.exists(publicFallback)) {
+            await fsx.mkdir(path.dirname(distPath));
+            await fsx.copy(publicFallback, distPath);
             continue;
           }
         }
-        await fsRm(distPath);
+        await fsx.rm(distPath);
       } else if (event === "add" || event === "change") {
         // If changed in public, skip if same file exists in public-dev (overlay takes priority)
         if (sourceDir === publicDir && includeDev) {
           const devOverride = path.join(publicDevDir, relPath);
-          if (await fsExists(devOverride)) {
+          if (await fsx.exists(devOverride)) {
             continue;
           }
         }
-        await fsMkdir(path.dirname(distPath));
-        await fsCopy(filePath, distPath);
+        await fsx.mkdir(path.dirname(distPath));
+        await fsx.copy(filePath, distPath);
       }
     }
   });

package/src/utils/copy-src.ts

@@ -1,5 +1,5 @@
 import path from "path";
-import { fsGlob, fsCopy, fsMkdir, fsRm, FsWatcher } from "@simplysm/core-node";
+import { fsx, FsWatcher } from "@simplysm/core-node";
 
 /**
  * Copy files matching glob patterns from src/ to dist/
@@ -13,12 +13,12 @@ export async function copySrcFiles(pkgDir: string, patterns: string[]): Promise<
   const distDir = path.join(pkgDir, "dist");
 
   for (const pattern of patterns) {
-    const files = await fsGlob(pattern, { cwd: srcDir, absolute: true });
+    const files = await fsx.glob(pattern, { cwd: srcDir, absolute: true });
     for (const file of files) {
       const relativePath = path.relative(srcDir, file);
       const distPath = path.join(distDir, relativePath);
-      await fsMkdir(path.dirname(distPath));
-      await fsCopy(file, distPath);
+      await fsx.mkdir(path.dirname(distPath));
+      await fsx.copy(file, distPath);
     }
   }
 }
@@ -48,10 +48,10 @@ export async function watchCopySrcFiles(pkgDir: string, patterns: string[]): Pro
       const distPath = path.join(distDir, relPath);
 
       if (event === "unlink") {
-        await fsRm(distPath);
+        await fsx.rm(distPath);
       } else if (event === "add" || event === "change") {
-        await fsMkdir(path.dirname(distPath));
-        await fsCopy(filePath, distPath);
+        await fsx.mkdir(path.dirname(distPath));
+        await fsx.copy(filePath, distPath);
       }
     }
   });

package/src/utils/esbuild-config.ts

@@ -165,28 +165,14 @@ interface PkgJson {
 }
 
 /**
- * Collect uninstalled optional peer deps from dependency tree
- *
- * For server builds (bundle: true), specify uninstalled optional peer dependencies
- * as esbuild externals to prevent build failures
+ * Recursively scan dependency tree and collect externals based on predicate
  */
-export function collectUninstalledOptionalPeerDeps(pkgDir: string): string[] {
-  const external = new Set<string>();
-  const visited = new Set<string>();
-
-  const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
-  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
-    scanOptionalPeerDeps(dep, pkgDir, external, visited);
-  }
-
-  return [...external];
-}
-
-function scanOptionalPeerDeps(
+function scanDependencyTree(
   pkgName: string,
   resolveDir: string,
   external: Set<string>,
   visited: Set<string>,
+  collector: (pkgName: string, depDir: string, pkgJson: PkgJson) => string[],
 ): void {
   if (visited.has(pkgName)) return;
   visited.add(pkgName);
@@ -203,23 +189,50 @@ function scanOptionalPeerDeps(
   const depDir = path.dirname(pkgJsonPath);
   const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8")) as PkgJson;
 
-  if (pkgJson.peerDependenciesMeta != null) {
-    const peerDeps = pkgJson.peerDependencies ?? {};
-    const depReq = createRequire(path.join(depDir, "noop.js"));
-    for (const [name, meta] of Object.entries(pkgJson.peerDependenciesMeta)) {
-      if (meta.optional === true && name in peerDeps) {
-        try {
-          depReq.resolve(name);
-        } catch {
-          external.add(name);
-        }
-      }
-    }
+  // Collect packages marked as external by predicate
+  const toExternal = collector(pkgName, depDir, pkgJson);
+  for (const name of toExternal) {
+    external.add(name);
+  }
+
+  // Recursively traverse sub-dependencies
+  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+    scanDependencyTree(dep, depDir, external, visited, collector);
   }
+}
+
+/**
+ * Collect uninstalled optional peer deps from dependency tree
+ *
+ * For server builds (bundle: true), specify uninstalled optional peer dependencies
+ * as esbuild externals to prevent build failures
+ */
+export function collectUninstalledOptionalPeerDeps(pkgDir: string): string[] {
+  const external = new Set<string>();
+  const visited = new Set<string>();
 
+  const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
   for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
-    scanOptionalPeerDeps(dep, depDir, external, visited);
+    scanDependencyTree(dep, pkgDir, external, visited, (_pkgName, depDir, depPkgJson) => {
+      const found: string[] = [];
+      if (depPkgJson.peerDependenciesMeta != null) {
+        const peerDeps = depPkgJson.peerDependencies ?? {};
+        const depReq = createRequire(path.join(depDir, "noop.js"));
+        for (const [name, meta] of Object.entries(depPkgJson.peerDependenciesMeta)) {
+          if (meta.optional === true && name in peerDeps) {
+            try {
+              depReq.resolve(name);
+            } catch {
+              found.push(name);
+            }
+          }
+        }
+      }
+      return found;
+    });
   }
+
+  return [...external];
 }
 
 //#endregion
@@ -238,42 +251,17 @@ export function collectNativeModuleExternals(pkgDir: string): string[] {
 
   const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
   for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
-    scanNativeModules(dep, pkgDir, external, visited);
+    scanDependencyTree(dep, pkgDir, external, visited, (pkgName, depDir, _pkgJson) => {
+      const found: string[] = [];
+      // Detect native modules by checking for binding.gyp
+      if (existsSync(path.join(depDir, "binding.gyp"))) {
+        found.push(pkgName);
+      }
+      return found;
+    });
   }
 
   return [...external];
 }
 
-function scanNativeModules(
-  pkgName: string,
-  resolveDir: string,
-  external: Set<string>,
-  visited: Set<string>,
-): void {
-  if (visited.has(pkgName)) return;
-  visited.add(pkgName);
-
-  const req = createRequire(path.join(resolveDir, "noop.js"));
-
-  let pkgJsonPath: string;
-  try {
-    pkgJsonPath = req.resolve(`${pkgName}/package.json`);
-  } catch {
-    return;
-  }
-
-  const depDir = path.dirname(pkgJsonPath);
-
-  // Detect native modules by checking for binding.gyp
-  if (existsSync(path.join(depDir, "binding.gyp"))) {
-    external.add(pkgName);
-  }
-
-  // Recursively traverse sub-dependencies
-  const depPkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8")) as PkgJson;
-  for (const dep of Object.keys(depPkgJson.dependencies ?? {})) {
-    scanNativeModules(dep, depDir, external, visited);
-  }
-}
-
 //#endregion

package/src/utils/replace-deps.ts

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import { glob } from "glob";
 import { consola } from "consola";
-import { fsCopy, fsMkdir, fsRm, FsWatcher, pathIsChildPath } from "@simplysm/core-node";
+import { fsx, pathx, FsWatcher } from "@simplysm/core-node";
 
 /**
  * Match glob patterns from replaceDeps config with target package list
@@ -249,7 +249,7 @@ export async function setupReplaceDeps(
   for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
     try {
       // Overwrite-copy source files to actualTargetPath (maintain existing directory, preserve symlinks)
-      await fsCopy(resolvedSourcePath, actualTargetPath, replaceDepsCopyFilter);
+      await fsx.copy(resolvedSourcePath, actualTargetPath, replaceDepsCopyFilter);
 
       setupCount += 1;
     } catch (err) {
@@ -300,7 +300,7 @@ export async function watchReplaceDeps(
         // Filter excluded items: basename match or path within excluded directory
         if (
           EXCLUDED_NAMES.has(path.basename(changedPath)) ||
-          excludedPaths.some((ep) => pathIsChildPath(changedPath, ep))
+          excludedPaths.some((ep) => pathx.isChildPath(changedPath, ep))
         ) {
           continue;
         }
@@ -327,14 +327,14 @@ export async function watchReplaceDeps(
               // Check if source is directory or file
               const stat = await fs.promises.stat(changedPath);
               if (stat.isDirectory()) {
-                await fsMkdir(destPath);
+                await fsx.mkdir(destPath);
               } else {
-                await fsMkdir(path.dirname(destPath));
-                await fsCopy(changedPath, destPath, replaceDepsCopyFilter);
+                await fsx.mkdir(path.dirname(destPath));
+                await fsx.copy(changedPath, destPath, replaceDepsCopyFilter);
               }
             } else {
               // Source was deleted → delete target
-              await fsRm(destPath);
+              await fsx.rm(destPath);
             }
           } catch (err) {
             logger.error(

package/src/utils/sd-config.ts

@@ -1,7 +1,7 @@
 import path from "path";
 import { createJiti } from "jiti";
 import { SdError } from "@simplysm/core-common";
-import { fsExists } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import type { SdConfig, SdConfigParams } from "../sd-config.types";
 
 /**
@@ -12,7 +12,7 @@ import type { SdConfig, SdConfigParams } from "../sd-config.types";
 export async function loadSdConfig(params: SdConfigParams): Promise<SdConfig> {
   const sdConfigPath = path.resolve(params.cwd, "sd.config.ts");
 
-  if (!(await fsExists(sdConfigPath))) {
+  if (!(await fsx.exists(sdConfigPath))) {
     throw new SdError(`sd.config.ts file not found: ${sdConfigPath}`);
   }
 

package/src/utils/template.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import Handlebars from "handlebars";
-import { fsCopy, fsMkdir, fsRead, fsReaddir, fsStat, fsWrite } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 
 /**
  * Recursively traverse template directory, render with Handlebars, and generate files
@@ -20,13 +20,13 @@ export async function renderTemplateDir(
   context: Record<string, unknown>,
   dirReplacements?: Record<string, string>,
 ): Promise<void> {
-  await fsMkdir(destDir);
+  await fsx.mkdir(destDir);
 
-  const entries = await fsReaddir(srcDir);
+  const entries = await fsx.readdir(srcDir);
 
   for (const entry of entries) {
     const srcPath = path.join(srcDir, entry);
-    const stat = await fsStat(srcPath);
+    const stat = await fsx.stat(srcPath);
 
     if (stat.isDirectory()) {
       // Apply directory name substitution
@@ -39,7 +39,7 @@ export async function renderTemplateDir(
       );
     } else if (entry.endsWith(".hbs")) {
       // Render Handlebars template
-      const source = await fsRead(srcPath);
+      const source = await fsx.read(srcPath);
       const template = Handlebars.compile(source, { noEscape: true });
       const result = template(context);
 
@@ -47,10 +47,10 @@ export async function renderTemplateDir(
       if (result.trim().length === 0) continue;
 
       const destFileName = entry.slice(0, -4); // Remove .hbs
-      await fsWrite(path.join(destDir, destFileName), result);
+      await fsx.write(path.join(destDir, destFileName), result);
     } else {
       // Copy binary files as-is
-      await fsCopy(srcPath, path.join(destDir, entry));
+      await fsx.copy(srcPath, path.join(destDir, entry));
     }
   }
 }

package/src/utils/tsconfig.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import path from "path";
-import { fsExists, fsReadJson, pathIsChildPath } from "@simplysm/core-node";
+import { fsx, pathx } from "@simplysm/core-node";
 import { SdError } from "@simplysm/core-common";
 
 /**
@@ -14,11 +14,11 @@ const DOM_LIB_PATTERNS = ["dom", "webworker"] as const;
  */
 export async function getTypesFromPackageJson(packageDir: string): Promise<string[]> {
   const packageJsonPath = path.join(packageDir, "package.json");
-  if (!(await fsExists(packageJsonPath))) {
+  if (!(await fsx.exists(packageJsonPath))) {
     return [];
   }
 
-  const packageJson = await fsReadJson<{ devDependencies?: Record<string, string> }>(
+  const packageJson = await fsx.readJson<{ devDependencies?: Record<string, string> }>(
     packageJsonPath,
   );
   const devDeps = packageJson.devDependencies ?? {};
@@ -32,9 +32,8 @@ export async function getTypesFromPackageJson(packageDir: string): Promise<strin
  * Type check environment
  * - node: remove DOM lib + add node types
  * - browser: remove node types
- * - neutral: keep DOM lib + add node types (for Node/browser shared packages)
  */
-export type TypecheckEnv = "node" | "browser" | "neutral";
+export type TypecheckEnv = "node" | "browser";
 
 /**
  * Create compiler options for package
@@ -72,9 +71,6 @@ export async function getCompilerOptionsForPackage(
     case "browser":
       options.types = packageTypes.filter((t) => t !== "node");
       break;
-    case "neutral":
-      options.types = [...new Set([...packageTypes, "node"])];
-      break;
   }
 
   return options;
@@ -111,7 +107,7 @@ export function getPackageSourceFiles(
   parsedConfig: ts.ParsedCommandLine,
 ): string[] {
   const pkgSrcDir = path.join(pkgDir, "src");
-  return parsedConfig.fileNames.filter((f) => pathIsChildPath(f, pkgSrcDir));
+  return parsedConfig.fileNames.filter((f) => pathx.isChildPath(f, pkgSrcDir));
 }
 
 /**
@@ -119,7 +115,7 @@ export function getPackageSourceFiles(
  */
 export function getPackageFiles(pkgDir: string, parsedConfig: ts.ParsedCommandLine): string[] {
   return parsedConfig.fileNames.filter((f) => {
-    if (!pathIsChildPath(f, pkgDir)) return false;
+    if (!pathx.isChildPath(f, pkgDir)) return false;
     // Exclude files directly in package root (config files) — treated same as project root files in other tasks
     const relative = path.relative(pkgDir, f);
     return path.dirname(relative) !== ".";

package/src/utils/typecheck-serialization.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { fsExistsSync, fsReadSync } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 
 /**
  * Serialized Diagnostic that can be passed to Worker
@@ -67,7 +67,7 @@ export function deserializeDiagnostic(
     // If file was deleted or inaccessible, treat as empty content
     // (source code context won't be displayed but diagnostic message is shown normally)
     if (!fileCache.has(fileName)) {
-      fileCache.set(fileName, fsExistsSync(fileName) ? fsReadSync(fileName) : "");
+      fileCache.set(fileName, fsx.existsSync(fileName) ? fsx.readSync(fileName) : "");
     }
     const content = fileCache.get(fileName)!;