@simplysm/sd-cli 7.3.4 → 10.0.21

package/src/build-tool/SdCliCacheCompilerHost.ts

@@ -1,79 +0,0 @@
-import ts from "typescript";
-import { PathUtil } from "@simplysm/sd-core-node";
-
-export class SdCliCacheCompilerHost {
-  public static create(parsedTsconfig: ts.ParsedCommandLine,
-                       moduleResolutionCache: ts.ModuleResolutionCache,
-                       sourceFileCache: Map<string, IFileCache>,
-                       outputFileCache: Map<string, string>): ts.CompilerHost {
-    const compilerHost = ts.createIncrementalCompilerHost(parsedTsconfig.options);
-
-    const cacheCompilerHost = { ...compilerHost };
-
-    cacheCompilerHost.fileExists = (fileName: string) => {
-      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (cache.exists === undefined) {
-        cache.exists = compilerHost.fileExists.call(cacheCompilerHost, fileName);
-      }
-      return cache.exists;
-    };
-
-    cacheCompilerHost.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget) => {
-      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (!cache.sourceFile) {
-        cache.sourceFile = compilerHost.getSourceFile.call(cacheCompilerHost, fileName, languageVersion);
-      }
-      return cache.sourceFile;
-    };
-
-    cacheCompilerHost.writeFile = (fileName: string,
-                                   data: string,
-                                   writeByteOrderMark: boolean,
-                                   onError?: (message: string) => void,
-                                   sourceFiles?: readonly ts.SourceFile[]) => {
-      if (parsedTsconfig.options.module === ts.ModuleKind.CommonJS) {
-        fileName = fileName.replace(/\.js(\.map)?$/, ".cjs$1");
-        data = data.replace(/\.js\.map$/, ".cjs.map");
-      }
-      else {
-        fileName = fileName.replace(/\.js(\.map)?$/, ".mjs$1");
-        data = data.replace(/\.js\.map$/, ".mjs.map");
-      }
-
-
-      const writeCache = outputFileCache.get(PathUtil.posix(fileName));
-      if (writeCache !== data) {
-        outputFileCache.set(PathUtil.posix(fileName), data);
-        compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
-      }
-    };
-
-    cacheCompilerHost.readFile = (fileName: string) => {
-      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (cache.content === undefined) {
-        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
-      }
-      return cache.content;
-    };
-
-    cacheCompilerHost.resolveModuleNames = (moduleNames: string[], containingFile: string) => {
-      return moduleNames.map((moduleName) => {
-        return ts.resolveModuleName(
-          moduleName,
-          PathUtil.posix(containingFile),
-          parsedTsconfig.options,
-          compilerHost,
-          moduleResolutionCache
-        ).resolvedModule;
-      });
-    };
-
-    return cacheCompilerHost;
-  }
-}
-
-interface IFileCache {
-  exists?: boolean;
-  sourceFile?: ts.SourceFile;
-  content?: string;
-}

package/src/build-tool/SdCliCordova.ts

@@ -1,263 +0,0 @@
-import { INpmConfig, ISdCliClientBuilderCordovaConfig } from "../commons";
-import * as path from "path";
-import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
-import xml2js from "xml2js";
-
-export class SdCliCordova {
-  protected readonly _logger: Logger;
-
-  private readonly _npmConfig: INpmConfig;
-
-  public readonly cordovaPath = path.resolve(this._rootPath, ".cache", "cordova");
-  private readonly _binPath = path.resolve(process.cwd(), "node_modules/.bin/cordova.cmd");
-
-  public get platforms(): ("browser" | "android")[] {
-    return [
-      ...this._config.target?.browser ? ["browser" as const] : [],
-      ...this._config.target?.android ? ["android" as const] : []
-    ];
-  }
-
-  public constructor(private readonly _rootPath: string, private readonly _config: ISdCliClientBuilderCordovaConfig) {
-    this._npmConfig = FsUtil.readJson(path.resolve(this._rootPath, "package.json"));
-    this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, this._npmConfig.name]);
-  }
-
-  private async _execAsync(cmd: string, cwd: string): Promise<void> {
-    this._logger.debug(cmd);
-    const msg = await SdProcess.spawnAsync(cmd, { cwd });
-    this._logger.debug(msg);
-  }
-
-  public async initializeAsync(): Promise<void> {
-    if (FsUtil.exists(this.cordovaPath)) {
-      this._logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
-    }
-    else {
-      await this._execAsync(`${this._binPath} telemetry on`, this._rootPath);
-
-      // 프로젝트 생성
-      await this._execAsync(`${this._binPath} create "${this.cordovaPath}" "${this._config.appId}" "${this._config.appName}"`, process.cwd());
-    }
-
-    // platforms 폴더 혹시 없으면 생성
-    await FsUtil.mkdirsAsync(path.resolve(this.cordovaPath, "platforms"));
-
-    // www 폴더 혹시 없으면 생성
-    await FsUtil.mkdirsAsync(path.resolve(this.cordovaPath, "www"));
-
-    // 미설치 빌드 플랫폼 신규 생성
-    const alreadyPlatforms = await FsUtil.readdirAsync(path.resolve(this.cordovaPath, "platforms"));
-    for (const platform of this.platforms) {
-      if (!alreadyPlatforms.includes(platform)) {
-        await this._execAsync(`${this._binPath} platform add ${platform}`, this.cordovaPath);
-      }
-    }
-
-    // 설치 미빌드 플랫폼 삭제
-    for (const alreadyPlatform of alreadyPlatforms) {
-      if (this._config.target?.[alreadyPlatform] == null) {
-        await this._execAsync(`${this._binPath} platform remove ${alreadyPlatform}`, this.cordovaPath);
-      }
-    }
-
-    // 설치된 미사용 플러그인 삭제
-    const pluginsFetch = FsUtil.exists(path.resolve(this.cordovaPath, "plugins/fetch.json"))
-      ? await FsUtil.readJsonAsync(path.resolve(this.cordovaPath, "plugins/fetch.json"))
-      : undefined;
-    const alreadyPluginIds = pluginsFetch != undefined
-      ? Object.values(pluginsFetch)
-        .map((item: any) => (item.source.id !== undefined ? item.source.id : item.source.url))
-      : [];
-    const usePlugins = ["cordova-plugin-ionic-webview", ...this._config.plugins ?? []].distinct();
-
-    for (const alreadyPluginId of alreadyPluginIds) {
-      let hasPlugin = false;
-      for (const usePlugin of usePlugins) {
-        if (
-          (usePlugin.includes("@") && alreadyPluginId === usePlugin) ||
-          (!usePlugin.includes("@") && alreadyPluginId.replace(/@.*$/, "") === usePlugin)
-        ) {
-          hasPlugin = true;
-          break;
-        }
-      }
-
-      if (!hasPlugin) {
-        await this._execAsync(`${this._binPath} plugin remove ${alreadyPluginId.replace(/@.*$/, "")}`, this.cordovaPath);
-      }
-    }
-
-    // 미설치 플러그인들 설치
-    for (const usePlugin of usePlugins) {
-      if (
-        (usePlugin.includes("@") && !alreadyPluginIds.includes(usePlugin)) ||
-        (!usePlugin.includes("@") && !alreadyPluginIds.map((alreadyPluginId) => alreadyPluginId.replace(/@.*$/, "")).includes(usePlugin))
-      ) {
-        await this._execAsync(`${this._binPath} plugin add ${usePlugin}`, this.cordovaPath);
-      }
-    }
-
-    // ANDROID SIGN 파일 복사
-    if (this._config.target?.android?.sign) {
-      await FsUtil.copyAsync(
-        path.resolve(this._rootPath, this._config.target.android.sign.keystore),
-        path.resolve(this.cordovaPath, "android.keystore")
-      );
-    }
-    else {
-      await FsUtil.removeAsync(path.resolve(this.cordovaPath, "android.keystore"));
-      // SIGN을 안쓸경우 아래 파일이 생성되어 있으면 오류남
-      await FsUtil.removeAsync(path.resolve(this.cordovaPath, "platforms/android/release-signing.properties"));
-    }
-
-    // 빌드 옵션 파일 생성
-    await FsUtil.writeJsonAsync(
-      path.resolve(this.cordovaPath, "build.json"),
-      {
-        ...this._config.target?.android ? {
-          android: {
-            release: {
-              packageType: this._config.target.android.bundle ? "bundle" : "apk",
-              ...this._config.target.android.sign ? {
-                keystore: path.resolve(this.cordovaPath, "android.keystore"),
-                storePassword: this._config.target.android.sign.storePassword,
-                alias: this._config.target.android.sign.alias,
-                password: this._config.target.android.sign.password,
-                keystoreType: this._config.target.android.sign.keystoreType
-              } : {}
-            }
-          }
-        } : {}
-      }
-    );
-
-    // ICON 파일 복사
-    if (this._config.icon !== undefined) {
-      await FsUtil.copyAsync(path.resolve(this._rootPath, this._config.icon), path.resolve(this.cordovaPath, "res", "icon.png"));
-    }
-    else {
-      await FsUtil.removeAsync(path.resolve(this.cordovaPath, "res", "icon.png"));
-    }
-
-    // CONFIG: 초기값 백업
-    const configFilePath = path.resolve(this.cordovaPath, "config.xml");
-    const configBackFilePath = path.resolve(this.cordovaPath, "config.xml.bak");
-    if (!FsUtil.exists(configBackFilePath)) {
-      await FsUtil.copyAsync(configFilePath, configBackFilePath);
-    }
-
-    // CONFIG: 초기값 읽기
-    const configFileContent = await FsUtil.readFileAsync(configBackFilePath);
-    const configXml = await xml2js.parseStringPromise(configFileContent);
-
-
-    // CONFIG: 버전 설정
-    configXml.widget.$.version = this._npmConfig.version;
-
-    // CONFIG: ICON 설정
-    if (this._config.icon !== undefined) {
-      configXml["widget"]["icon"] = [{ "$": { "src": "res/icon.png" } }];
-    }
-
-    // CONFIG: 접근허용 세팅
-    configXml["widget"]["access"] = [{ "$": { "origin": "*" } }];
-    configXml["widget"]["allow-navigation"] = [{ "$": { "href": "*" } }];
-    configXml["widget"]["allow-intent"] = [{ "$": { "href": "*" } }];
-    configXml["widget"]["preference"] = [{ "$": { "name": "MixedContentMode", "value": "0" } }];
-
-    // CONFIG: ANDROID usesCleartextTraffic 설정
-    if (this._config.target?.android) {
-      configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
-
-      configXml["widget"]["platform"] = configXml["widget"]["platform"] ?? [];
-      configXml["widget"]["platform"].push({
-        "$": {
-          "name": "android"
-        },
-        "edit-config": [{
-          "$": {
-            "file": "app/src/main/AndroidManifest.xml",
-            "mode": "merge",
-            "target": "/manifest/application"
-          },
-          "application": [{
-            "$": {
-              "android:usesCleartextTraffic": "true"
-            }
-          }]
-        }]
-      });
-    }
-
-    // CONFIG: 파일 새로 쓰기
-    const configResultContent = new xml2js.Builder().buildObject(configXml);
-    await FsUtil.writeFileAsync(configFilePath, configResultContent);
-
-    // 각 플랫폼 www 준비
-    await this._execAsync(`${this._binPath} prepare`, this.cordovaPath);
-  }
-
-  public async buildAsync(outPath: string): Promise<void> {
-    // 실행
-    const buildType = this._config.debug ? "debug" : "release";
-    for (const platform of this.platforms) {
-      await this._execAsync(`${this._binPath} build ${platform} --${buildType}`, this.cordovaPath);
-    }
-
-    // 결과물 복사: ANDROID
-    if (this._config.target?.android) {
-      const targetOutPath = path.resolve(outPath, "android");
-      const apkFileName = this._config.target.android.sign ? `app-${buildType}.apk` : `app-${buildType}-unsigned.apk`;
-      // const distApkFileName = path.basename(`${this._config.appName}${this._config.target.android.sign ? "" : "-unsigned"}-v${this._npmConfig.version}.apk`);
-      const latestDistApkFileName = path.basename(`${this._config.appName}${this._config.target.android.sign ? "" : "-unsigned"}-latest.apk`);
-      await FsUtil.mkdirsAsync(targetOutPath);
-      // await FsUtil.copyAsync(
-      //   path.resolve(this.cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName),
-      //   path.resolve(targetOutPath, distApkFileName)
-      // );
-      await FsUtil.copyAsync(
-        path.resolve(this.cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName),
-        path.resolve(targetOutPath, latestDistApkFileName)
-      );
-      // 자동업데이트를 위한 파일 쓰기
-      await FsUtil.copyAsync(
-        path.resolve(this.cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName),
-        path.resolve(path.resolve(targetOutPath, "updates"), this._npmConfig.version + ".apk")
-      );
-    }
-
-    /*if (this._config.target?.android) {
-      // 자동업데이트를 위한 zip 파일 쓰기
-      const zip = new JSZip();
-      const resultFiles = await FsUtil.globAsync(path.resolve(this.cordovaPath, "platforms", "android", "app", "src", "main", "assets", "www", "**!/!*"), {
-        dot: true,
-        nodir: true
-      });
-      for (const resultFile of resultFiles) {
-        const contentBuffer = await FsUtil.readFileBufferAsync(resultFile);
-        const relativePath = path.relative(path.resolve(this.cordovaPath, "platforms", "android", "app", "src", "main", "assets", "www"), resultFile);
-        zip.file("/" + relativePath, contentBuffer);
-      }
-
-      const zipFileName = path.basename(`${this._npmConfig.version}.zip`);
-      const resultBuffer = await zip.generateAsync({ type: "nodebuffer" });
-
-      await FsUtil.writeFileAsync(path.resolve(outPath, "android/updates/", zipFileName), resultBuffer);
-    }*/
-  }
-
-  public static async runWebviewOnDeviceAsync(rootPath: string, platform: "browser" | "android", pkgName: string, url?: string): Promise<void> {
-    const cordovaPath = path.resolve(rootPath, `packages/${pkgName}/.cache/cordova/`);
-
-    if (url !== undefined) {
-      await FsUtil.removeAsync(path.resolve(cordovaPath, "www"));
-      await FsUtil.mkdirsAsync(path.resolve(cordovaPath, "www"));
-      await FsUtil.writeFileAsync(path.resolve(cordovaPath, "www/index.html"), `'${url}'로 이동중... <script>setTimeout(function () {window.location.href = "${url.replace(/\/$/, "")}/${pkgName}/cordova/"}, 3000);</script>`.trim());
-    }
-
-    const binPath = path.resolve(process.cwd(), "node_modules/.bin/cordova.cmd");
-    // await SdProcess.spawnAsync(`${binPath} build ${platform}`, { cwd: cordovaPath }, true);
-    await SdProcess.spawnAsync(`${binPath} run ${platform} --device`, { cwd: cordovaPath }, true);
-  }
-}

package/src/build-tool/SdCliElectron.ts

@@ -1,85 +0,0 @@
-import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
-import { INpmConfig, ISdCliClientPackageConfig } from "../commons";
-import path from "path";
-import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
-
-export class SdCliElectron {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
-
-  public constructor(private readonly _rootPath: string) {
-  }
-
-  public async runWebviewOnDeviceAsync(pkgName: string, url: string, opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
-    this._logger.debug("프로젝트 설정 가져오기...");
-    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), true, opt.optNames);
-    const pkgConfig = config.packages[pkgName] as ISdCliClientPackageConfig | undefined;
-    if (!pkgConfig) throw new Error("패키지 설정을 찾을 수 없습니다.");
-
-    const electronConfig = pkgConfig.builder?.electron;
-    if (!electronConfig) throw new Error("ELECTRON 설정을 찾을 수 없습니다.");
-
-    const pkgRootPath = path.resolve(this._rootPath, `packages/${pkgName}`);
-    const electronSrcPath = path.resolve(pkgRootPath, `dist/electron`);
-
-    // await FsUtil.removeAsync(electronSrcPath);
-
-    const npmConfig = (await FsUtil.readJsonAsync(path.resolve(pkgRootPath, `package.json`))) as INpmConfig;
-    const electronVersion = npmConfig.dependencies?.["electron"];
-    if (electronVersion === undefined) {
-      throw new Error("ELECTRON 빌드 패키지의 'dependencies'에는 'electron'이 반드시 포함되어야 합니다.");
-    }
-
-    const dotenvVersion = npmConfig.dependencies?.["dotenv"];
-    if (dotenvVersion === undefined) {
-      throw new Error("ELECTRON 빌드 패키지의 'dependencies'에는 'dotenv'가 반드시 포함되어야 합니다.");
-    }
-
-    // const remoteVersion = npmConfig.dependencies?.["@electron/remote"];
-
-    await FsUtil.writeJsonAsync(path.resolve(electronSrcPath, `package.json`), {
-      name: npmConfig.name,
-      version: npmConfig.version,
-      description: npmConfig.description,
-      main: "electron.js",
-      author: npmConfig.author,
-      license: npmConfig.license,
-      /*,
-      devDependencies: {
-        "electron": electronVersion.replace("^", "")
-      },
-      dependencies: {
-        "dotenv": dotenvVersion,
-        ...remoteVersion !== undefined ? {
-          "@electron/remote": remoteVersion
-        } : {}
-      }*/
-    });
-
-    // await FsUtil.copyAsync(path.resolve(pkgRootPath, "dist", "electron"), path.resolve(electronSrcPath));
-
-    // if (FsUtil.exists(path.resolve(pkgRootPath, "src/favicon.ico"))) {
-    //   await FsUtil.copyAsync(path.resolve(pkgRootPath, "src/favicon.ico"), path.resolve(electronSrcPath, "favicon.ico"));
-    // }
-    // if (FsUtil.exists(path.resolve(pkgRootPath, "src/assets"))) {
-    //   await FsUtil.copyAsync(path.resolve(pkgRootPath, "src/assets"), path.resolve(electronSrcPath, "assets"));
-    // }
-
-    await FsUtil.writeFileAsync(path.resolve(electronSrcPath, `.env`), [
-      "NODE_ENV=development",
-      `SD_TITLE=${npmConfig.description}`,
-      `SD_VERSION=${npmConfig.version}`,
-      `SD_ELECTRON_DEV_URL=${url.replace(/\/$/, "")}/${pkgName}/electron/`,
-      (electronConfig.icon !== undefined) ? `SD_ELECTRON_ICON=${electronConfig.icon}` : `SD_ELECTRON_ICON=favicon.ico`,
-      ...(pkgConfig.env !== undefined) ? Object.keys(pkgConfig.env).map((key) => `${key}=${pkgConfig.env![key]}`) : [],
-      ...(electronConfig.env !== undefined) ? Object.keys(electronConfig.env).map((key) => `${key}=${electronConfig.env![key]}`) : [],
-    ].filterExists().join("\n"));
-
-    // const electronTsFileContent = await FsUtil.readFileAsync(path.resolve(pkgRootPath, `src/electron.ts`));
-    // const result = ts.transpileModule(electronTsFileContent, { compilerOptions: { module: ts.ModuleKind.CommonJS } });
-    // await FsUtil.writeFileAsync(path.resolve(electronSrcPath, "electron.js"), result.outputText);
-
-    await SdProcess.spawnAsync("electron-rebuild", { cwd: pkgRootPath }, true);
-
-    await SdProcess.spawnAsync(`electron .`, { cwd: electronSrcPath }, true);
-  }
-}

package/src/build-tool/SdCliGithubApi.ts

@@ -1,111 +0,0 @@
-import https from "https";
-import { SdProcess } from "@simplysm/sd-core-node";
-import mime from "mime";
-
-export class SdCliGithubApi {
-  public constructor(private readonly _apiKey: string,
-                     private readonly _repoOwner: string,
-                     private readonly _repoName: string) {
-  }
-
-  public async uploadAsync(version: string, files: { name: string; buffer: Buffer }[]): Promise<void> {
-    const releaseId = await this._createReleaseTagAsync(version);
-
-    for (const file of files) {
-      await this._uploadFileAsync(releaseId, file.name, file.buffer);
-    }
-  }
-
-  private async _uploadFileAsync(releaseId: number, fileName: string, buffer: Buffer): Promise<void> {
-    const contentLength = buffer.length;
-
-    await new Promise<void>((resolve, reject) => {
-      const req = https.request(
-        `https://uploads.github.com/repos/${this._repoOwner}/${this._repoName}/releases/${releaseId}/assets?name=${fileName}&label=${fileName}`,
-        {
-          method: "POST",
-          headers: {
-            "Authorization": `token ${this._apiKey}`,
-            "Accept": "application/vnd.github.v3+json",
-            "User-Agent": "@simplysm/sd-cli:publish",
-            "Content-Length": contentLength,
-            "Content-Type": mime.getType(fileName)!
-          }
-        },
-        (res) => {
-          let dataBuffer = Buffer.from([]);
-          res.on("data", data => {
-            dataBuffer = Buffer.concat([dataBuffer, data]);
-          });
-
-          res.on("end", () => {
-            if (res.statusCode !== 201) {
-              const errObj = JSON.parse(dataBuffer.toString());
-              throw new Error(errObj.message + "(" + errObj.documentation_url + ")");
-            }
-            else {
-              resolve();
-            }
-          });
-        }
-      );
-
-      req.on("error", (error) => {
-        reject(error);
-      });
-      req.write(buffer);
-      req.end();
-    });
-  }
-
-  private async _createReleaseTagAsync(ver: string): Promise<number> {
-    const currentBranch = (await SdProcess.spawnAsync("git branch --show-current")).trim();
-
-    return await new Promise<number>((resolve, reject) => {
-      const req = https.request(
-        `https://api.github.com/repos/${this._repoOwner}/${this._repoName}/releases`,
-        {
-          method: "POST",
-          headers: {
-            "Authorization": `token ${this._apiKey}`,
-            "Accept": "application/vnd.github.v3+json",
-            "User-Agent": "@simplysm/sd-cli:publish"
-          }
-        },
-        (res) => {
-          let dataBuffer = Buffer.from([]);
-          res.on("data", data => {
-            dataBuffer = Buffer.concat([dataBuffer, data]);
-          });
-
-          res.on("end", () => {
-            if (res.statusCode !== 201) {
-              const errObj = JSON.parse(dataBuffer.toString());
-              throw new Error(errObj.message + "(" + errObj.documentation_url + ")");
-            }
-            else {
-              // console.log(JSON.parse(dataBuffer.toString()));
-              const resData = JSON.parse(dataBuffer.toString());
-              resolve(resData.id);
-            }
-          });
-        }
-      );
-
-      req.on("error", (error) => {
-        reject(error);
-      });
-
-      req.write(JSON.stringify({
-        tag_name: `v${ver}`,
-        target_commitish: currentBranch,
-        name: `v${ver}`,
-        body: `v${ver}`,
-        draft: false,
-        prerelease: false
-      }));
-
-      req.end();
-    });
-  }
-}

package/src/build-tool/SdCliIndexFileGenerator.ts

@@ -1,79 +0,0 @@
-import { ITsconfig } from "../commons";
-import path from "path";
-import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
-import chokidar from "chokidar";
-
-export class SdCliIndexFileGenerator {
-  private readonly _indexFilePath = path.resolve(this.rootPath, "src/index.ts");
-  private _contentCache: string | undefined;
-
-  public constructor(public readonly rootPath: string,
-                     public readonly config: ISdAutoIndexConfig) {
-    this._contentCache = FsUtil.exists(this._indexFilePath) ? FsUtil.readFile(this._indexFilePath) : undefined;
-  }
-
-  public async watchAsync(): Promise<void> {
-    const watcher = chokidar.watch([path.resolve(this.rootPath, "src")], { persistent: true });
-    watcher.on("add", async (filePath) => {
-      if (filePath.endsWith(".ts")) {
-        await this.runAsync();
-      }
-    });
-    watcher.on("unlink", async (filePath) => {
-      if (filePath.endsWith(".ts")) {
-        await this.runAsync();
-      }
-    });
-
-    await this.runAsync();
-  }
-
-  public async runAsync(): Promise<void> {
-    const importTexts: string[] = [];
-
-    // 옵션의 polyfills 를 모두 import
-    if (this.config.polyfills) {
-      for (const polyfill of this.config.polyfills) {
-        importTexts.push(`import "${polyfill}";`);
-      }
-    }
-
-    // 내부 파일들 import
-    const filePaths = await this._getFilePathsAsync();
-    for (const filePath of filePaths) {
-      const requirePath = PathUtil.posix(path.relative(path.dirname(this._indexFilePath), filePath))
-        .replace(/\.ts$/, "")
-        .replace(/\/index$/, "");
-
-      const sourceTsFileContent = await FsUtil.readFileAsync(filePath);
-      if (sourceTsFileContent.split("\n").some((line) => line.startsWith("export "))) {
-        importTexts.push(`export * from "./${requirePath}";`);
-      }
-      else {
-        importTexts.push(`import "./${requirePath}";`);
-      }
-    }
-
-    const content = importTexts.join("\n") + "\n";
-    const prevContent = this._contentCache;
-    this._contentCache = content;
-    if (content.trim() !== prevContent?.trim()) {
-      await FsUtil.writeFileAsync(this._indexFilePath, content);
-    }
-  }
-
-  private async _getFilePathsAsync(): Promise<string[]> {
-    const tsconfig: ITsconfig = await FsUtil.readJsonAsync(path.resolve(this.rootPath, "tsconfig.json"));
-    const entryFilePaths = tsconfig.files?.map((item) => path.resolve(this.rootPath, item)) ?? [];
-
-    return (await FsUtil.globAsync(path.resolve(this.rootPath, "src/**/*.ts"), { nodir: true }))
-      .filter((item) => (
-        !entryFilePaths.includes(item)
-        && item !== this._indexFilePath
-      ));
-  }
-}
-
-export interface ISdAutoIndexConfig {
-  polyfills?: string[];
-}

package/src/build-tool/SdCliNgCacheCompilerHost.ts

@@ -1,58 +0,0 @@
-import ts from "typescript";
-import { PathUtil } from "@simplysm/sd-core-node";
-import * as 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>;
-}