@simplysm/sd-cli 12.13.23 → 12.13.36

package/src/fix/core/convert-symbol.ts

@@ -18,11 +18,18 @@ function parseReplacements(input: Record<string, string>): SymbolReplacement[] {
   });
 }
 
+function getSourceFileModule(filePath: string): string {
+  const match = filePath.match(/packages[\\/](.*?)[\\/]src[\\/]/);
+  return `@simplysm/${match![1]}`;
+}
+
 export default function convertSymbols(raw: Record<string, string>) {
   const replacements = parseReplacements(raw);
   const sourceFiles = getTsMortphSourceFiles();
 
   for (const sourceFile of sourceFiles) {
+    const sourceFileModule = getSourceFileModule(sourceFile.getFilePath());
+
     let changed = false;
 
     const usedReplacements = new Set<string>(); // 실제 사용된 newModule#newName 추적
@@ -47,13 +54,16 @@ export default function convertSymbols(raw: Record<string, string>) {
 
       const importModule = importDecl.getModuleSpecifierValue();
 
-      const match = replacements.find(r => r.oldModule === importModule && r.oldName === name);
-      if (!match) return;
+      const match = replacements.find((r) => r.oldModule === importModule && r.oldName === name);
+      if (!match || match.oldModule === sourceFileModule || match.newModule === sourceFileModule)
+        return;
 
       identifier.replaceWithText(match.newName);
       usedReplacements.add(`${match.newModule}#${match.newName}`);
       changed = true;
-      console.log(`[ref] ${sourceFile.getBaseName()} :: ${importModule} :: ${name} → ${match.newName}`);
+      console.log(
+        `[ref] ${sourceFile.getBaseName()} :: ${importModule} :: ${name} → ${match.newName}`,
+      );
     });
 
     // 2. import 교체
@@ -64,8 +74,18 @@ export default function convertSymbols(raw: Record<string, string>) {
       for (const ni of namedImports) {
         const oldName = ni.getName();
 
-        const match = replacements.find(r => r.oldModule === specifier && r.oldName === oldName);
-        if (match) {
+        const match = replacements.find((r) => r.oldModule === specifier && r.oldName === oldName);
+        if (
+          !match ||
+          match.oldModule === sourceFileModule ||
+          match.newModule === sourceFileModule
+        ) {
+          // 기존 import 유지 기록
+          if (!existingImportMap.has(specifier)) {
+            existingImportMap.set(specifier, new Set());
+          }
+          existingImportMap.get(specifier)!.add(oldName);
+        } else {
           ni.remove();
 
           // 만약 모듈이 동일하다면 즉시 대체
@@ -77,13 +97,9 @@ export default function convertSymbols(raw: Record<string, string>) {
           }
 
           changed = true;
-          console.log(`[import] ${sourceFile.getBaseName()} :: ${specifier} :: ${oldName} → ${match.newName}`);
-        } else {
-          // 기존 import 유지 기록
-          if (!existingImportMap.has(specifier)) {
-            existingImportMap.set(specifier, new Set());
-          }
-          existingImportMap.get(specifier)!.add(oldName);
+          console.log(
+            `[import] ${sourceFile.getBaseName()} :: ${specifier} :: ${oldName} → ${match.newName}`,
+          );
         }
       }
     }
@@ -93,10 +109,13 @@ export default function convertSymbols(raw: Record<string, string>) {
       const [newModule, newName] = key.split("#");
 
       const already = existingImportMap.get(newModule)?.has(newName);
-      const existsInFile = sourceFile.getImportDeclarations().some(decl =>
-        decl.getModuleSpecifierValue() === newModule &&
-        decl.getNamedImports().some(ni => ni.getName() === newName)
-      );
+      const existsInFile = sourceFile
+        .getImportDeclarations()
+        .some(
+          (decl) =>
+            decl.getModuleSpecifierValue() === newModule &&
+            decl.getNamedImports().some((ni) => ni.getName() === newName),
+        );
 
       if (already || existsInFile) continue;
 

package/src/fix/remove-unused-protected-readonly.ts

@@ -51,7 +51,13 @@ export default function removeUnusedProtectedReadonly() {
         const usedInTemplate =
           templateText.includes(name) || new RegExp(`\\b${name}\\b`).test(templateText);
 
-        if (!usedInTemplate) {
+        const identifiers = cls.getDescendantsOfKind(SyntaxKind.Identifier);
+        const usedInClass = identifiers.some((id) => {
+          if (id.getText() !== name) return false;
+          return id !== field.getNameNode();
+        });
+
+        if (!usedInTemplate && !usedInClass) {
           console.log(`🧹 Removing unused field: ${name} in ${sourceFile.getBaseName()}`);
           field.remove();
         }

package/src/pkg-builders/SdProjectBuildRunner.ts

@@ -88,10 +88,11 @@ export class SdProjectBuildRunner {
             {
               pkgPath: changedPkgInfo.pkgPath,
               projConf: opt.projConf,
+              scopePathSet: scopePathSet,
+
               watch: true,
               emitOnly: opt.emitOnly,
               noEmit: opt.noEmit,
-              scopePathSet: scopePathSet,
             },
           ]);
 
@@ -272,6 +273,11 @@ export class SdProjectBuildRunner {
   }
 
   static async buildAsync(opt: { pkgPaths: TNormPath[]; projConf: ISdProjectConfig }) {
+    const scopePathSet = await this.#getScopePathSetAsync(
+      opt.pkgPaths,
+      Object.keys(opt.projConf.localUpdates ?? {}),
+    );
+
     const buildResults = await opt.pkgPaths.parallelAsync(async (pkgPath) => {
       const worker = new SdWorker<ISdBuildRunnerWorkerType>(
         import.meta.resolve("../workers/build-runner.worker"),
@@ -281,6 +287,7 @@ export class SdProjectBuildRunner {
         {
           pkgPath,
           projConf: opt.projConf,
+          scopePathSet: scopePathSet,
         },
       ]);
 

package/src/pkg-builders/commons/SdBuildRunnerBase.ts

@@ -15,11 +15,11 @@ export abstract class SdBuildRunnerBase<T extends "server" | "library" | "client
   constructor(
     protected _pkgPath: TNormPath,
     protected _projConf: ISdProjectConfig,
+    scopePathSet: Set<TNormPath>,
     protected _watch: boolean,
     protected _dev: boolean,
     protected _emitOnly?: boolean,
     protected _noEmit?: boolean,
-    scopePathSet?: Set<TNormPath>,
   ) {
     this._pkgName = path.basename(_pkgPath);
     this._pkgConf = _projConf.packages[this._pkgName] as TSdPackageConfig<T>;

package/src/pkg-builders/lib/SdTsLibBuilder.ts

@@ -24,7 +24,6 @@ export class SdTsLibBuilder {
       isDevMode: dev,
       isEmitOnly: emitOnly,
       isNoEmit: noEmit,
-      globalStyleFilePath: PathUtils.norm(this._pkgPath, "src/styles.scss"),
       isForBundle: false,
       scopePathSet,
     });

package/src/sd-cli.ts

@@ -19,14 +19,14 @@ if (path.extname(cliPath) === ".ts") {
   // .js 번들 실행 (배포본)
 
   // 로컬 업데이트
-  if (!process.argv.includes("--noEmit")) {
-    if (!process.argv.slice(2).includes("local-update")) {
-      await spawnWaitAsync(`node`, [
-        "--import=specifier-resolution-node/register",
-        fileURLToPath(cliPath),
-        "local-update",
-      ]);
-    }
+  if (process.argv.slice(2).includes("watch") && !process.argv.slice(2).includes("--noEmit")) {
+    // if (!process.argv.slice(2).includes("local-update")) {
+    await spawnWaitAsync(`node`, [
+      "--import=specifier-resolution-node/register",
+      fileURLToPath(cliPath),
+      "local-update",
+    ]);
+    // }
   }
 
   // 프로세스 실행

package/src/ts-compiler/SdTsCompiler.ts

@@ -368,40 +368,35 @@ export class SdTsCompiler {
   }
 
   async #buildGlobalStyleAsync() {
+    if (!this.#isForAngular) return;
+
     //-- global style
-    if (
-      this._opt.globalStyleFilePath != null &&
-      FsUtils.exists(this._opt.globalStyleFilePath) &&
-      !this.#emittedFilesCacheMap.has(this._opt.globalStyleFilePath)
-    ) {
-      this.#debug(`전역 스타일 번들링 중...`);
-
-      await this.#perf.run("전역 스타일 번들링", async () => {
-        const data = await FsUtils.readFileAsync(this._opt.globalStyleFilePath!);
-        const stylesheetBundlingResult = await this.#styleBundler!.bundleAsync(
-          data,
-          this._opt.globalStyleFilePath!,
-          this._opt.globalStyleFilePath,
-        );
-        const emitFileInfos = this.#emittedFilesCacheMap.getOrCreate(
-          this._opt.globalStyleFilePath!,
-          [],
-        );
-        emitFileInfos.push({
-          outAbsPath: PathUtils.norm(
-            this._opt.pkgPath,
-            path
-              .relative(path.resolve(this._opt.pkgPath, "src"), this._opt.globalStyleFilePath!)
-              .replace(/\.scss$/, ".css"),
-          ),
-          text: stylesheetBundlingResult.contents ?? "",
-        });
+    const globalStyleFilePath = PathUtils.norm(this._opt.pkgPath, "src/styles.scss");
+    if (this.#emittedFilesCacheMap.has(globalStyleFilePath)) return;
+    if (!FsUtils.exists(globalStyleFilePath)) return;
+
+    this.#debug(`전역 스타일 번들링 중...`);
+
+    await this.#perf.run("전역 스타일 번들링", async () => {
+      const data = await FsUtils.readFileAsync(globalStyleFilePath);
+      const stylesheetBundlingResult = await this.#styleBundler!.bundleAsync(
+        data,
+        globalStyleFilePath,
+        globalStyleFilePath,
+      );
+      const emitFileInfos = this.#emittedFilesCacheMap.getOrCreate(globalStyleFilePath, []);
+      emitFileInfos.push({
+        outAbsPath: PathUtils.norm(
+          this._opt.pkgPath,
+          path
+            .relative(path.resolve(this._opt.pkgPath, "src"), globalStyleFilePath)
+            .replace(/\.scss$/, ".css"),
+        ),
+        text: stylesheetBundlingResult.contents ?? "",
       });
+    });
 
-      return this._opt.globalStyleFilePath;
-    }
-
-    return undefined;
+    return globalStyleFilePath;
   }
 
   #build(prepareResult: IPrepareResult) {

package/src/types/build/ISdTsCompilerOptions.ts

@@ -11,5 +11,4 @@ export interface ISdTsCompilerOptions {
   isEmitOnly: boolean;
   isNoEmit: boolean;
   scopePathSet: ScopePathSet;
-  globalStyleFilePath?: TNormPath;
 }

package/src/types/worker/ISdBuildRunnerWorkerType.ts

@@ -15,10 +15,10 @@ export interface ISdBuildRunnerWorkerType extends ISdWorkerType {
 export interface ISdBuildRunnerInitializeRequest {
   pkgPath: TNormPath;
   projConf: ISdProjectConfig;
+  scopePathSet: Set<TNormPath>;
 
   // watch
   watch?: boolean;
   emitOnly?: boolean;
   noEmit?: boolean;
-  scopePathSet?: Set<TNormPath>;
 }

package/src/workers/build-runner.worker.ts

@@ -50,11 +50,11 @@ createSdWorker<ISdBuildRunnerWorkerType>({
     buildRunner = new buildRunnerType(
       req.pkgPath,
       req.projConf,
+      req.scopePathSet,
       req.watch ?? false,
       req.watch ? !pkgConf.forceProductionMode : false,
       req.emitOnly,
       req.noEmit,
-      req.scopePathSet,
     );
   },
   async rebuild(modifiedFileSet?: Set<TNormPath>) {