@simplysm/sd-cli 7.0.247 → 7.0.263

package/src/entry-points/SdCliWorkspace.ts

@@ -1,17 +1,15 @@
-import { FsUtil, Logger, PathUtil, SdProcess } from "@simplysm/sd-core-node";
+import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
 import path from "path";
 import { INpmConfig, ISdCliConfig, ISdCliPackageBuildResult } from "../commons";
 import { SdCliPackage } from "../packages/SdCliPackage";
-import { Uuid, Wait } from "@simplysm/sd-core-common";
+import { JsonConvert, Wait } from "@simplysm/sd-core-common";
 import os from "os";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
 import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
-import { SdServiceServer } from "@simplysm/sd-service-server";
 import { SdCliLocalUpdate } from "./SdCliLocalUpdate";
-import url from "url";
-import mime from "mime";
-import { NextHandleFunction } from "connect";
+import { fileURLToPath } from "url";
+import cp from "child_process";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -34,7 +32,8 @@ export class SdCliWorkspace {
     }
 
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync(config, opt.pkgs);
+    const allPkgs = await this._getPackagesAsync(config);
+    const pkgs = allPkgs.filter((pkg) => opt.pkgs.length === 0 || opt.pkgs.includes(path.basename(pkg.rootPath)));
 
     this._logger.debug("패키지 이벤트 설정...");
     let changeCount = 0;
@@ -69,11 +68,15 @@ export class SdCliWorkspace {
                 if (changePkg.config.type === "client") {
                   if (typeof changePkg.config.server === "string") {
                     const serverInfo = this._serverInfoMap.get(changePkg.config.server);
-                    serverInfo?.server?.broadcastReload();
+                    if (serverInfo) {
+                      await this._sendServerWorkerBroadcastReloadAsync(serverInfo);
+                    }
                   }
                   else {
                     const serverInfo = this._serverInfoMap.get("PORT:" + changePkg.config.server.port);
-                    serverInfo?.server?.broadcastReload();
+                    if (serverInfo) {
+                      await this._sendServerWorkerBroadcastReloadAsync(serverInfo);
+                    }
                   }
                 }
               }
@@ -100,35 +103,15 @@ export class SdCliWorkspace {
         if (pkg.config.type === "client") {
           await pkg.watchAsync();
 
-          const pkgMiddleware: NextHandleFunction = (req, res, next) => {
-            if (req.method === "GET") {
-              const urlObj = url.parse(req.url!, true, false);
-              const urlPathChain = decodeURI(urlObj.pathname!.slice(1)).split("/");
-              if (urlPathChain[0] === pkg.name.split("/").last()!) {
-                let targetFilePath = path.resolve(pkg.rootPath, "dist", ...urlPathChain.slice(1));
-                targetFilePath = FsUtil.exists(targetFilePath) && FsUtil.stat(targetFilePath).isDirectory() ? path.resolve(targetFilePath, "index.html") : targetFilePath;
-
-                if (FsUtil.exists(targetFilePath) && !path.basename(targetFilePath).startsWith(".")) {
-                  const fileStream = FsUtil.createReadStream(targetFilePath);
-                  const targetFileSize = FsUtil.lstat(targetFilePath).size;
-
-                  fileStream.on("open", () => {
-                    res.setHeader("Content-Length", targetFileSize);
-                    res.setHeader("Content-Type", mime.getType(targetFilePath)!);
-                    res.writeHead(200);
-                  });
-                  fileStream.pipe(res);
-                  return;
-                }
-              }
-            }
+          if (typeof pkg.config.server === "string") {
+            const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { pathProxy: [], clientInfos: [] });
 
-            next();
-          };
+            serverInfo.pathProxy.push({
+              from: pkg.name.split("/").last()!,
+              to: path.resolve(pkg.rootPath, "dist")
+            });
+            await this._reloadServerWorkerPathProxyAsync(serverInfo);
 
-          if (typeof pkg.config.server === "string") {
-            const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { middlewares: [], clientInfos: [] });
-            serverInfo.middlewares.push(pkgMiddleware);
             serverInfo.clientInfos.push({
               pkgKey: pkg.name.split("/").last()!,
               platforms: pkg.config.builder ? Object.keys(pkg.config.builder) : ["web"],
@@ -137,18 +120,20 @@ export class SdCliWorkspace {
           }
           else { // DEV SERVER
             const serverInfo = this._serverInfoMap.getOrCreate("PORT:" + pkg.config.server.port, {
-              middlewares: [],
+              pathProxy: [],
               clientInfos: []
             });
-            if (serverInfo.server === undefined) {
-              const server = new SdServiceServer({
-                rootPath: process.cwd(),
-                services: [],
-                port: pkg.config.server.port
+            if (serverInfo.worker === undefined) {
+              const serverWorkerInfo = await this._runServerWorkerAsync(pkg.config.server);
+              serverInfo.worker = serverWorkerInfo.worker;
+              serverInfo.url = serverWorkerInfo.url;
+
+              serverInfo.pathProxy.push({
+                from: pkg.name.split("/").last()!,
+                to: path.resolve(pkg.rootPath, "dist")
               });
-              await server.listenAsync();
-              serverInfo.server = server;
-              serverInfo.server.devMiddlewares = [pkgMiddleware];
+              await this._reloadServerWorkerPathProxyAsync(serverInfo);
+
               serverInfo.clientInfos.push({
                 pkgKey: pkg.name.split("/").last()!,
                 platforms: pkg.config.builder ? Object.keys(pkg.config.builder) : ["web"],
@@ -177,97 +162,21 @@ export class SdCliWorkspace {
     }
   }
 
-  private _isServerRestarting = false;
-
-  private async _restartServerAsync(pkg: SdCliPackage): Promise<void> {
-    await Wait.until(() => !this._isServerRestarting);
-
-    this._isServerRestarting = true;
-    const entryFileRelPath = pkg.main;
-    if (entryFileRelPath === undefined) {
-      this._logger.error(`서버패키지(${pkg.name})의 'package.json'에서 'main'필드를 찾을 수 없습니다.`);
-      this._isServerRestarting = false;
-      return;
-    }
-    const entryFilePath = path.resolve(pkg.rootPath, entryFileRelPath);
-
-    try {
-      const serverInfo = this._serverInfoMap.getOrCreate(path.basename(pkg.rootPath), {
-        middlewares: [],
-        clientInfos: []
-      });
-      if (serverInfo.server) {
-        this._logger.log(`[${pkg.name}] 기존 서버 중지...`);
-        await serverInfo.server.closeAsync();
-        delete serverInfo.server;
-      }
-
-      this._logger.log(`[${pkg.name}] 서버 시작중...`);
-
-      const serverMainPath = "file:///" + PathUtil.posix(entryFilePath) + "?update=" + Uuid.new().toString().replace(/-/g, "");
-      const serverModule = await import(serverMainPath);
-      serverInfo.server = serverModule.default as SdServiceServer | undefined;
-      if (!serverInfo.server) {
-        this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
-        this._isServerRestarting = false;
-        return;
-      }
-      serverInfo.server.devMiddlewares = serverInfo.middlewares;
-      await Wait.until(() => serverInfo.server!.isOpen);
-
-      this._logger.log(`[${pkg.name}] 서버가 시작되었습니다.`);
-    }
-    catch (err) {
-      this._logger.error(`서버(${pkg.name}) 재시작중 오류 발생`, err);
-    }
-
-    this._isServerRestarting = false;
-  }
-
   public async buildAsync(opt: { confFileRelPath: string; optNames: string[]; pkgs: string[] }): Promise<void> {
     this._logger.debug("프로젝트 설정 가져오기...");
     const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
 
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync(config, opt.pkgs);
+    const allPkgs = await this._getPackagesAsync(config);
+    const pkgs = allPkgs.filter((pkg) => opt.pkgs.length === 0 || opt.pkgs.includes(path.basename(pkg.rootPath)));
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
-    await this._upgradeVersionAsync(pkgs);
+    await this._upgradeVersionAsync(allPkgs);
 
     // 빌드
     await this._buildPkgsAsync(pkgs);
   }
 
-  private async _buildPkgsAsync(pkgs: SdCliPackage[]): Promise<void> {
-    this._logger.debug("빌드를 시작합니다...");
-    const pkgNames = pkgs.map((item) => item.name);
-    const buildCompletedPackageNames: string[] = [];
-    const totalResultMap = new Map<string, ISdCliPackageBuildResult[]>();
-    try {
-      await pkgs.parallelAsync(async (pkg) => {
-        await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
-
-        this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
-        totalResultMap.set(pkg.name, await pkg.buildAsync());
-        this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
-
-        buildCompletedPackageNames.push(pkg.name);
-      });
-
-      this._loggingResults(totalResultMap);
-      if (Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")) {
-        throw new Error("빌드중 오류가 발생하였습니다.");
-      }
-      else {
-        this._logger.info("모든 빌드가 완료되었습니다.");
-      }
-    }
-    catch (err) {
-      this._loggingResults(totalResultMap);
-      throw err;
-    }
-  }
-
   public async publishAsync(opt: { noBuild: boolean; confFileRelPath: string; optNames: string[]; pkgs: string[] }): Promise<void> {
     this._logger.debug("프로젝트 설정 가져오기...");
     const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
@@ -287,10 +196,11 @@ export class SdCliWorkspace {
     }
 
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync(config, opt.pkgs);
+    const allPkgs = await this._getPackagesAsync(config);
+    const pkgs = allPkgs.filter((pkg) => opt.pkgs.length === 0 || opt.pkgs.includes(path.basename(pkg.rootPath)));
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
-    await this._upgradeVersionAsync(pkgs);
+    await this._upgradeVersionAsync(allPkgs);
 
     // 빌드
     if (!opt.noBuild) {
@@ -322,6 +232,129 @@ export class SdCliWorkspace {
     this._logger.info(`모든 배포가 완료되었습니다. (v${this._npmConfig.version})`);
   }
 
+  private async _runServerWorkerAsync(filePathOrOpt: string | { port: number }): Promise<{ worker: cp.ChildProcess; url: string }> {
+    const workerPath = fileURLToPath(await import.meta.resolve!("../worker/server-worker"));
+    return await new Promise<{ worker: cp.ChildProcess; url: string }>((resolve, reject) => {
+      const worker = cp.fork(workerPath, [
+        JsonConvert.stringify(filePathOrOpt)
+      ], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        env: process.env
+      });
+
+      worker.on("error", (err) => {
+        reject(err);
+      });
+
+      worker.stdout!.pipe(process.stdout);
+      worker.stderr!.pipe(process.stderr);
+
+      worker.on("message", (url: string) => {
+        resolve({ worker, url });
+      });
+    });
+  }
+
+  private async _reloadServerWorkerPathProxyAsync(serverInfo: IServerInfo): Promise<void> {
+    if (!serverInfo.worker) return;
+
+    await new Promise<void>((resolve, reject) => {
+      serverInfo.worker!.send(JsonConvert.stringify(serverInfo.pathProxy), (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+
+  private async _sendServerWorkerBroadcastReloadAsync(serverInfo: IServerInfo): Promise<void> {
+    if (!serverInfo.worker) return;
+
+    await new Promise<void>((resolve, reject) => {
+      serverInfo.worker!.send("broadcastReload", (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+
+  private _isServerRestarting = false;
+
+  private async _restartServerAsync(pkg: SdCliPackage): Promise<void> {
+    await Wait.until(() => !this._isServerRestarting);
+
+    this._isServerRestarting = true;
+    const entryFileRelPath = pkg.main;
+    if (entryFileRelPath === undefined) {
+      this._logger.error(`서버패키지(${pkg.name})의 'package.json'에서 'main'필드를 찾을 수 없습니다.`);
+      this._isServerRestarting = false;
+      return;
+    }
+    const entryFilePath = path.resolve(pkg.rootPath, entryFileRelPath);
+
+    try {
+      const serverInfo = this._serverInfoMap.getOrCreate(path.basename(pkg.rootPath), {
+        pathProxy: [],
+        clientInfos: []
+      });
+      if (serverInfo.worker) {
+        this._logger.log(`[${pkg.name}] 기존 서버 중지...`);
+        cp.exec(`taskkill /pid ${serverInfo.worker.pid} /F /T`);
+        delete serverInfo.worker;
+        delete serverInfo.url;
+      }
+
+      this._logger.log(`[${pkg.name}] 서버 시작중...`);
+
+      const serverWorkerInfo = await this._runServerWorkerAsync(entryFilePath);
+      serverInfo.worker = serverWorkerInfo.worker;
+      serverInfo.url = serverWorkerInfo.url;
+      await this._reloadServerWorkerPathProxyAsync(serverInfo);
+
+      this._logger.log(`[${pkg.name}] 서버가 시작되었습니다.`);
+    }
+    catch (err) {
+      this._logger.error(`서버(${pkg.name}) 재시작중 오류 발생`, err);
+    }
+
+    this._isServerRestarting = false;
+  }
+
+  private async _buildPkgsAsync(pkgs: SdCliPackage[]): Promise<void> {
+    this._logger.debug("빌드를 시작합니다...");
+    const pkgNames = pkgs.map((item) => item.name);
+    const buildCompletedPackageNames: string[] = [];
+    const totalResultMap = new Map<string, ISdCliPackageBuildResult[]>();
+    try {
+      await pkgs.parallelAsync(async (pkg) => {
+        await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
+
+        this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
+        totalResultMap.set(pkg.name, await pkg.buildAsync());
+        this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
+
+        buildCompletedPackageNames.push(pkg.name);
+      });
+
+      this._loggingResults(totalResultMap);
+      if (Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")) {
+        throw new Error("빌드중 오류가 발생하였습니다.");
+      }
+      else {
+        this._logger.info("모든 빌드가 완료되었습니다.");
+      }
+    }
+    catch (err) {
+      this._loggingResults(totalResultMap);
+      throw err;
+    }
+  }
+
   private async _upgradeVersionAsync(pkgs: SdCliPackage[]): Promise<void> {
     // 작업공간 package.json 버전 설정
     const newVersion = semver.inc(this._npmConfig.version, "patch")!;
@@ -364,14 +397,14 @@ export class SdCliWorkspace {
     process.stdout.clearLine(0);
   }
 
-  private async _getPackagesAsync(conf: ISdCliConfig, pkgs: string[]): Promise<SdCliPackage[]> {
+  private async _getPackagesAsync(conf: ISdCliConfig): Promise<SdCliPackage[]> {
     const pkgRootPaths = await this._npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
     if (!pkgRootPaths) {
       throw new Error("최상위 'package.json'에서 'workspaces'를 찾을 수 없습니다.");
     }
 
     return pkgRootPaths.map((pkgRootPath) => {
-      if (pkgs.length > 0 && !pkgs.includes(path.basename(pkgRootPath))) return undefined;
+      // if (pkgs.length > 0 && !pkgs.includes(path.basename(pkgRootPath))) return undefined;
       const pkgConfig = conf.packages[path.basename(pkgRootPath)];
       if (!pkgConfig) return undefined;
       return new SdCliPackage(this._rootPath, pkgRootPath, pkgConfig);
@@ -416,26 +449,26 @@ export class SdCliWorkspace {
 
     const serverInfos = Array.from(this._serverInfoMap.values());
     for (const serverInfo of serverInfos) {
-      if (!serverInfo.server) continue;
+      if (!serverInfo.worker) continue;
 
-      const protocolStr = serverInfo.server.options.ssl ? "https" : "http";
-      const portStr = serverInfo.server.options.port.toString();
+      /*const protocolStr = serverInfo.server.options.ssl ? "https" : "http";
+      const portStr = serverInfo.server.options.port.toString();*/
 
       for (const clientInfo of serverInfo.clientInfos) {
         for (const platform of clientInfo.platforms) {
           if (platform === "web") {
-            clientHrefs.push(`${protocolStr}://localhost:${portStr}/${clientInfo.pkgKey}/`);
+            clientHrefs.push(`${serverInfo.url}/${clientInfo.pkgKey}/`);
           }
           else if (platform === "electron") {
-            clientHrefs.push(`sd-cli run-electron ${clientInfo.pkgKey} http://localhost:${portStr}`);
+            clientHrefs.push(`sd-cli run-electron ${clientInfo.pkgKey} ${serverInfo.url}`);
           }
           else if (platform === "cordova") {
             for (const target of clientInfo.cordovaTargets) {
               if (target === "browser") {
-                clientHrefs.push(`${protocolStr}://localhost:${portStr}/${clientInfo.pkgKey}/${platform}/`);
+                clientHrefs.push(`${serverInfo.url}/${clientInfo.pkgKey}/${platform}/`);
               }
               else {
-                clientHrefs.push(`sd-cli run-cordova ${target} ${clientInfo.pkgKey} http://[IP]:${portStr}`);
+                clientHrefs.push(`sd-cli run-cordova ${target} ${clientInfo.pkgKey} ${serverInfo.url}`);
               }
             }
           }
@@ -449,7 +482,8 @@ export class SdCliWorkspace {
 }
 
 interface IServerInfo {
-  server?: SdServiceServer;
-  middlewares: NextHandleFunction[];
+  worker?: cp.ChildProcess;
+  url?: string;
+  pathProxy: { from: string; to: string }[];
   clientInfos: { pkgKey: string; platforms: string[]; cordovaTargets: string[] }[];
 }

package/src/entry-points/file/base/fc_package_eslintrc.ts

@@ -0,0 +1,30 @@
+export const fc_package_eslintrc = (opt: { isForAngular: boolean }): string => /* language=cjs */ `
+
+module.exports = {
+  overrides: [
+    {
+      files: ["*.ts"],
+      parserOptions: {
+        tsconfigRootDir: __dirname,
+        project: "tsconfig.json"
+      },
+      settings: {
+        "import/resolver": {
+          "typescript": {
+            project: require("path").resolve(__dirname, "tsconfig.json")
+          }
+        }
+      },${opt.isForAngular ? `
+      {
+        files: ["*.ts"],
+        extends: ["plugin:@simplysm/angular"]
+      },
+      {
+        files: ["*.html"],
+        extends: ["plugin:@simplysm/angular-template"]
+      }` : ""}
+    }
+  ]
+};
+
+`.trim();

package/src/entry-points/file/base/fc_package_npmconfig.ts

@@ -0,0 +1,43 @@
+import { INpmConfig } from "../../../commons";
+import { FsUtil } from "@simplysm/sd-core-node";
+import path from "path";
+
+export const fc_package_npmconfig = (opt: {
+  projPath: string;
+  name: string;
+  description: string;
+  isModule: boolean;
+  main?: string;
+  types?: string;
+  dependencies: Record<string, string>;
+}): string => {
+  const projNpmConfig = FsUtil.readJson(path.resolve(opt.projPath, "package.json")) as INpmConfig;
+
+  if (projNpmConfig.repository?.url === undefined) {
+    throw new Error("프로젝트 package.json 파일에 reposotry.url 이 설정되어있지 않습니다.");
+  }
+
+  return JSON.stringify({
+    name: `@${projNpmConfig.name}/${opt.name}`,
+    version: `${projNpmConfig.version}`,
+    description: `${projNpmConfig.description} - ${opt.description}`,
+    author: projNpmConfig.author,
+    repository: {
+      type: "git",
+      url: projNpmConfig.repository.url,
+      directory: `packages/${opt.name}`
+    },
+    license: "UNLICENSED",
+    ...opt.isModule ? {
+      type: "module"
+    } : {},
+    private: true,
+    sideEffects: false,
+    engines: {
+      node: "^16"
+    },
+    ...opt.types !== undefined ? { types: opt.types } : {},
+    ...opt.main !== undefined ? { main: opt.main } : {},
+    ...Object.keys(opt.dependencies).length > 0 ? { dependencies: opt.dependencies } : {}
+  }, undefined, 2);
+};

package/src/entry-points/file/base/fc_package_tsconfig.ts

@@ -0,0 +1,11 @@
+export const fc_package_tsconfig = (opt: { isModule: boolean; useDom: boolean }): string => JSON.stringify({
+  extends: "../../tsconfig.json",
+  compilerOptions: {
+    ...!opt.isModule ? { module: "CommonJS" } : {},
+    lib: [
+      "ES2020",
+      ...opt.useDom ? ["DOM"] : []
+    ],
+    outDir: "./dist"
+  }
+}, undefined, 2);

package/src/entry-points/file/client/fc_package_AppModule.ts

@@ -0,0 +1,36 @@
+export const fc_package_AppModule = (): string => /* language=ts */ `
+
+import { ApplicationRef, DoBootstrap, NgModule } from "@angular/core";
+import { BrowserModule } from "@angular/platform-browser";
+import {
+  SdAngularModule,
+  SdCanDeactivateGuardModule,
+  SdToastProvider,
+  SdToastProviderModule
+} from "@simplysm/sd-angular";
+import { AppPageModule } from "./_modules/AppPageModule";
+import { AppPage } from "./AppPage";
+
+@NgModule({
+  imports: [
+    BrowserModule,
+
+    SdAngularModule.forRoot(),
+    SdToastProviderModule,
+    SdCanDeactivateGuardModule,
+
+    AppPageModule
+  ]
+})
+export class AppModule implements DoBootstrap {
+  public constructor(private readonly _toast: SdToastProvider) {
+  }
+
+  public async ngDoBootstrap(appRef: ApplicationRef): Promise<void> {
+    this._toast.alertThemes = ["danger"];
+
+    appRef.bootstrap(AppPage);
+  }
+}
+
+`.trim();

package/src/entry-points/file/client/fc_package_AppPage.ts

@@ -0,0 +1,33 @@
+export const fc_package_AppPage = (): string => /* language=ts */ `
+  
+import { ChangeDetectionStrategy, Component, HostListener } from "@angular/core";
+import { DevModal } from "./modals/DevModal";
+import { SdModalProvider } from "@simplysm/sd-angular";
+
+@Component({
+  selector: "app-root",
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: \`APP_PAGE\`
+})
+export class AppPage {
+  public constructor(private readonly _modal: SdModalProvider) {
+  }
+
+  @HostListener("document:keydown", ["$event"])
+  public async onKeydown(event: KeyboardEvent): Promise<void> {
+    if (
+      process.env["NODE_ENV"] !== "production"
+      && event.ctrlKey
+      && event.altKey
+      && event.shiftKey
+      && event.key === "F12"
+    ) {
+      event.preventDefault();
+      event.stopPropagation();
+
+      await this._modal.showAsync(DevModal, "DEV", undefined, { key: "dev-modal" });
+    }
+  }
+}
+
+`.trim();

package/src/entry-points/file/client/fc_package_appicons.ts

@@ -0,0 +1,5 @@
+export const fc_package_appicons = (): string => /* language=ts */ `
+
+export const appIcons = {};
+
+`.trim();

package/src/entry-points/file/client/fc_package_client_main.ts

@@ -0,0 +1,18 @@
+export const fc_package_client_main = (): string => /* language=ts */ `
+
+import { enableProdMode } from "@angular/core";
+import { platformBrowserDynamic } from "@angular/platform-browser-dynamic";
+import { AppModule } from "./AppModule";
+
+if (process.env["NODE_ENV"] === "production") {
+  enableProdMode();
+}
+
+platformBrowserDynamic().bootstrapModule(AppModule)
+  .catch(err => {
+    // eslint-disable-next-line no-console
+    console.error(err);
+  });
+
+
+`.trim();