@simplysm/sd-cli 7.0.248 → 7.0.266

package/src/build-tool/SdCliNgCacheCompilerHost.ts

@@ -1,58 +1,58 @@
-import ts from "typescript";
-import { PathUtil } from "@simplysm/sd-core-node";
-import sass from "sass";
-import { fileURLToPath, pathToFileURL, URL } from "url";
-
-export class SdCliNgCacheCompilerHost {
-  public static wrap(compilerHost: ts.CompilerHost,
-                     sourceFileCache: Map<string, IFileCache>): ts.CompilerHost {
-    const cacheCompilerHost = { ...compilerHost };
-
-    cacheCompilerHost["readResource"] = (fileName: string) => {
-      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (cache.content === undefined) {
-        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
-      }
-      return cache.content;
-    };
-
-    cacheCompilerHost["transformResource"] = async (data, context) => {
-      if (context.resourceFile != null || context.type !== "style") {
-        return null;
-      }
-
-      const cache = sourceFileCache.getOrCreate(PathUtil.posix(context.containingFile), {});
-      if (cache.styleContent === undefined) {
-        const scssResult = await sass.compileStringAsync(data, {
-          url: new URL((context.containingFile as string) + ".sd.scss"),
-          importer: {
-            findFileUrl: (url) => {
-              if (!url.startsWith("~")) return pathToFileURL(url);
-              return new URL(url.substring(1), pathToFileURL("node_modules"));
-            }
-          }
-        });
-
-        cache.styleContent = scssResult.css.toString();
-
-        const deps = scssResult.loadedUrls.slice(1).map((item) => PathUtil.posix(fileURLToPath(item.href)));
-        for (const dep of deps) {
-          const depCache = sourceFileCache.getOrCreate(dep, {});
-          depCache.importerSet = depCache.importerSet ?? new Set<string>();
-          depCache.importerSet.add(PathUtil.posix(context.containingFile));
-        }
-      }
-      return { content: cache.styleContent };
-    };
-
-    return cacheCompilerHost;
-  }
-}
-
-interface IFileCache {
-  exists?: boolean;
-  sourceFile?: ts.SourceFile;
-  content?: string;
-  styleContent?: string;
-  importerSet?: Set<string>;
-}
+import ts from "typescript";
+import { PathUtil } from "@simplysm/sd-core-node";
+import sass from "sass";
+import { fileURLToPath, pathToFileURL, URL } from "url";
+
+export class SdCliNgCacheCompilerHost {
+  public static wrap(compilerHost: ts.CompilerHost,
+                     sourceFileCache: Map<string, IFileCache>): ts.CompilerHost {
+    const cacheCompilerHost = { ...compilerHost };
+
+    cacheCompilerHost["readResource"] = (fileName: string) => {
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+      if (cache.content === undefined) {
+        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
+      }
+      return cache.content;
+    };
+
+    cacheCompilerHost["transformResource"] = async (data, context) => {
+      if (context.resourceFile != null || context.type !== "style") {
+        return null;
+      }
+
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(context.containingFile), {});
+      if (cache.styleContent === undefined) {
+        const scssResult = await sass.compileStringAsync(data, {
+          url: new URL((context.containingFile as string) + ".sd.scss"),
+          importer: {
+            findFileUrl: (url) => {
+              if (!url.startsWith("~")) return pathToFileURL(url);
+              return new URL(url.substring(1), pathToFileURL("node_modules"));
+            }
+          }
+        });
+
+        cache.styleContent = scssResult.css.toString();
+
+        const deps = scssResult.loadedUrls.slice(1).map((item) => PathUtil.posix(fileURLToPath(item.href)));
+        for (const dep of deps) {
+          const depCache = sourceFileCache.getOrCreate(dep, {});
+          depCache.importerSet = depCache.importerSet ?? new Set<string>();
+          depCache.importerSet.add(PathUtil.posix(context.containingFile));
+        }
+      }
+      return { content: cache.styleContent };
+    };
+
+    return cacheCompilerHost;
+  }
+}
+
+interface IFileCache {
+  exists?: boolean;
+  sourceFile?: ts.SourceFile;
+  content?: string;
+  styleContent?: string;
+  importerSet?: Set<string>;
+}

package/src/build-tool/SdCliPackageLinter.ts

@@ -1,74 +1,74 @@
-import { ISdCliPackageBuildResult } from "../commons";
-import ts from "typescript";
-import { FsUtil } from "@simplysm/sd-core-node";
-import path from "path";
-import { ESLint } from "eslint";
-
-export class SdCliPackageLinter {
-  private readonly _lintResultCache = new Map<string, ISdCliPackageBuildResult[]>();
-
-  public constructor(private readonly _rootPath: string) {
-  }
-
-  public async lintAsync(filePaths: string[], program?: ts.Program): Promise<ISdCliPackageBuildResult[]> {
-    if (!FsUtil.exists(path.resolve(this._rootPath, ".eslintrc.cjs"))) return [];
-
-    const linter = new ESLint(
-      program && filePaths.some((item) => item.endsWith(".ts")) ? {
-        overrideConfig: {
-          overrides: [
-            {
-              files: ["*.ts"],
-              parserOptions: {
-                /*programs: [program],
-                tsconfigRootDir: null,
-                project: null*/
-                tsconfigRootDir: this._rootPath,
-                project: "tsconfig-build.json"
-              },
-              settings: {
-                "import/resolver": {
-                  "typescript": {
-                    /*programs: [program],
-                    project: null*/
-                    project: path.resolve(this._rootPath, "tsconfig-build.json")
-                  }
-                }
-              }
-            }
-          ]
-        }
-      } : {}
-    );
-
-    const lintFilePaths = await filePaths
-      .filterAsync(async (filePath) => (
-        !filePath.endsWith(".d.ts") &&
-        /\.[cm]?[tj]sx?$/.test(filePath) &&
-        !(await linter.isPathIgnored(filePath))
-      ));
-    for (const lintFilePath of lintFilePaths) {
-      this._lintResultCache.delete(lintFilePath);
-    }
-
-    const lintResults = await linter.lintFiles(lintFilePaths);
-
-    const result = lintResults.map((lintResult) => ({
-      filePath: lintResult.filePath,
-      results: lintResult.messages.map((msg) => ({
-        filePath: lintResult.filePath,
-        line: msg.line,
-        char: msg.column,
-        code: msg.ruleId ?? undefined,
-        severity: msg.severity === 1 ? "warning" as const : "error" as const,
-        message: msg.message
-      }))
-    }));
-
-    for (const resultItem of result) {
-      this._lintResultCache.set(resultItem.filePath, resultItem.results);
-    }
-
-    return Array.from(this._lintResultCache.values()).mapMany();
-  }
-}
+import { ISdCliPackageBuildResult } from "../commons";
+import ts from "typescript";
+import { FsUtil } from "@simplysm/sd-core-node";
+import path from "path";
+import { ESLint } from "eslint";
+
+export class SdCliPackageLinter {
+  private readonly _lintResultCache = new Map<string, ISdCliPackageBuildResult[]>();
+
+  public constructor(private readonly _rootPath: string) {
+  }
+
+  public async lintAsync(filePaths: string[], program?: ts.Program): Promise<ISdCliPackageBuildResult[]> {
+    if (!FsUtil.exists(path.resolve(this._rootPath, ".eslintrc.cjs"))) return [];
+
+    const linter = new ESLint(
+      program && filePaths.some((item) => item.endsWith(".ts")) ? {
+        overrideConfig: {
+          overrides: [
+            {
+              files: ["*.ts"],
+              parserOptions: {
+                /*programs: [program],
+                tsconfigRootDir: null,
+                project: null*/
+                tsconfigRootDir: this._rootPath,
+                project: "tsconfig-build.json"
+              },
+              settings: {
+                "import/resolver": {
+                  "typescript": {
+                    /*programs: [program],
+                    project: null*/
+                    project: path.resolve(this._rootPath, "tsconfig-build.json")
+                  }
+                }
+              }
+            }
+          ]
+        }
+      } : {}
+    );
+
+    const lintFilePaths = await filePaths
+      .filterAsync(async (filePath) => (
+        !filePath.endsWith(".d.ts") &&
+        /\.[cm]?[tj]sx?$/.test(filePath) &&
+        !(await linter.isPathIgnored(filePath))
+      ));
+    for (const lintFilePath of lintFilePaths) {
+      this._lintResultCache.delete(lintFilePath);
+    }
+
+    const lintResults = await linter.lintFiles(lintFilePaths);
+
+    const result = lintResults.map((lintResult) => ({
+      filePath: lintResult.filePath,
+      results: lintResult.messages.map((msg) => ({
+        filePath: lintResult.filePath,
+        line: msg.line,
+        char: msg.column,
+        code: msg.ruleId ?? undefined,
+        severity: msg.severity === 1 ? "warning" as const : "error" as const,
+        message: msg.message
+      }))
+    }));
+
+    for (const resultItem of result) {
+      this._lintResultCache.set(resultItem.filePath, resultItem.results);
+    }
+
+    return Array.from(this._lintResultCache.values()).mapMany();
+  }
+}

package/src/builder/SdCliClientBuilder.ts

@@ -46,6 +46,8 @@ export class SdCliClientBuilder extends EventEmitter {
 
   private readonly _hasAngularRoute: boolean;
 
+  private readonly _cacheBasePath = path.resolve(this._rootPath, ".cache");
+
   public constructor(private readonly _rootPath: string,
                      private readonly _config: ISdCliClientPackageConfig,
                      private readonly _workspaceRootPath: string) {
@@ -92,11 +94,39 @@ export class SdCliClientBuilder extends EventEmitter {
     return super.on(event, listener);
   }
 
+  private async _checkCacheAsync(watch: boolean): Promise<void> {
+    const workspacePkgLockContent = await FsUtil.readFileAsync(path.resolve(this._workspaceRootPath, "package-lock.json"));
+
+    // const cachePath = path.resolve(cacheBasePath, pkgVersion);
+
+    const versionHash = createHash("sha1")
+      .update(workspacePkgLockContent)
+      .update(JSON.stringify(this._parsedTsconfig.options))
+      .update(JSON.stringify(this._config))
+      .update(watch.toString())
+      .digest("hex");
+    if (
+      !FsUtil.exists(path.resolve(this._cacheBasePath, "version")) // 버전파일이 없거나
+      || (
+        FsUtil.exists(path.resolve(this._cacheBasePath, "version")) &&
+        await FsUtil.readFileAsync(path.resolve(this._cacheBasePath, "version")) !== versionHash
+      ) // 버전이 현재 버전과 다르면
+    ) {
+      // 캐시 삭제
+      await FsUtil.removeAsync(path.resolve(this._cacheBasePath));
+    }
+    // 버전쓰기
+    await FsUtil.writeFileAsync(path.resolve(this._cacheBasePath, "version"), versionHash);
+  }
+
   public async watchAsync(): Promise<void> {
     // DIST 비우기
     await FsUtil.removeAsync(path.resolve(this._rootPath, ".electron"));
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
+    // 캐시체크
+    await this._checkCacheAsync(true);
+
     // NgModule 생성
     await this._ngModuleGenerator.runAsync();
 
@@ -111,11 +141,15 @@ export class SdCliClientBuilder extends EventEmitter {
       .map((builderType) => this._getWebpackConfig(true, builderType));
     const multiCompiler = webpack(webpackConfigs);
     await new Promise<void>((resolve, reject) => {
+      const invalidFiles: string[] = [];
       multiCompiler.hooks.invalid.tap(this.constructor.name, (fileName) => {
         if (fileName != null) {
           this._logger.debug("파일변경 감지", fileName);
+
           // NgModule 캐시 삭제
           this._ngModuleGenerator.removeCaches([path.resolve(fileName)]);
+
+          invalidFiles.push(fileName);
         }
       });
 
@@ -144,9 +178,6 @@ export class SdCliClientBuilder extends EventEmitter {
           return;
         }
 
-        // 결과 반환
-        const results = multiStats.stats.mapMany((stats) => SdCliBuildResultUtil.convertFromWebpackStats(stats));
-
         // .config.json 파일 쓰기
         const npmConfig = this._getNpmConfig(this._rootPath)!;
         const packageKey = npmConfig.name.split("/").last()!;
@@ -156,11 +187,14 @@ export class SdCliClientBuilder extends EventEmitter {
           : path.resolve(this._parsedTsconfig.options.outDir!, ".config.json");
         await FsUtil.writeFileAsync(configDistPath, JSON.stringify(this._config.configs ?? {}, undefined, 2));
 
-        // 마무리
+        // 완료 로그
         this._logger.debug("Webpack 빌드 완료");
-        resolve();
 
+        // 결과 반환
+        const results = multiStats.stats.mapMany((stats) => SdCliBuildResultUtil.convertFromWebpackStats(stats));
         this.emit("complete", results);
+
+        resolve();
       });
     });
   }
@@ -172,6 +206,9 @@ export class SdCliClientBuilder extends EventEmitter {
     this._logger.debug("removeAsync:2");
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
+    // 캐시체크
+    await this._checkCacheAsync(false);
+
     // NgModule 생성
     this._logger.debug("ngModule");
     await this._ngModuleGenerator.runAsync();
@@ -211,7 +248,7 @@ export class SdCliClientBuilder extends EventEmitter {
       await augmentAppWithServiceWorker(
         PathUtil.posix(path.relative(this._workspaceRootPath, this._rootPath)) as any,
         PathUtil.posix(path.relative(this._workspaceRootPath, path.resolve(this._parsedTsconfig.options.outDir!))) as any,
-        `/${packageKey}/`,
+        `/${packageKey}/` as any,
         PathUtil.posix(path.relative(this._workspaceRootPath, path.resolve(this._rootPath, "ngsw-config.json")))
       );
     }
@@ -264,7 +301,8 @@ export class SdCliClientBuilder extends EventEmitter {
         "NODE_ENV=production",
         `SD_VERSION=${npmConfig.version}`,
         (this._config.builder.electron.icon !== undefined) ? `SD_ELECTRON_ICON=${this._config.builder.electron.icon}` : `SD_ELECTRON_ICON=favicon.ico`,
-        ...(this._config.env !== undefined) ? Object.keys(this._config.env).map((key) => `${key}=${this._config.env![key]}`) : []
+        ...(this._config.env !== undefined) ? Object.keys(this._config.env).map((key) => `${key}=${this._config.env![key]}`) : [],
+        ...(this._config.builder.electron.env !== undefined) ? Object.keys(this._config.builder.electron.env).map((key) => `${key}=${this._config.builder!.electron!.env![key]}`) : []
       ].filterExists().join("\n"));
 
       let electronTsFileContent = await FsUtil.readFileAsync(path.resolve(this._rootPath, `src/electron.ts`));
@@ -328,8 +366,6 @@ export class SdCliClientBuilder extends EventEmitter {
     const pkgKey = npmConfig.name.split("/").last()!;
     const publicPath = builderType === "web" ? `/${pkgKey}/` : watch ? `/${pkgKey}/${builderType}/` : ``;
 
-    const cacheBasePath = path.resolve(this._rootPath, ".cache");
-
     const distPath = (builderType === "cordova" && !watch) ? path.resolve(this._cordova!.cordovaPath, "www")
       : (builderType === "electron" && !watch) ? path.resolve(this._rootPath, ".electron/src")
         : builderType === "web" ? this._parsedTsconfig.options.outDir
@@ -341,6 +377,25 @@ export class SdCliClientBuilder extends EventEmitter {
     const polyfillsFilePath = path.resolve(this._rootPath, "src/polyfills.ts");
     const stylesFilePath = path.resolve(this._rootPath, "src/styles.scss");
 
+    const versionHash = createHash("sha1")
+      .update(workspacePkgLockContent)
+      .update(JSON.stringify(this._parsedTsconfig.options))
+      .update(JSON.stringify(this._config))
+      .update(watch.toString())
+      .digest("hex");
+    if (
+      !FsUtil.exists(path.resolve(this._cacheBasePath, "version")) // 버전파일이 없거나
+      || (
+        FsUtil.exists(path.resolve(this._cacheBasePath, "version")) &&
+        FsUtil.readFile(path.resolve(this._cacheBasePath, "version")) !== versionHash
+      ) // 버전이 현재 버전과 다르면
+    ) {
+      // 캐시 삭제
+      FsUtil.remove(path.resolve(this._cacheBasePath));
+    }
+    // 버전쓰기
+    FsUtil.writeFile(path.resolve(this._cacheBasePath, "version"), versionHash);
+
     let prevProgressMessage = "";
     return {
       mode: watch ? "development" : "production",
@@ -395,14 +450,9 @@ export class SdCliClientBuilder extends EventEmitter {
       cache: {
         type: "filesystem",
         profile: undefined,
-        cacheDirectory: path.resolve(cacheBasePath, "angular-webpack"),
+        cacheDirectory: this._cacheBasePath,
         maxMemoryGenerations: 1,
-        name: createHash("sha1")
-          .update(workspacePkgLockContent)
-          .update(JSON.stringify(this._parsedTsconfig.options))
-          .update(JSON.stringify(this._config))
-          .update(watch.toString())
-          .digest("hex")
+        name: "webpack"
       },
       snapshot: {
         immutablePaths: internalModuleCachePaths,
@@ -482,7 +532,7 @@ export class SdCliClientBuilder extends EventEmitter {
               {
                 loader: "@angular-devkit/build-angular/src/babel/webpack-loader",
                 options: {
-                  cacheDirectory: path.resolve(cacheBasePath, "babel-webpack"),
+                  cacheDirectory: path.resolve(this._cacheBasePath, "webpack-babel"),
                   scriptTarget: ts.ScriptTarget.ES2017,
                   aot: true,
                   optimize: !watch,
@@ -689,8 +739,8 @@ export class SdCliClientBuilder extends EventEmitter {
           sri: false,
           cache: {
             enabled: true,
-            basePath: cacheBasePath,
-            path: path.resolve(cacheBasePath, "index-webpack")
+            basePath: this._cacheBasePath,
+            path: path.resolve(this._cacheBasePath, "webpack-html")
           },
           postTransform: undefined,
           optimization: {
@@ -703,7 +753,8 @@ export class SdCliClientBuilder extends EventEmitter {
         }),
         new webpack.EnvironmentPlugin({
           SD_VERSION: this._getNpmConfig(this._rootPath)!.version,
-          ...this._config.env
+          ...this._config.env,
+          ...this._config.builder?.[builderType]?.env
         }),
         new ESLintWebpackPlugin({
           context: this._rootPath,

package/src/builder/SdCliJsLibBuilder.ts

@@ -1,70 +1,70 @@
-import { ISdCliPackageBuildResult } from "../commons";
-import { EventEmitter } from "events";
-import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
-import path from "path";
-import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
-
-export class SdCliJsLibBuilder extends EventEmitter {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
-
-  private readonly _linter: SdCliPackageLinter;
-
-  public constructor(private readonly _rootPath: string) {
-    super();
-    this._linter = new SdCliPackageLinter(this._rootPath);
-  }
-
-  public override on(event: "change", listener: () => void): this;
-  public override on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
-  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
-    return super.on(event, listener);
-  }
-
-  public async watchAsync(): Promise<void> {
-    this.emit("change");
-
-    const relatedPaths = await this.getRelatedPathsAsync();
-    const watcher = SdFsWatcher.watch(relatedPaths);
-    watcher.onChange({}, async (changedInfos) => {
-      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
-      if (changeFilePaths.length === 0) return;
-
-      this._logger.debug("파일 변경 감지");
-      this.emit("change");
-      const watchBuildResults: ISdCliPackageBuildResult[] = [];
-
-      const lintFilePaths = changedInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path);
-      if (lintFilePaths.length > 0) {
-        watchBuildResults.push(...await this._linter.lintAsync(lintFilePaths));
-      }
-
-      const watchRelatedPaths = await this.getRelatedPathsAsync();
-      watcher.add(watchRelatedPaths);
-
-      this.emit("complete", watchBuildResults);
-    });
-
-    // 빌드
-    const buildResults = await this._linter.lintAsync(relatedPaths);
-
-    this.emit("complete", buildResults);
-  }
-
-  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    const relatedPaths = await this.getRelatedPathsAsync();
-    return await this._linter.lintAsync(relatedPaths);
-  }
-
-  private async getRelatedPathsAsync(): Promise<string[]> {
-    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs)");
-    const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
-      ignore: [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/.*/**"
-      ]
-    });
-
-    return [...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
-  }
-}
+import { ISdCliPackageBuildResult } from "../commons";
+import { EventEmitter } from "events";
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import path from "path";
+import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
+
+export class SdCliJsLibBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  private readonly _linter: SdCliPackageLinter;
+
+  public constructor(private readonly _rootPath: string) {
+    super();
+    this._linter = new SdCliPackageLinter(this._rootPath);
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    return super.on(event, listener);
+  }
+
+  public async watchAsync(): Promise<void> {
+    this.emit("change");
+
+    const relatedPaths = await this.getRelatedPathsAsync();
+    const watcher = SdFsWatcher.watch(relatedPaths);
+    watcher.onChange({}, async (changedInfos) => {
+      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+      if (changeFilePaths.length === 0) return;
+
+      this._logger.debug("파일 변경 감지");
+      this.emit("change");
+      const watchBuildResults: ISdCliPackageBuildResult[] = [];
+
+      const lintFilePaths = changedInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path);
+      if (lintFilePaths.length > 0) {
+        watchBuildResults.push(...await this._linter.lintAsync(lintFilePaths));
+      }
+
+      const watchRelatedPaths = await this.getRelatedPathsAsync();
+      watcher.add(watchRelatedPaths);
+
+      this.emit("complete", watchBuildResults);
+    });
+
+    // 빌드
+    const buildResults = await this._linter.lintAsync(relatedPaths);
+
+    this.emit("complete", buildResults);
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    const relatedPaths = await this.getRelatedPathsAsync();
+    return await this._linter.lintAsync(relatedPaths);
+  }
+
+  private async getRelatedPathsAsync(): Promise<string[]> {
+    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs)");
+    const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/.*/**"
+      ]
+    });
+
+    return [...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
+  }
+}