@simplysm/sd-cli 12.8.22 → 12.9.1

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

@@ -13,24 +13,22 @@ import { convertOutputFile } from "@angular/build/src/tools/esbuild/utils";
 import { resolveAssets } from "@angular/build/src/utils/resolve-assets";
 
 export class SdServerBundler {
-  readonly #logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
+  private _logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
 
-  #context?: esbuild.BuildContext;
+  private _context?: esbuild.BuildContext;
 
-  readonly #modifiedFileSet = new Set<TNormPath>();
-  readonly #resultCache: ISdCliServerPluginResultCache = {};
+  private _modifiedFileSet = new Set<TNormPath>();
+  private _resultCache: ISdCliServerPluginResultCache = {};
 
-  readonly #outputHashCache = new Map<TNormPath, string>();
+  private _outputHashCache = new Map<TNormPath, string>();
 
-  constructor(
-    private readonly _opt: {
-      dev: boolean;
-      pkgPath: TNormPath;
-      entryPoints: string[];
-      external?: string[];
-      watchScopePaths: TNormPath[];
-    },
-  ) {
+  constructor(private _opt: {
+    dev: boolean;
+    pkgPath: TNormPath;
+    entryPoints: string[];
+    external?: string[];
+    watchScopePaths: TNormPath[];
+  }) {
   }
 
   async bundleAsync(modifiedFileSet?: Set<TNormPath>): Promise<{
@@ -39,13 +37,13 @@ export class SdServerBundler {
     results: ISdBuildMessage[];
     emitFileSet: Set<TNormPath>;
   }> {
-    this.#modifiedFileSet.clear();
+    this._modifiedFileSet.clear();
     if (modifiedFileSet) {
-      this.#modifiedFileSet.adds(...modifiedFileSet);
+      this._modifiedFileSet.adds(...modifiedFileSet);
     }
 
-    if (!this.#context) {
-      this.#context = await esbuild.context({
+    if (!this._context) {
+      this._context = await esbuild.context({
         entryPoints: this._opt.entryPoints,
         keepNames: true,
         bundle: true,
@@ -106,10 +104,10 @@ const __dirname = __path__.dirname(__filename);`.trim(),
         },
         plugins: [
           createSdServerPlugin({
-            modifiedFileSet: this.#modifiedFileSet,
+            modifiedFileSet: this._modifiedFileSet,
             dev: this._opt.dev,
             pkgPath: this._opt.pkgPath,
-            result: this.#resultCache,
+            result: this._resultCache,
             watchScopePaths: this._opt.watchScopePaths,
           }),
         ],
@@ -119,18 +117,18 @@ const __dirname = __path__.dirname(__filename);`.trim(),
     const emitFileSet = new Set<TNormPath>();
     let result: esbuild.BuildResult | esbuild.BuildFailure;
     try {
-      result = await this.#context.rebuild();
+      result = await this._context.rebuild();
 
       const outputFiles: BuildOutputFile[] =
         result.outputFiles?.map((file) => convertOutputFile(file, BuildOutputFileType.Root)) ?? [];
 
       for (const outputFile of outputFiles) {
         const distFilePath = PathUtils.norm(this._opt.pkgPath, outputFile.path);
-        const prevHash = this.#outputHashCache.get(distFilePath);
+        const prevHash = this._outputHashCache.get(distFilePath);
         const currHash = HashUtils.get(outputFile.contents);
         if (prevHash !== currHash) {
           FsUtils.writeFile(distFilePath, outputFile.contents);
-          this.#outputHashCache.set(distFilePath, currHash);
+          this._outputHashCache.set(distFilePath, currHash);
           emitFileSet.add(distFilePath);
         }
       }
@@ -145,14 +143,14 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       );
 
       for (const assetFile of assetFiles) {
-        const prevHash = this.#outputHashCache.get(PathUtils.norm(assetFile.source));
+        const prevHash = this._outputHashCache.get(PathUtils.norm(assetFile.source));
         const currHash = FsUtils.hash(assetFile.source);
         if (prevHash !== currHash) {
           FsUtils.copy(
             assetFile.source,
             path.resolve(this._opt.pkgPath, "dist", assetFile.destination),
           );
-          this.#outputHashCache.set(PathUtils.norm(assetFile.source), currHash);
+          this._outputHashCache.set(PathUtils.norm(assetFile.source), currHash);
           emitFileSet.add(PathUtils.norm(assetFile.destination));
         }
       }
@@ -161,14 +159,14 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       result = err;
       for (const e of err.errors) {
         if (e.detail != null) {
-          this.#logger.error(e.detail);
+          this._logger.error(e.detail);
         }
       }
     }
 
     return {
-      watchFileSet: this.#resultCache.watchFileSet!,
-      affectedFileSet: this.#resultCache.affectedFileSet!,
+      watchFileSet: this._resultCache.watchFileSet!,
+      affectedFileSet: this._resultCache.affectedFileSet!,
       results: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
         result,
         this._opt.pkgPath,

package/src/sd-cli.ts

@@ -201,54 +201,25 @@ else {
 }
 
 if (argv._[0] === "local-update") {
-  await SdCliLocalUpdate.runAsync({
-    confFileRelPath: argv.config ?? "simplysm.js",
-    optNames: argv.options ?? [],
-  });
+  await SdCliLocalUpdate.runAsync(argv);
 }
 else if (argv._[0] === "watch") {
-  await SdCliProject.watchAsync({
-    confFileRelPath: argv.config ?? "simplysm.js",
-    optNames: argv.options ?? [],
-    pkgNames: argv.packages ?? [],
-    inspectNames: argv.inspects ?? [],
-  });
+  await SdCliProject.watchAsync(argv);
 }
 else if (argv._[0] === "build") {
-  await SdCliProject.buildAsync({
-    confFileRelPath: argv.config ?? "simplysm.js",
-    optNames: argv.options ?? [],
-    pkgNames: argv.packages ?? [],
-  });
+  await SdCliProject.buildAsync(argv);
 }
 else if (argv._[0] === "publish") {
-  await SdCliProject.publishAsync({
-    noBuild: argv.noBuild,
-    confFileRelPath: argv.config ?? "simplysm.js",
-    optNames: argv.options ?? [],
-    pkgNames: argv.packages ?? [],
-  });
+  await SdCliProject.publishAsync(argv);
 }
 else if (argv._[0] === "run-electron") {
-  await SdCliElectron.runAsync({
-    confFileRelPath: argv.config ?? "simplysm.js",
-    optNames: argv.options ?? [],
-    pkgName: argv.package,
-  });
+  await SdCliElectron.runAsync(argv);
 }
 else if (argv._[0] === "build-electron-for-dev") {
-  await SdCliElectron.buildForDevAsync({
-    confFileRelPath: argv.config ?? "simplysm.js",
-    optNames: argv.options ?? [],
-    pkgName: argv.package,
-  });
+  await SdCliElectron.buildForDevAsync(argv);
 }
 else if (argv._[0] === "run-cordova") {
-  await SdCliCordova.runWebviewOnDeviceAsync({
-    platform: argv.platform,
-    pkgName: argv.package,
-    url: argv.url,
-  });
+  await SdCliCordova.runWebviewOnDeviceAsync(argv);
 }
 else if (argv._[0] === "commit") {
   await SdCliAiCommand.commitAsync();

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

@@ -0,0 +1,312 @@
+import ts from "typescript";
+import { SdDependencyCache } from "./sd-dependency-cache";
+import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
+import path from "path";
+import { NgtscProgram } from "@angular/compiler-cli";
+
+export class SdDependencyAnalyzer {
+  static analyze(
+    program: ts.Program,
+    compilerHost: ts.CompilerHost,
+    scopePaths: TNormPath[],
+    depCache: SdDependencyCache,
+  ): void {
+    const compilerOpts = program.getCompilerOptions();
+    const typeChecker = program.getTypeChecker();
+
+    const inScope = (filePath: string): boolean => {
+      return scopePaths.some((scope) => PathUtils.isChildPath(filePath, scope));
+    };
+
+    const resolveModule = (text: string, base: string): TNormPath[] => {
+      const res = ts.resolveModuleName(
+        text,
+        base,
+        compilerOpts,
+        compilerHost,
+      );
+
+      if (res.resolvedModule) {
+        return [
+          PathUtils.norm(res.resolvedModule.resolvedFileName),
+        ];
+      }
+
+      const absPath = path.resolve(path.dirname(base), text);
+      if (!inScope(absPath)) {
+        return [];
+      }
+      else if (
+        // 지원되게할 .png등이면 그냥 가져오고 (bundling  loader에 들어가는것들과 .ts, .json등)
+        // fallback일때는 absPath에 .ts, .d.ts, .js, .json 등 다붙여서 가져와야함
+        [
+          ".ts",
+          ".d.ts",
+          ".js",
+          ".json",
+
+          ".html",
+          ".scss",
+          ".css",
+
+          ".png",
+          ".jpeg",
+          ".jpg",
+          ".jfif",
+          ".gif",
+          ".svg",
+          ".woff",
+          ".woff2",
+          ".ttf",
+          ".ttc",
+          ".eot",
+          ".ico",
+          ".otf",
+          ".csv",
+          ".xlsx",
+          ".xls",
+          ".pptx",
+          ".ppt",
+          ".docx",
+          ".doc",
+          ".zip",
+          ".pfx",
+          ".pkl",
+          ".mp3",
+          ".ogg",
+        ].some(ext => absPath.endsWith(ext))
+      ) {
+        return [
+          PathUtils.norm(absPath),
+        ];
+      }
+      else {
+        return [
+          PathUtils.norm(absPath + ".ts"),
+          PathUtils.norm(absPath + ".js"),
+          PathUtils.norm(absPath + ".d.ts"),
+          PathUtils.norm(absPath + ".json"),
+        ];
+      }
+    };
+
+    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 typeCache = new WeakMap<ts.Node, ts.Type>();
+
+    const getCachedType = (node: ts.Node) => {
+      if (typeCache.has(node)) return typeCache.get(node);
+      const type = typeChecker.getTypeAtLocation(node) as ts.Type | undefined;
+      if (type) typeCache.set(node, type);
+      return type;
+    };
+
+    const collectDeps = (sf: ts.SourceFile) => {
+      const sfNPath = PathUtils.norm(sf.fileName);
+      if (depCache.hasCollected(sfNPath)) return;
+      depCache.addCollected(sfNPath);
+
+      const visit = (node: ts.Node) => {
+        // --- import ... from '...'
+        if (
+          ts.isImportDeclaration(node) &&
+          ts.isStringLiteral(node.moduleSpecifier)
+        ) {
+          const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
+          for (const resolvedNPath of resolvedNPaths) {
+            if (
+              node.importClause &&
+              node.importClause.namedBindings &&
+              ts.isNamedImports(node.importClause.namedBindings)
+            ) {
+              for (const element of node.importClause.namedBindings.elements) {
+                depCache.addImport(
+                  sfNPath,
+                  resolvedNPath,
+                  element.propertyName?.text ?? element.name.text,
+                );
+              }
+            }
+            else {
+              depCache.addImport(sfNPath, resolvedNPath, 0);
+            }
+          }
+        }
+
+        // --- export * from '...'
+        else if (
+          ts.isExportDeclaration(node) &&
+          !node.exportClause &&
+          node.moduleSpecifier &&
+          ts.isStringLiteral(node.moduleSpecifier)
+        ) {
+          const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
+          for (const resolvedNPath of resolvedNPaths) {
+            depCache.addReexport(sfNPath, resolvedNPath, 0);
+          }
+        }
+
+        // --- export { A as B } from '...'
+        if (
+          ts.isExportDeclaration(node) &&
+          node.exportClause &&
+          ts.isNamedExports(node.exportClause) &&
+          node.moduleSpecifier &&
+          ts.isStringLiteral(node.moduleSpecifier)
+        ) {
+          const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
+          for (const resolvedNPath of resolvedNPaths) {
+            for (const element of node.exportClause.elements) {
+              const local = element.propertyName?.text ?? element.name.text;
+              const exported = element.name.text;
+              depCache.addReexport(sfNPath, resolvedNPath, {
+                importSymbol: local,
+                exportSymbol: exported,
+              });
+            }
+          }
+        }
+
+        // --- export const A = ...
+        else if (
+          ts.isVariableStatement(node) &&
+          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);
+            }
+          }
+        }
+
+        // --- export function/class/interface A ...
+        else 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) &&
+          node.name
+        ) {
+          depCache.addExport(sfNPath, node.name.text);
+        }
+
+        else if (ts.isIdentifier(node) && !isInImportOrExport(node)) {
+          const orgValSymbol = typeChecker.getSymbolAtLocation(node);
+
+          // 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);
+            if (declNPath !== sfNPath && inScope(declNPath)) {
+              depCache.addImport(sfNPath, declNPath, 0);
+            }
+          }
+        }
+        else if (
+          ts.isPropertyAccessExpression(node)
+        ) {
+          const type = getCachedType(node.expression);
+          const propSymbol = type?.getProperty(node.name.text);
+
+          if (propSymbol) {
+            for (const decl of propSymbol.getDeclarations() ?? []) {
+              const declFile = decl.getSourceFile();
+              const declNPath = PathUtils.norm(declFile.fileName);
+              if (declNPath !== sfNPath && inScope(declNPath)) {
+                depCache.addImport(sfNPath, declNPath, 0);
+              }
+            }
+          }
+        }
+        else if (
+          ts.isElementAccessExpression(node) &&
+          ts.isStringLiteral(node.argumentExpression)
+        ) {
+          const type = getCachedType(node.expression);
+          const propSymbol = type?.getProperty(node.argumentExpression.text);
+
+          if (propSymbol) {
+            for (const decl of propSymbol.getDeclarations() ?? []) {
+              const declFile = decl.getSourceFile();
+              const declNPath = PathUtils.norm(declFile.fileName);
+              if (declNPath !== sfNPath && inScope(declNPath)) {
+                depCache.addImport(sfNPath, declNPath, 0);
+              }
+            }
+          }
+        }
+
+        ts.forEachChild(node, visit);
+      };
+
+      ts.forEachChild(sf, visit);
+    };
+
+    const getOrgSourceFile = (sf: ts.SourceFile) => {
+      if (sf.fileName.endsWith(".ngtypecheck.ts")) {
+        const orgFileName = sf.fileName.slice(0, -15) + ".ts";
+        return program.getSourceFile(orgFileName);
+      }
+      return sf;
+    };
+
+    const sourceFileSet = new Set(
+      program.getSourceFiles()
+        .filter((sf) => inScope(sf.fileName))
+        .map((sf) => getOrgSourceFile(sf))
+        .filterExists(),
+    );
+
+    for (const sf of sourceFileSet) {
+      collectDeps(sf);
+    }
+  }
+
+
+  static analyzeAngularResources(
+    ngProgram: NgtscProgram,
+    scopePaths: TNormPath[],
+    depCache: SdDependencyCache,
+  ) {
+    const inScope = (filePath: string): boolean => {
+      return scopePaths.some((scope) => PathUtils.isChildPath(filePath, scope));
+    };
+
+    for (const sf of ngProgram.getTsProgram().getSourceFiles()) {
+      const fileNPath = PathUtils.norm(sf.fileName);
+      if (!inScope(fileNPath)) continue;
+
+      const dependencies = ngProgram.compiler.getResourceDependencies(sf);
+      for (const dep of dependencies) {
+        const depNPath = PathUtils.norm(dep);
+        if (!inScope(depNPath)) continue;
+
+        console.log(fileNPath, depNPath);
+        depCache.addImport(fileNPath, depNPath, 0);
+      }
+    }
+  }
+}