@simplysm/sd-cli 10.0.37 → 10.0.39

package/src/builders/SdCliTsLibBuilder.ts

@@ -1,95 +1,166 @@
-import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import {FsUtil, Logger, SdFsWatcher} from "@simplysm/sd-core-node";
 import path from "path";
-import { ISdCliBuilderResult } from "../commons";
-import { EventEmitter } from "events";
-import { FunctionQueue } from "@simplysm/sd-core-common";
-import { SdTsIncrementalBuilder } from "../SdTsIncrementalBuilder";
-import { SdLinter } from "../SdLinter";
+import {ISdCliBuilderResult, ISdCliLibPackageConfig, ISdCliPackageBuildResult} from "../commons";
+import {EventEmitter} from "events";
+import {FunctionQueue, Uuid} from "@simplysm/sd-core-common";
+import {SdTsIncrementalBuilder} from "../SdTsIncrementalBuilder";
+import {SdLinter} from "../SdLinter";
+import {pathToFileURL} from "url";
+import less from "less";
+import ts from "typescript";
+import transformKeys from "ts-transformer-keys/transformer";
 
 export class SdCliTsLibBuilder extends EventEmitter {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
-
-  public constructor(private readonly _pkgPath: string) {
-    super();
-  }
-
-  public override on(event: "change", listener: () => void): this;
-  public override on(event: "complete", listener: (result: ISdCliBuilderResult) => void): this;
-  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
-    super.on(event, listener);
-    return this;
-  }
-
-  public async buildAsync(): Promise<ISdCliBuilderResult> {
-    this._debug("빌드 준비...");
-    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, true, false);
-
-    this._debug("dist 초기화...");
-    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
-
-    this._debug("BUILD...");
-    const buildResult = await sdTsProgram.buildAsync();
-
-    this._debug("LINT...");
-    const lintResults = await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
-
-    this._debug(`빌드 완료`);
-    return {
-      affectedFilePaths: buildResult.affectedFilePaths,
-      buildResults: [...buildResult.results, ...lintResults]
-    };
-  }
-
-  public async watchAsync(): Promise<void> {
-    this._debug("빌드 준비...");
-    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, true, true);
-
-    this._debug("dist 초기화...");
-    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
-
-    this.emit("change");
-
-    this._debug("BUILD...");
-    const buildResult = await sdTsProgram.buildAsync();
-
-    this._debug("LINT...");
-    const lintResults = await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
-
-    this._debug(`빌드 완료`);
-    this.emit("complete", {
-      affectedFilePaths: buildResult.affectedFilePaths,
-      buildResults: [...buildResult.results, ...lintResults]
-    });
-
-    this._debug("WATCH...");
-    const fnQ = new FunctionQueue();
-    SdFsWatcher
-      .watch([
-        ...sdTsProgram.builderProgram!.getSourceFiles().map((item) => item.fileName),
-        path.resolve(this._pkgPath, "src/**/*.{ts,tsx}")
-      ])
-      .onChange({
-        delay: 100
-      }, () => {
-        fnQ.runLast(async () => {
-          this.emit("change");
-
-          this._debug(`BUILD...`);
-          const watchBuildResult = await sdTsProgram.buildAsync();
-
-          this._debug(`LINT...`);
-          const watchLintResults = await SdLinter.lintAsync(watchBuildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
-
-          this._debug(`빌드 완료`);
-          this.emit("complete", {
-            affectedFilePaths: watchBuildResult.affectedFilePaths,
-            buildResults: [...watchBuildResult.results, ...watchLintResults]
-          });
+    private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
+
+    public constructor(private readonly _pkgPath: string,
+                       private readonly _pkgConf: ISdCliLibPackageConfig,
+                       private readonly _withLint: boolean) {
+        super();
+    }
+
+    public override on(event: "change", listener: () => void): this;
+    public override on(event: "complete", listener: (result: ISdCliBuilderResult) => void): this;
+    public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+        super.on(event, listener);
+        return this;
+    }
+
+    public async buildAsync(): Promise<ISdCliBuilderResult> {
+        this._debug("빌드 준비...");
+        const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, (opt) => ({
+            emitJs: true,
+            transforms: opt.jsx === ts.JsxEmit.ReactJSX ? [{fn: transformKeys, args: undefined}] : undefined
+        }));
+
+        this._debug("dist 초기화...");
+        await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+
+        this._debug("BUILD...");
+        const buildResult = await sdTsProgram.buildAsync();
+
+        this._debug("LINT...");
+        const lintResults = !this._withLint ? [] : await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+        let styleResult: ISdCliPackageBuildResult | undefined;
+        if (this._pkgConf.style !== undefined) {
+            this._debug("STYLE...");
+            styleResult = await this._genStyleAsync();
+        }
+
+        this._debug("COPY...");
+        await FsUtil.copyAsync(
+            path.resolve(this._pkgPath, "src/assets"),
+            path.resolve(this._pkgPath, "dist/assets")
+        );
+
+
+        this._debug(`빌드 완료`);
+        return {
+            affectedFilePaths: buildResult.affectedFilePaths,
+            buildResults: [...buildResult.results, ...lintResults, ...styleResult ? [styleResult] : []]
+        };
+    }
+
+    public async watchAsync(): Promise<void> {
+        this._debug("빌드 준비...");
+        const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, (opt) => ({
+            emitJs: true,
+            compilerOptions: opt.jsx === ts.JsxEmit.ReactJSX ? {jsx: ts.JsxEmit.ReactJSXDev} : undefined,
+            transforms: opt.jsx === ts.JsxEmit.ReactJSX ? [{fn: transformKeys, args: undefined},] : undefined
+        }));
+
+        this._debug("dist 초기화...");
+        await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+
+        this.emit("change");
+
+        this._debug("BUILD...");
+        const buildResult = await sdTsProgram.buildAsync();
+
+        this._debug("LINT...");
+        const lintResults = !this._withLint ? [] : await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+        let styleResult: ISdCliPackageBuildResult | undefined;
+        if (this._pkgConf.style !== undefined) {
+            this._debug("STYLE...");
+            styleResult = await this._genStyleAsync();
+        }
+
+        this._debug("COPY...");
+        await FsUtil.copyAsync(
+            path.resolve(this._pkgPath, "src/assets"),
+            path.resolve(this._pkgPath, "dist/assets")
+        );
+
+        this._debug(`빌드 완료`);
+        this.emit("complete", {
+            affectedFilePaths: buildResult.affectedFilePaths,
+            buildResults: [...buildResult.results, ...lintResults, ...styleResult ? [styleResult] : []]
         });
-      });
-  }
 
-  private _debug(msg: string): void {
-    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
-  }
+        this._debug("WATCH...");
+        const fnQ = new FunctionQueue();
+        SdFsWatcher
+            .watch([
+                ...sdTsProgram.builderProgram!.getSourceFiles().map((item) => item.fileName),
+                path.resolve(this._pkgPath, "src/**/*.{ts,tsx}")
+            ])
+            .onChange({
+                delay: 100
+            }, () => {
+                fnQ.runLast(async () => {
+                    this.emit("change");
+
+                    this._debug(`BUILD...`);
+                    const watchBuildResult = await sdTsProgram.buildAsync();
+
+                    this._debug(`LINT...`);
+                    const watchLintResults = !this._withLint ? [] : await SdLinter.lintAsync(watchBuildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+                    let watchStyleResult: ISdCliPackageBuildResult | undefined;
+                    if (this._pkgConf.style !== undefined && watchBuildResult.affectedFilePaths.some((item) => item.endsWith(this._pkgConf.style!))) {
+                        this._debug("STYLE...");
+                        watchStyleResult = await this._genStyleAsync();
+                    }
+
+                    this._debug("COPY...");
+                    await FsUtil.copyAsync(
+                        path.resolve(this._pkgPath, "src/assets"),
+                        path.resolve(this._pkgPath, "dist/assets")
+                    );
+
+                    this._debug(`빌드 완료`);
+                    this.emit("complete", {
+                        affectedFilePaths: watchBuildResult.affectedFilePaths,
+                        buildResults: [...watchBuildResult.results, ...watchLintResults, ...watchStyleResult ? [watchStyleResult] : []]
+                    });
+                });
+            });
+    }
+
+    private _debug(msg: string): void {
+        this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+    }
+
+    private async _genStyleAsync(): Promise<ISdCliPackageBuildResult | undefined> {
+        const srcFilePath = path.resolve(this._pkgPath, "dist", this._pkgConf.style! + ".js");
+        try {
+            const styleImport = await import(pathToFileURL(srcFilePath).href + "?token=" + Uuid.new().toString());
+            const styleText = styleImport.default.join("");
+            const styleRendered = await less.render(styleText);
+            await FsUtil.writeFileAsync(path.resolve(this._pkgPath, "style.css"), styleRendered.css);
+        } catch (err) {
+            return {
+                code: undefined,
+                message: err.message,
+                severity: "error",
+                char: undefined,
+                line: undefined,
+                filePath: srcFilePath
+            };
+        }
+
+        return;
+    }
 }

package/src/commons.ts

@@ -1,64 +1,96 @@
 export interface INpmConfig {
-  name: string;
-  version: string;
-  workspaces?: string[];
+    name: string;
+    description?: string;
+    version: string;
+    workspaces?: string[];
 
-  dependencies?: Record<string, string>;
-  optionalDependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    peerDependenciesMeta?: Record<string, {
+        optional?: boolean
+    }>;
 
-  resolutions?: Record<string, string>;
+    resolutions?: Record<string, string>;
 }
 
 export interface ISdCliBuildClusterReqMessage {
-  cmd: "watch" | "build";
-  pkgPath: string;
-  pkgConf: TSdCliPackageConfig
+    cmd: "watch" | "build";
+    pkgPath: string;
+    pkgConf: TSdCliPackageConfig;
+    builderKey?: "web" | "electron";
+    withLint: boolean;
 }
 
 export interface ISdCliBuildClusterResMessage {
-  req: ISdCliBuildClusterReqMessage;
-  type: "change" | "complete" | "ready";
-  result?: ISdCliBuilderResult;
+    req: ISdCliBuildClusterReqMessage;
+    type: "change" | "complete" | "ready";
+    result?: ISdCliBuilderResult;
 }
 
 export interface ISdCliBuilderResult {
-  port?: number;
-  affectedFilePaths: string[];
-  buildResults: ISdCliPackageBuildResult[];
+    port?: number;
+    affectedFilePaths: string[];
+    buildResults: ISdCliPackageBuildResult[];
 }
 
 export interface ISdCliPackageBuildResult {
-  filePath: string | undefined;
-  line: number | undefined;
-  char: number | undefined;
-  code: string | undefined;
-  severity: "error" | "warning" | "suggestion" | "message";
-  message: string;
+    filePath: string | undefined;
+    line: number | undefined;
+    char: number | undefined;
+    code: string | undefined;
+    severity: "error" | "warning" | "suggestion" | "message";
+    message: string;
 }
 
 export interface ISdCliConfig {
-  packages: Record<string, TSdCliPackageConfig | undefined>;
-  localUpdates?: Record<string, string>;
+    packages: Record<string, TSdCliPackageConfig | undefined>;
+    localUpdates?: Record<string, string>;
 }
+export type TSdCliConfigFn = (isDev: boolean, opts?: string[]) => ISdCliConfig;
 
 export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig | ISdCliClientPackageConfig;
 
 export interface ISdCliLibPackageConfig {
-  type: "library";
-  publish?: "npm";
+    type: "library";
+    style?: string;
+    publish?: "npm";
 }
 
 export interface ISdCliServerPackageConfig {
-  type: "server";
-  externals?: string[];
-  publish?: any;
+    type: "server";
+    externals?: string[];
+    publish?: ISdCliLocalDirectoryPublishConfig;
+    configs?: Record<string, any>;
 }
 
 export interface ISdCliClientPackageConfig {
-  type: "client";
-  server?: string;
-  publish?: any;
+    type: "client";
+    server?: string;
+    publish?: ISdCliLocalDirectoryPublishConfig;
+    env?: Record<string, string>;
+    configs?: Record<string, any>;
+
+    builder?: {
+        web?: ISdCliClientBuilderWebConfig;
+        electron?: ISdCliClientBuilderElectronConfig;
+    }
+}
+
+export interface ISdCliLocalDirectoryPublishConfig {
+    type: "local-directory";
+    path: string;
+}
+
+export interface ISdCliClientBuilderElectronConfig {
+    appId: string;
+    installerIcon?: string;
+    postInstallScript?: string;
+    devServerPort?: number;
+    reinstallDependencies?: string[];
+}
+
+export interface ISdCliClientBuilderWebConfig {
+    devServerPort?: number;
 }

package/src/entry/SdCliElectron.ts

@@ -0,0 +1,55 @@
+import {FsUtil, Logger, SdProcess} from "@simplysm/sd-core-node";
+import {pathToFileURL} from "url";
+import path from "path";
+import {INpmConfig, ISdCliConfig} from "../commons";
+
+export class SdCliElectron {
+    public static async runAsync(opt: {
+        confFileRelPath: string;
+        optNames: string[];
+        pkgName: string;
+    }): Promise<void> {
+        const logger = Logger.get(["simplysm", "sd-cli", "SdCliElectron", "runAsync"]);
+
+        const pkgPath = path.resolve(process.cwd(), `packages/${opt.pkgName}`);
+        const electronPath = path.resolve(pkgPath, ".cache/dev/electron/src");
+
+        logger.log("설정 가져오기...");
+        const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(true, opt.optNames) as ISdCliConfig;
+        const pkgConf = projConf.packages[opt.pkgName];
+        if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
+            throw new Error();
+        }
+
+        logger.log("package.json 파일 쓰기...");
+        const npmConfig = (await FsUtil.readJsonAsync(path.resolve(pkgPath, `package.json`))) as INpmConfig;
+
+        const externalPkgNames = pkgConf.builder.electron.reinstallDependencies ?? [];
+
+        await FsUtil.writeJsonAsync(path.resolve(electronPath, `package.json`), {
+            name: npmConfig.name,
+            version: npmConfig.version,
+            description: npmConfig.description,
+            main: "electron-main.js",
+            ...pkgConf.builder.electron.postInstallScript !== undefined ? {
+                scripts: {
+                    "postinstall": pkgConf.builder.electron.postInstallScript
+                },
+            } : {},
+            dependencies: externalPkgNames.toObject((item) => item, (item) => npmConfig.dependencies![item])
+        });
+
+        logger.log("npm install...");
+        await SdProcess.spawnAsync(`npm install`, {cwd: electronPath}, true);
+
+        for (const externalPkgName of externalPkgNames) {
+            if (FsUtil.exists(path.resolve(electronPath, "node_modules", externalPkgName, "binding.gyp"))) {
+                logger.log(`electron rebuild (${externalPkgName})...`);
+                await SdProcess.spawnAsync(`electron-rebuild -m ./node_modules/${externalPkgName}`, {cwd: electronPath}, true);
+            }
+        }
+
+        logger.log("electron...");
+        await SdProcess.spawnAsync(`electron .`, {cwd: electronPath}, true);
+    }
+}

package/src/entry/SdCliLocalUpdate.ts

@@ -0,0 +1,125 @@
+import {FsUtil, Logger, PathUtil, SdFsWatcher} from "@simplysm/sd-core-node";
+import path from "path";
+import {pathToFileURL} from "url";
+import {ISdCliConfig} from "../commons";
+
+export class SdCliLocalUpdate {
+    public static async runAsync(opt: {
+        confFileRelPath: string;
+        optNames: string[];
+    }): Promise<void> {
+        const logger = Logger.get(["simplysm", "sd-cli", "SdCliLocalUpdate", "runAsync"]);
+
+        logger.debug("프로젝트 설정 가져오기...");
+        const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(true, opt.optNames) as ISdCliConfig;
+        if (!projConf.localUpdates) return;
+
+        logger.debug("로컬 업데이트 구성...");
+        const updatePathInfos = await this._getUpdatePathInfosAsync(projConf.localUpdates);
+
+        logger.log("로컬 라이브러리 업데이트...");
+        for (const updatePathInfo of updatePathInfos) {
+            if (!FsUtil.exists(updatePathInfo.source)) {
+                logger.warn(`소스경로를 찾을 수 없어 무시됩니다(${updatePathInfo.source})`);
+                return;
+            }
+
+            // 소스경로에서 대상경로로 파일 복사
+            await FsUtil.copyAsync(updatePathInfo.source, updatePathInfo.target, (src) => {
+                return !src.includes("node_modules") && !src.endsWith("package.json");
+            });
+        }
+        logger.info("로컬 라이브러리 업데이트 완료");
+    }
+
+    public static async watchAsync(opt: {
+        confFileRelPath: string;
+        optNames: string[];
+    }): Promise<void> {
+        const logger = Logger.get(["simplysm", "sd-cli", "SdCliLocalUpdate", "watchAsync"]);
+
+        logger.debug("프로젝트 설정 가져오기...");
+        const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(true, opt.optNames) as ISdCliConfig;
+        if (!projConf.localUpdates) return;
+
+        logger.debug("로컬 업데이트 구성...");
+        const updatePathInfos = await this._getUpdatePathInfosAsync(projConf.localUpdates);
+
+        const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
+
+        const watcher = SdFsWatcher.watch(watchPaths);
+        watcher.onChange({delay: 1000}, async (changedInfos) => {
+            const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+            if (changeFilePaths.length === 0) return;
+
+            logger.log("로컬 라이브러리 변경감지...");
+            for (const changedFilePath of changeFilePaths) {
+                if (!FsUtil.exists(changedFilePath)) continue;
+
+                for (const updatePathInfo of updatePathInfos) {
+                    if (!PathUtil.isChildPath(changedFilePath, updatePathInfo.source)) continue;
+
+                    const sourceRelPath = path.relative(updatePathInfo.source, changedFilePath);
+
+                    const targetFilePath = path.resolve(updatePathInfo.target, sourceRelPath);
+
+                    logger.debug(`변경파일감지(복사): ${changedFilePath} => ${targetFilePath}`);
+                    await FsUtil.copyAsync(changedFilePath, targetFilePath);
+                }
+            }
+
+            const watchWatchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
+            watcher.add(watchWatchPaths);
+
+            logger.info("로컬 라이브러리 복사 완료");
+        });
+    }
+
+    private static async _getUpdatePathInfosAsync(record: Record<string, string>): Promise<IUpdatePathInfo[]> {
+        const result: IUpdatePathInfo[] = [];
+        for (const pkgGlobPath of Object.keys(record)) {
+            // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기
+            const targetPaths = [
+                ...await FsUtil.globAsync(path.resolve(process.cwd(), "node_modules", pkgGlobPath)),
+                ...await FsUtil.globAsync(path.resolve(process.cwd(), "packages", "*", "node_modules", pkgGlobPath))
+            ];
+
+            result.push(
+                ...targetPaths
+                    .map((targetPath) => {
+                        // 대상의 명칭 추출
+                        const regexpText = pkgGlobPath.replace(/[\\/.*]/g, (item) => (
+                            item === "/" ? "[\\\\\\/]"
+                                : item === "." ? "\\."
+                                    : item === "*" ? "(.*)"
+                                        : item
+                        ));
+                        const targetNameMatch = new RegExp(regexpText).exec(targetPath);
+                        if (!targetNameMatch || typeof targetNameMatch[1] === "undefined") return undefined;
+                        const targetName = targetNameMatch[1];
+
+                        // 가져올 소스 경로 추출
+                        const sourcePath = path.resolve(record[pkgGlobPath].replace(/\*/g, targetName));
+                        return {source: sourcePath, target: targetPath};
+                    })
+                    .filterExists()
+            );
+        }
+
+        return result;
+    }
+
+    private static async _getWatchPathsAsync(sourcePath: string): Promise<string[]> {
+        return await FsUtil.globAsync(path.resolve(sourcePath, "**"), {
+            ignore: [
+                "**/node_modules/**",
+                "**/package.json"
+            ]
+        });
+    }
+}
+
+interface IUpdatePathInfo {
+    source: string;
+    target: string;
+}