@simplysm/sd-cli 12.13.13 → 12.13.15

package/src/pkg-builders/server/sd-server.build-runner.ts

@@ -13,16 +13,20 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
 
   protected override async _runAsync(
     dev: boolean,
+    emitOnly: boolean,
+    noEmit: boolean,
     modifiedFileSet?: Set<TNormPath>,
   ): Promise<IBuildRunnerRunResult> {
     if (!dev) {
       await this.#generateProductionFilesAsync();
     }
 
-    if (!modifiedFileSet) {
-      this._debug("GEN .config...");
-      const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
-      FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
+    if (!noEmit) {
+      if (!modifiedFileSet) {
+        this._debug("GEN .config...");
+        const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
+        FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
+      }
     }
 
     /*const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
@@ -36,6 +40,8 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
       this.#serverBundler ??
       new SdServerBundler({
         dev,
+        emitOnly,
+        noEmit,
         pkgPath: this._pkgPath,
         entryPoints: tsConfig.files
           ? tsConfig.files.map((item) => path.resolve(this._pkgPath, item))

package/src/pkg-builders/server/sd-server.bundler.ts

@@ -26,6 +26,8 @@ export class SdServerBundler {
   constructor(
     private readonly _opt: {
       dev: boolean;
+      emitOnly: boolean;
+      noEmit: boolean;
       pkgPath: TNormPath;
       entryPoints: string[];
       external?: string[];
@@ -108,6 +110,8 @@ const __dirname = __path__.dirname(__filename);`.trim(),
           createSdServerPlugin({
             modifiedFileSet: this.#modifiedFileSet,
             dev: this._opt.dev,
+            emitOnly: this._opt.emitOnly,
+            noEmit: this._opt.noEmit,
             pkgPath: this._opt.pkgPath,
             result: this.#resultCache,
             watchScopePathSet: this._opt.watchScopePathSet,
@@ -153,7 +157,7 @@ const __dirname = __path__.dirname(__filename);`.trim(),
             path.resolve(this._opt.pkgPath, "dist", assetFile.destination),
           );
           this.#outputHashCache.set(PathUtils.norm(assetFile.source), currHash);
-          emitFileSet.add(PathUtils.norm(assetFile.destination));
+          emitFileSet.add(PathUtils.norm(this._opt.pkgPath, "dist", assetFile.destination));
         }
       }
     } catch (err) {

package/src/pkg-builders/server/sd-server.plugin-creator.ts

@@ -9,6 +9,8 @@ import { ScopePathSet } from "../commons/scope-path";
 export function createSdServerPlugin(conf: {
   pkgPath: TNormPath;
   dev: boolean;
+  emitOnly: boolean;
+  noEmit: boolean;
   modifiedFileSet: Set<TNormPath>;
   result: ISdCliServerPluginResultCache;
   watchScopePathSet: ScopePathSet;
@@ -20,6 +22,8 @@ export function createSdServerPlugin(conf: {
         pkgPath: conf.pkgPath,
         additionalOptions: { declaration: false },
         isDevMode: conf.dev,
+        isNoEmit: conf.noEmit,
+        isEmitOnly: conf.emitOnly,
         isForBundle: true,
         watchScopePathSet: conf.watchScopePathSet,
       });
@@ -40,7 +44,8 @@ export function createSdServerPlugin(conf: {
       });
 
       build.onLoad({ filter: /\.ts$/ }, (args) => {
-        const emittedJsFile = tsCompileResult.emittedFilesCacheMap.get(PathUtils.norm(args.path))
+        const emittedJsFile = tsCompileResult.emittedFilesCacheMap
+          .get(PathUtils.norm(args.path))
           ?.last();
         if (!emittedJsFile) {
           return {
@@ -65,10 +70,10 @@ export function createSdServerPlugin(conf: {
         {
           filter: new RegExp(
             "(" +
-            Object.keys(build.initialOptions.loader!)
-              .map((item) => "\\" + item)
-              .join("|") +
-            ")$",
+              Object.keys(build.initialOptions.loader!)
+                .map((item) => "\\" + item)
+                .join("|") +
+              ")$",
           ),
         },
         (args) => {

package/src/sd-cli-entry.ts

@@ -93,6 +93,16 @@ await yargs(hideBin(process.argv))
             array: true,
             describe: "크롬 inspect를 수행할 패키지 설정",
           },
+          emitOnly: {
+            type: "boolean",
+            describe: "emit만 수행",
+            default: false,
+          },
+          noEmit: {
+            type: "boolean",
+            describe: "emit만 수행",
+            default: false,
+          },
         }),
     async (argv) => await SdCliProject.watchAsync(argv),
   )

package/src/sd-cli.ts

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

package/src/ts-compiler/sd-dependency-analyzer.ts

@@ -10,30 +10,40 @@ export class SdDependencyAnalyzer {
     program: ts.Program,
     compilerHost: ts.CompilerHost,
     scopePathSet: ScopePathSet,
-    depCache: SdDependencyCache,
+    cache: {
+      dep: SdDependencyCache;
+      type: WeakMap<ts.Node, ts.Type | undefined>;
+      prop: WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>;
+      declFiles: WeakMap<ts.Symbol, TNormPath[]>;
+      ngOrg: Map<TNormPath, ts.SourceFile>;
+    },
   ): void {
     const compilerOpts = program.getCompilerOptions();
     const typeChecker = program.getTypeChecker();
 
+    const moduleResolutionCache = ts.createModuleResolutionCache(
+      compilerHost.getCurrentDirectory(),
+      compilerHost.getCanonicalFileName.bind(compilerHost),
+      compilerOpts,
+    );
+
     const resolveModule = (text: string, base: string): TNormPath[] => {
       const res = ts.resolveModuleName(
         text,
         base,
         compilerOpts,
         compilerHost,
+        moduleResolutionCache,
       );
 
       if (res.resolvedModule) {
-        return [
-          PathUtils.norm(res.resolvedModule.resolvedFileName),
-        ];
+        return [PathUtils.norm(res.resolvedModule.resolvedFileName)];
       }
 
       const absPath = path.resolve(path.dirname(base), text);
       if (!scopePathSet.inScope(absPath)) {
         return [];
-      }
-      else if (
+      } else if (
         // 지원되게할 .png등이면 그냥 가져오고 (bundling  loader에 들어가는것들과 .ts, .json등)
         // fallback일때는 absPath에 .ts, .d.ts, .js, .json 등 다붙여서 가져와야함
         [
@@ -71,13 +81,10 @@ export class SdDependencyAnalyzer {
           ".pkl",
           ".mp3",
           ".ogg",
-        ].some(ext => absPath.endsWith(ext))
+        ].some((ext) => absPath.endsWith(ext))
       ) {
-        return [
-          PathUtils.norm(absPath),
-        ];
-      }
-      else {
+        return [PathUtils.norm(absPath)];
+      } else {
         return [
           PathUtils.norm(absPath + ".ts"),
           PathUtils.norm(absPath + ".js"),
@@ -88,61 +95,118 @@ export class SdDependencyAnalyzer {
     };
 
     const isInImportOrExport = (node: ts.Node) => {
-      let curr = node as ts.Node | undefined;
-      while (curr) {
-        if (
-          ts.isImportDeclaration(curr) ||
-          ts.isExportDeclaration(curr) ||
-          ts.isImportSpecifier(curr) ||
-          ts.isExportSpecifier(curr) ||
-          ts.isNamespaceImport(curr)
-        ) {
-          return true;
-        }
-        curr = curr.parent;
-      }
-      return false;
+      const p = node.parent;
+      return (
+        ts.isImportDeclaration(p) ||
+        ts.isExportDeclaration(p) ||
+        ts.isImportSpecifier(p) ||
+        ts.isExportSpecifier(p) ||
+        ts.isNamespaceImport(p)
+      );
     };
 
-    const typeCache = new WeakMap<ts.Node, ts.Type>();
+    const isDeclarationIdentifier = (id: ts.Identifier): boolean => {
+      const p = id.parent;
+      return (
+        (ts.isParameter(p) && p.name === id) ||
+        (ts.isVariableDeclaration(p) && p.name === id) ||
+        (ts.isFunctionDeclaration(p) && p.name === id) ||
+        (ts.isClassDeclaration(p) && p.name === id) ||
+        (ts.isInterfaceDeclaration(p) && p.name === id) ||
+        (ts.isTypeAliasDeclaration(p) && p.name === id) ||
+        (ts.isEnumDeclaration(p) && p.name === id) ||
+        (ts.isPropertySignature(p) && p.name === id) ||
+        (ts.isPropertyDeclaration(p) && p.name === id) ||
+        (ts.isMethodSignature(p) && p.name === id) ||
+        (ts.isMethodDeclaration(p) && p.name === id)
+      );
+    };
+
+    // const typeCache = new WeakMap<ts.Node, ts.Type | undefined>();
 
     const getCachedType = (node: ts.Node) => {
-      if (typeCache.has(node)) return typeCache.get(node);
+      if (cache.type.has(node)) return cache.type.get(node);
       const type = typeChecker.getTypeAtLocation(node) as ts.Type | undefined;
-      if (type) typeCache.set(node, type);
-      return type;
+      if (!type) return undefined;
+
+      const skipMask =
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.BooleanLike |
+        ts.TypeFlags.NumberLike |
+        ts.TypeFlags.StringLike |
+        ts.TypeFlags.BigIntLike |
+        ts.TypeFlags.ESSymbolLike;
+
+      const result = (type.flags & skipMask) !== 0 ? undefined : type;
+      cache.type.set(node, result);
+
+      return result;
+    };
+
+    // const propCache = new WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>();
+
+    const getCachedProp = (type: ts.Type | undefined, name: string) => {
+      if (!type) return undefined;
+      let map = cache.prop.get(type);
+      if (!map) {
+        map = new Map();
+        cache.prop.set(type, map);
+      }
+      if (map.has(name)) return map.get(name);
+      const s = type.getProperty(name);
+      map.set(name, s);
+      return s;
+    };
+
+    // const declFilesCache = new WeakMap<ts.Symbol, TNormPath[]>();
+
+    const getDeclFileNPaths = (sym: ts.Symbol | undefined): TNormPath[] => {
+      if (!sym) return [];
+      const c = cache.declFiles.get(sym);
+      if (c) return c;
+      const paths = (sym.getDeclarations() ?? []).map((d) =>
+        PathUtils.norm(d.getSourceFile().fileName),
+      );
+      cache.declFiles.set(sym, paths);
+      return paths;
     };
 
     const collectDeps = (sf: ts.SourceFile) => {
       const sfNPath = PathUtils.norm(sf.fileName);
-      if (depCache.hasCollected(sfNPath)) return;
-      depCache.addCollected(sfNPath);
+      if (cache.dep.hasCollected(sfNPath)) return;
+      cache.dep.addCollected(sfNPath);
+      if (!scopePathSet.inScope(sfNPath)) return;
 
       const visit = (node: ts.Node) => {
         // --- import ... from '...'
-        if (
-          ts.isImportDeclaration(node) &&
-          ts.isStringLiteral(node.moduleSpecifier)
-        ) {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
           const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
           for (const resolvedNPath of resolvedNPaths) {
+            if (!scopePathSet.inScope(resolvedNPath)) continue;
+
             if (
               node.importClause &&
               node.importClause.namedBindings &&
               ts.isNamedImports(node.importClause.namedBindings)
             ) {
+              // import ... from '...'
               for (const element of node.importClause.namedBindings.elements) {
-                depCache.addImport(
+                cache.dep.addImport(
                   sfNPath,
                   resolvedNPath,
                   element.propertyName?.text ?? element.name.text,
                 );
               }
-            }
-            else {
-              depCache.addImport(sfNPath, resolvedNPath, 0);
+            } else {
+              cache.dep.addImport(sfNPath, resolvedNPath, 0);
             }
           }
+
+          return;
         }
 
         // --- export * from '...'
@@ -154,12 +218,16 @@ export class SdDependencyAnalyzer {
         ) {
           const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
           for (const resolvedNPath of resolvedNPaths) {
-            depCache.addReexport(sfNPath, resolvedNPath, 0);
+            if (!scopePathSet.inScope(resolvedNPath)) continue;
+
+            cache.dep.addReexport(sfNPath, resolvedNPath, 0);
           }
+
+          return;
         }
 
         // --- export { A as B } from '...'
-        if (
+        else if (
           ts.isExportDeclaration(node) &&
           node.exportClause &&
           ts.isNamedExports(node.exportClause) &&
@@ -168,89 +236,87 @@ export class SdDependencyAnalyzer {
         ) {
           const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
           for (const resolvedNPath of resolvedNPaths) {
+            if (!scopePathSet.inScope(resolvedNPath)) continue;
+
             for (const element of node.exportClause.elements) {
               const local = element.propertyName?.text ?? element.name.text;
               const exported = element.name.text;
-              depCache.addReexport(sfNPath, resolvedNPath, {
+              cache.dep.addReexport(sfNPath, resolvedNPath, {
                 importSymbol: local,
                 exportSymbol: exported,
               });
             }
           }
+
+          return;
         }
 
         // --- export const A = ...
         else if (
           ts.isVariableStatement(node) &&
-          node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)
+          node.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)
         ) {
           for (const decl of node.declarationList.declarations) {
             if (ts.isIdentifier(decl.name)) {
-              depCache.addExport(sfNPath, decl.name.text);
+              cache.dep.addExport(sfNPath, decl.name.text);
             }
           }
         }
 
         // --- export function/class/interface A ...
-        else if (
-          (
-            ts.isFunctionDeclaration(node) ||
+        if (
+          (ts.isFunctionDeclaration(node) ||
             ts.isClassDeclaration(node) ||
             ts.isInterfaceDeclaration(node) ||
             ts.isTypeAliasDeclaration(node) ||
-            ts.isEnumDeclaration(node)
-          ) &&
-          node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword) &&
+            ts.isEnumDeclaration(node)) &&
+          node.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword) &&
           node.name
         ) {
-          depCache.addExport(sfNPath, node.name.text);
-        }
-
-        else if (ts.isIdentifier(node) && !isInImportOrExport(node)) {
+          cache.dep.addExport(sfNPath, node.name.text);
+        } else if (
+          ts.isIdentifier(node) &&
+          isDeclarationIdentifier(node) &&
+          !isInImportOrExport(node)
+        ) {
           const orgValSymbol = typeChecker.getSymbolAtLocation(node);
+          let valSymbol = orgValSymbol;
+          if (orgValSymbol && orgValSymbol.flags & ts.SymbolFlags.Alias) {
+            // 현 파일 선언으로 확정되면 굳이 치환 불필요
+            const declNPaths = getDeclFileNPaths(orgValSymbol);
+            const external = declNPaths.some((declNPath) => declNPath !== sfNPath);
+            if (external) {
+              valSymbol = typeChecker.getAliasedSymbol(orgValSymbol);
+            }
+          }
 
-          // alias (import된 심볼)일 경우, 원본 심볼로 치환
-          const valSymbol = (orgValSymbol && (orgValSymbol.flags & ts.SymbolFlags.Alias))
-            ? typeChecker.getAliasedSymbol(orgValSymbol)
-            : undefined;
-
-          for (const decl of valSymbol?.getDeclarations() ?? []) {
-            const declFile = decl.getSourceFile();
-            const declNPath = PathUtils.norm(declFile.fileName);
+          for (const declNPath of getDeclFileNPaths(valSymbol)) {
             if (declNPath !== sfNPath && scopePathSet.inScope(declNPath)) {
-              depCache.addImport(sfNPath, declNPath, 0);
+              cache.dep.addImport(sfNPath, declNPath, 0);
             }
           }
-        }
-        else if (
-          ts.isPropertyAccessExpression(node)
-        ) {
+        } else if (ts.isPropertyAccessExpression(node)) {
           const type = getCachedType(node.expression);
-          const propSymbol = type?.getProperty(node.name.text);
+          const propSymbol = getCachedProp(type, node.name.text);
 
           if (propSymbol) {
-            for (const decl of propSymbol.getDeclarations() ?? []) {
-              const declFile = decl.getSourceFile();
-              const declNPath = PathUtils.norm(declFile.fileName);
+            for (const declNPath of getDeclFileNPaths(propSymbol)) {
               if (declNPath !== sfNPath && scopePathSet.inScope(declNPath)) {
-                depCache.addImport(sfNPath, declNPath, 0);
+                cache.dep.addImport(sfNPath, declNPath, 0);
               }
             }
           }
-        }
-        else if (
+        } else if (
           ts.isElementAccessExpression(node) &&
           ts.isStringLiteral(node.argumentExpression)
         ) {
           const type = getCachedType(node.expression);
-          const propSymbol = type?.getProperty(node.argumentExpression.text);
+          const propSymbol = getCachedProp(type, node.argumentExpression.text);
 
           if (propSymbol) {
-            for (const decl of propSymbol.getDeclarations() ?? []) {
-              const declFile = decl.getSourceFile();
-              const declNPath = PathUtils.norm(declFile.fileName);
+            for (const declNPath of getDeclFileNPaths(propSymbol)) {
               if (declNPath !== sfNPath && scopePathSet.inScope(declNPath)) {
-                depCache.addImport(sfNPath, declNPath, 0);
+                cache.dep.addImport(sfNPath, declNPath, 0);
               }
             }
           }
@@ -262,16 +328,27 @@ export class SdDependencyAnalyzer {
       ts.forEachChild(sf, visit);
     };
 
+    // const ngToOrgCache = new Map<TNormPath, ts.SourceFile>();
+
     const getOrgSourceFile = (sf: ts.SourceFile) => {
       if (sf.fileName.endsWith(".ngtypecheck.ts")) {
-        const orgFileName = sf.fileName.slice(0, -15) + ".ts";
-        return program.getSourceFile(orgFileName);
+        const sfNPath = PathUtils.norm(sf.fileName);
+        let org = cache.ngOrg.get(sfNPath);
+        if (!org) {
+          const orgPath = sf.fileName.slice(0, -15) + ".ts";
+          org = program.getSourceFile(orgPath) ?? sf;
+
+          const realOrg = program.getSourceFile(orgPath);
+          if (realOrg) cache.ngOrg.set(sfNPath, realOrg);
+        }
+        return org;
       }
       return sf;
     };
 
     const sourceFileSet = new Set(
-      program.getSourceFiles()
+      program
+        .getSourceFiles()
         .filter((sf) => scopePathSet.inScope(sf.fileName))
         .map((sf) => getOrgSourceFile(sf))
         .filterExists(),
@@ -282,13 +359,11 @@ export class SdDependencyAnalyzer {
     }
   }
 
-
   static analyzeAngularResources(
     ngProgram: NgtscProgram,
     scopePathSet: ScopePathSet,
     depCache: SdDependencyCache,
   ) {
-
     for (const sf of ngProgram.getTsProgram().getSourceFiles()) {
       const fileNPath = PathUtils.norm(sf.fileName);
       if (!scopePathSet.inScope(fileNPath)) continue;
@@ -302,4 +377,4 @@ export class SdDependencyAnalyzer {
       }
     }
   }
-}
+}