@simplysm/sd-cli 12.9.19 → 12.9.22

package/src/entry/sd-cli-electron.ts

@@ -4,66 +4,24 @@ import electronBuilder from "electron-builder";
 import { ISdClientBuilderElectronConfig } from "../types/config.types";
 import { INpmConfig } from "../types/common-configs.types";
 import { loadProjConfAsync } from "./utils/loadProjConfAsync";
+import os from "os";
+import fs from "node:fs";
 
 export class SdCliElectron {
+  private static _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]);
+
   static async runAsync(opt: {
     package: string
     config: string;
     options?: string[];
   }) {
-    const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron", "runAsync"]);
-
-    const pkgPath = path.resolve(process.cwd(), `packages/${opt.package}`);
-    const electronPath = path.resolve(pkgPath, "dist/electron");
-
-    logger.log("설정 가져오기...");
-    const projConf = await loadProjConfAsync(process.cwd(), true, opt);
-    const pkgConf = projConf.packages[opt.package];
-    if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
-      throw new Error();
-    }
-
-    logger.log("package.json 파일 쓰기...");
-    const npmConfig = FsUtils.readJson(path.resolve(pkgPath, `package.json`)) as INpmConfig;
-
-    const reinstallPkgNames = pkgConf.builder.electron.reinstallDependencies ?? [];
-
-    FsUtils.writeJson(path.resolve(electronPath, `package.json`), {
-      name: npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
-      version: npmConfig.version,
-      description: npmConfig.description,
-      main: "electron-main.js",
-      ...(pkgConf.builder.electron.postInstallScript !== undefined
-        ? {
-          scripts: {
-            postinstall: pkgConf.builder.electron.postInstallScript,
-          },
-        }
-        : {}),
-      dependencies: reinstallPkgNames.toObject(
-        (item) => item,
-        (item) => npmConfig.dependencies![item],
-      ),
-    });
-
-    logger.log("npm install...");
-    await SdProcess.spawnAsync(`npm install`, { cwd: electronPath }, true);
+    this._logger.log("설정 가져오기...");
+    const { pkgPath, electronPath, electronConfig } = await this._loadDevConfig(opt);
 
-    logger.log(`electron rebuild`);
-    await SdProcess.spawnAsync(`npx electron-rebuild`, { cwd: electronPath }, true);
+    this._logger.log("준비...");
+    await this._prepareAsync({ pkgPath, electronPath, electronConfig });
 
-    /*for (const reinstallPkgName of reinstallPkgNames) {
-      if (FsUtil.exists(path.resolve(electronPath, "node_modules", reinstallPkgName, "binding.gyp"))) {
-        logger.log(`electron rebuild (${reinstallPkgName})...`);
-        await SdProcess.spawnAsync(
-          `electron-rebuild -m ./node_modules/${reinstallPkgName}`,
-          { cwd: electronPath },
-          true,
-        );
-      }
-    }*/
-
-    logger.log("electron...");
+    this._logger.log("실행...");
     await SdProcess.spawnAsync(`npx electron .`, { cwd: electronPath }, true);
   }
 
@@ -72,123 +30,74 @@ export class SdCliElectron {
     config: string;
     options?: string[];
   }) {
-    const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron", "buildForDevAsync"]);
+    this._logger.log("설정 가져오기...");
+    const { pkgPath, electronPath, electronConfig } = await this._loadDevConfig(opt);
 
-    const pkgPath = path.resolve(process.cwd(), `packages/${opt.package}`);
-    const electronPath = path.resolve(pkgPath, "dist/electron");
+    this._logger.log("준비...");
+    const { npmConfig } = await this._prepareAsync({ pkgPath, electronPath, electronConfig });
+
+    this._logger.log("빌드...");
     const electronDistPath = path.resolve(pkgPath, ".electron/dist");
+    await this._buildAsync({ pkgPath, electronPath, electronDistPath, npmConfig, electronConfig });
+  }
+
+  static async buildAsync(opt: {
+    pkgPath: string;
+    electronConfig: ISdClientBuilderElectronConfig
+  }) {
+    this._logger.log("준비...");
+    const electronPath = path.resolve(opt.pkgPath, ".electron/src");
+    const { npmConfig } = await this._prepareAsync({ ...opt, electronPath });
 
-    logger.log("설정 가져오기...");
+    this._logger.log("빌드...");
+    const electronDistPath = path.resolve(opt.pkgPath, ".electron/dist");
+    await this._buildAsync({
+      pkgPath: opt.pkgPath,
+      electronPath,
+      electronDistPath,
+      npmConfig,
+      electronConfig: opt.electronConfig,
+    });
+  }
+
+  private static async _loadDevConfig(opt: {
+    package: string
+    config: string;
+    options?: string[];
+  }) {
     const projConf = await loadProjConfAsync(process.cwd(), true, opt);
     const pkgConf = projConf.packages[opt.package];
     if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
       throw new Error();
     }
+    const pkgPath = path.resolve(process.cwd(), `packages/${opt.package}`);
+    const electronPath = path.resolve(pkgPath, "dist/electron");
 
-    logger.log("package.json 파일 쓰기...");
-    const npmConfig = FsUtils.readJson(path.resolve(pkgPath, `package.json`)) as INpmConfig;
-
-    const reinstallPkgNames = pkgConf.builder.electron.reinstallDependencies ?? [];
-
-    FsUtils.writeJson(path.resolve(electronPath, `package.json`), {
-      name: npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
-      version: npmConfig.version,
-      description: npmConfig.description,
-      main: "electron-main.js",
-      ...(pkgConf.builder.electron.postInstallScript !== undefined
-        ? {
-          scripts: {
-            postinstall: pkgConf.builder.electron.postInstallScript,
-          },
-        }
-        : {}),
-      dependencies: reinstallPkgNames.toObject(
-        (item) => item,
-        (item) => npmConfig.dependencies![item],
-      ),
-    });
-
-    logger.log("npm install...");
-    await SdProcess.spawnAsync(`npm install`, { cwd: electronPath }, true);
-
-    logger.log(`electron rebuild`);
-    await SdProcess.spawnAsync(`npx electron-rebuild`, { cwd: electronPath }, true);
-
-    /*for (const reinstallPkgName of reinstallPkgNames) {
-      if (FsUtils.exists(path.resolve(electronPath, "node_modules", reinstallPkgName, "binding.gyp"))) {
-        logger.log(`electron rebuild (${reinstallPkgName})...`);
-        await SdProcess.spawnAsync(
-          `electron-rebuild -m ./node_modules/${reinstallPkgName}`,
-          { cwd: electronPath },
-          true,
-        );
-      }
-    }*/
-
-    logger.log("build...");
-
-    await electronBuilder.build({
-      targets: electronBuilder.Platform.WINDOWS.createTarget(),
-      config: {
-        appId: pkgConf.builder.electron.appId,
-        productName: npmConfig.description,
-        asar: false,
-        win: {
-          target: pkgConf.builder.electron.portable ? "portable" : "nsis",
-        },
-        nsis: {},
-        directories: {
-          app: electronPath,
-          output: electronDistPath,
-        },
-        ...(pkgConf.builder.electron.installerIcon !== undefined
-          ? {
-            icon: path.resolve(pkgPath, pkgConf.builder.electron.installerIcon),
-          }
-          : {}),
-        removePackageScripts: false,
-      },
-    });
-
-    FsUtils.copy(
-      path.resolve(
-        electronDistPath,
-        `${npmConfig.description} ${pkgConf.builder.electron.portable
-          ? ""
-          : "Setup "}${npmConfig.version}.exe`,
-      ),
-      path.resolve(
-        pkgPath,
-        `dist/electron/${npmConfig.description}${pkgConf.builder.electron.portable
-          ? "-portable"
-          : ""}-dev.exe`,
-      ),
-    );
+    return {
+      pkgPath,
+      electronPath,
+      electronConfig: pkgConf.builder.electron,
+    };
   }
 
-  static async buildAsync(opt: {
+  private static async _prepareAsync(opt: {
     pkgPath: string;
-    config: ISdClientBuilderElectronConfig
+    electronPath: string;
+    electronConfig: ISdClientBuilderElectronConfig;
   }) {
-    const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron", "buildAsync"]);
-
-    const electronSrcPath = path.resolve(opt.pkgPath, ".electron/src");
-    const electronDistPath = path.resolve(opt.pkgPath, ".electron/dist");
-
-    logger.log("package.json 파일 쓰기...");
     const npmConfig = FsUtils.readJson(path.resolve(opt.pkgPath, `package.json`)) as INpmConfig;
 
-    const reinstallPkgNames = opt.config.reinstallDependencies ?? [];
+    const reinstallPkgNames = opt.electronConfig.reinstallDependencies ?? [];
 
-    FsUtils.writeJson(path.resolve(electronSrcPath, `package.json`), {
+    FsUtils.writeJson(path.resolve(opt.electronPath, `package.json`), {
       name: npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
       version: npmConfig.version,
       description: npmConfig.description,
       main: "electron-main.js",
-      ...(opt.config.postInstallScript !== undefined
+      ...(opt.electronConfig.postInstallScript !== undefined
         ? {
           scripts: {
-            postinstall: opt.config.postInstallScript,
+            postinstall: opt.electronConfig.postInstallScript,
           },
         }
         : {}),
@@ -198,60 +107,59 @@ export class SdCliElectron {
       ),
     });
 
-    logger.log("npm install...");
-    await SdProcess.spawnAsync(`npm install`, { cwd: electronSrcPath }, true);
+    await SdProcess.spawnAsync(`npm install`, { cwd: opt.electronPath }, true);
+
+    await SdProcess.spawnAsync(`npx electron-rebuild`, { cwd: opt.electronPath }, true);
 
-    logger.log(`electron rebuild`);
-    await SdProcess.spawnAsync(`npx electron-rebuild`, { cwd: electronSrcPath }, true);
+    return { npmConfig };
+  }
 
-    /*for (const reinstallPkgName of reinstallPkgNames) {
-      if (FsUtils.exists(path.resolve(
-        electronSrcPath,
-        "node_modules",
-        reinstallPkgName,
-        "binding.gyp",
-      ))) {
-        logger.log(`electron rebuild (${reinstallPkgName})...`);
-        await SdProcess.spawnAsync(
-          `electron-rebuild -m ./node_modules/${reinstallPkgName}`,
-          { cwd: electronSrcPath },
-          true,
-        );
-      }
-    }*/
+  private static async _buildAsync(opt: {
+    pkgPath: string;
+    electronPath: string;
+    electronDistPath: string;
+    npmConfig: INpmConfig;
+    electronConfig: ISdClientBuilderElectronConfig
+  }) {
+    if (!this._canCreateSymlink()) {
+      throw new Error("'Electron 빌드'를 위해서는 'Symlink 생성' 권한이 필요합니다. 윈도우의 개발자모드를 활성화하세요.");
+    }
 
-    logger.log("build...");
     await electronBuilder.build({
       targets: electronBuilder.Platform.WINDOWS.createTarget(),
       config: {
-        appId: opt.config.appId,
-        productName: npmConfig.description,
+        appId: opt.electronConfig.appId,
+        productName: opt.npmConfig.description,
         asar: false,
         win: {
-          target: opt.config.portable ? "portable" : "nsis",
+          target: opt.electronConfig.portable ? "portable" : "nsis",
         },
         nsis: {},
         directories: {
-          app: electronSrcPath,
-          output: electronDistPath,
+          app: opt.electronPath,
+          output: opt.electronDistPath,
         },
-        ...(opt.config.installerIcon !== undefined
+        ...(opt.electronConfig.installerIcon !== undefined
           ? {
-            icon: path.resolve(opt.pkgPath, opt.config.installerIcon),
+            icon: path.resolve(opt.pkgPath, opt.electronConfig.installerIcon),
           }
           : {}),
         removePackageScripts: false,
+        npmRebuild: false,
+        forceCodeSigning: false,
       },
     });
 
     FsUtils.copy(
       path.resolve(
-        electronDistPath,
-        `${npmConfig.description} ${opt.config.portable ? "" : "Setup "}${npmConfig.version}.exe`,
+        opt.electronDistPath,
+        `${opt.npmConfig.description} ${opt.electronConfig.portable
+          ? ""
+          : "Setup "}${opt.npmConfig.version}.exe`,
       ),
       path.resolve(
         opt.pkgPath,
-        `dist/electron/${npmConfig.description}${opt.config.portable
+        `dist/electron/${opt.npmConfig.description}${opt.electronConfig.portable
           ? "-portable"
           : ""}-latest.exe`,
       ),
@@ -259,10 +167,38 @@ export class SdCliElectron {
 
     FsUtils.copy(
       path.resolve(
-        electronDistPath,
-        `${npmConfig.description} ${opt.config.portable ? "" : "Setup "}${npmConfig.version}.exe`,
+        opt.electronDistPath,
+        `${opt.npmConfig.description} ${opt.electronConfig.portable
+          ? ""
+          : "Setup "}${opt.npmConfig.version}.exe`,
       ),
-      path.resolve(opt.pkgPath, `dist/electron/updates/${npmConfig.version}.exe`),
+      path.resolve(opt.pkgPath, `dist/electron/updates/${opt.npmConfig.version}.exe`),
     );
   }
+
+  private static _canCreateSymlink() {
+    const tmpDir = os.tmpdir();
+    const testTarget = path.join(tmpDir, "symlink-test-target.txt");
+    const testLink = path.join(tmpDir, "symlink-test-link.txt");
+
+    try {
+      // 대상 파일 생성
+      fs.writeFileSync(testTarget, "test");
+
+      // symlink 시도
+      fs.symlinkSync(testTarget, testLink, "file");
+
+      // symlink 성공 여부 확인
+      const isSymlink = fs.lstatSync(testLink).isSymbolicLink();
+
+      // 정리
+      fs.unlinkSync(testLink);
+      fs.unlinkSync(testTarget);
+
+      return isSymlink;
+    }
+    catch {
+      return false;
+    }
+  }
 }

package/src/entry/sd-cli-project.ts

@@ -334,7 +334,10 @@ export class SdCliProject {
         const cordovaPluginConfXml = XmlConvert.parse(FsUtils.readFile(cordovaPluginConfFilePath));
         cordovaPluginConfXml.plugin.$.version = newVersion;
 
-        FsUtils.writeFile(cordovaPluginConfFilePath, XmlConvert.stringify(cordovaPluginConfXml));
+        FsUtils.writeFile(
+          cordovaPluginConfFilePath,
+          XmlConvert.stringify(cordovaPluginConfXml, { format: true }),
+        );
       }
     }
   }

package/src/fix/convert-ordering-interface.ts

@@ -0,0 +1,56 @@
+/* eslint-disable no-console */
+import { SyntaxKind } from "ts-morph";
+import getTsMortphSourceFiles from "./core/get-ts-morph-source-files";
+
+export default function convertOrderingInterface() {
+  const sourceFiles = getTsMortphSourceFiles();
+
+  for (const sourceFile of sourceFiles) {
+    let changed = false;
+
+    // 1. import 교체
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      if (importDecl.getModuleSpecifierValue() !== "@simplysm/sd-angular") continue;
+
+      const namedImports = importDecl.getNamedImports();
+
+      let hasOld = false;
+      let hasNew = false;
+
+      for (const ni of namedImports) {
+        const name = ni.getName();
+        if (name === "ISdSheetColumnOrderingVM") {
+          ni.remove(); // ← ✅ 이 방식으로 제거
+          hasOld = true;
+        }
+        if (name === "ISortingDef") {
+          hasNew = true;
+        }
+      }
+
+      if (hasOld && !hasNew) {
+        importDecl.addNamedImport("ISortingDef");
+        changed = true;
+        console.log(`[import-updated] ${sourceFile.getBaseName()} :: import 교체 완료`);
+      }
+    }
+
+    // 2. 타입 참조 교체
+    sourceFile.forEachDescendant((node) => {
+      if (
+        node.getKind() === SyntaxKind.TypeReference &&
+        node.getText() === "ISdSheetColumnOrderingVM"
+      ) {
+        node.replaceWithText("ISortingDef");
+        changed = true;
+        console.log(`[type-replaced] ${sourceFile.getBaseName()} :: 타입 참조 변경`);
+      }
+    });
+
+    if (changed) {
+      sourceFile.saveSync();
+    }
+  }
+
+  console.log("[완료] ISdSheetColumnOrderingVM → ISortingDef 변환 완료");
+}

package/src/fix/convert-sd-sheet-bindings-inInline-template.ts

@@ -0,0 +1,62 @@
+/* eslint-disable no-console */
+import { SyntaxKind } from "ts-morph";
+import getTsMortphSourceFiles from "./core/get-ts-morph-source-files";
+
+export default function convertSdSheetBindingsSafely() {
+  const sourceFiles = getTsMortphSourceFiles();
+
+  for (const sourceFile of sourceFiles) {
+    for (const classDecl of sourceFile.getClasses()) {
+      const decorator = classDecl.getDecorator("Component");
+      if (!decorator) continue;
+
+      const arg = decorator.getArguments()[0];
+      if (!arg.asKind(SyntaxKind.ObjectLiteralExpression)) continue;
+
+      const obj = arg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+      const templateProp = obj.getProperty("template");
+      if (!templateProp || !templateProp.isKind(SyntaxKind.PropertyAssignment)) continue;
+
+      const initializer = templateProp.getInitializer();
+      if (!initializer) continue;
+
+      let rawTemplate: string | undefined;
+      if (initializer.isKind(SyntaxKind.NoSubstitutionTemplateLiteral) || initializer.isKind(
+        SyntaxKind.StringLiteral)) {
+        rawTemplate = initializer.getLiteralText();
+      }
+      else if (initializer.isKind(SyntaxKind.TemplateExpression)) {
+        rawTemplate = initializer.getFullText().slice(1, -1);
+      }
+      else continue;
+
+      // 정규식으로 <sd-sheet> 안에서만 바인딩 속성 치환
+      let newTemplate = rawTemplate.replace(
+        /<sd-sheet([\s\S]*?)>/g,
+        (match) =>
+          match
+            .replace(/\[\(page\)\]/g, "[(currentPage)]")
+            .replace(/\[pageLength\]/g, "[totalPageCount]")
+            .replace(/\[\(ordering\)\]/g, "[(sorts)]")
+            .replace(/\[pageItemCount\]/g, "[itemsPerPage]"),
+      );
+
+      newTemplate = newTemplate.replace(
+        /<sd-pagination([\s\S]*?)>/g,
+        (match) =>
+          match
+            .replace(/\[\(page\)\]/g, "[(currentPage)]")
+            .replace(/\[pageLength\]/g, "[totalPageCount]")
+            .replace(/\[displayPageLength\]/g, "[visiblePageCount]"),
+      );
+
+      if (rawTemplate !== newTemplate) {
+        initializer.replaceWithText("`" + newTemplate + "`");
+        console.log(`[template-updated] ${sourceFile.getBaseName()} :: 바인딩 속성 안전하게 변경 완료`);
+        sourceFile.saveSync();
+      }
+    }
+  }
+
+  console.log("[완료] 정규식 기반 안전한 sd-sheet 바인딩 속성 변경 완료");
+}

package/src/pkg-builders/client/sd-client.build-runner.ts

@@ -104,7 +104,7 @@ export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
       this._debug("ELECTRON BUILD...");
       await SdCliElectron.buildAsync({
         pkgPath: this._pkgPath,
-        config: this._pkgConf.builder.electron,
+        electronConfig: this._pkgConf.builder.electron,
       });
     }
 

package/src/sd-cli-entry.ts

@@ -14,6 +14,9 @@ import { SdCliAiCommand } from "./entry/sd-cli-ai-command";
 import { SdCliPostinstall } from "./entry/sd-cli-postinstall";
 import convertEcmaPrivateToTsPrivate from "./fix/convert-ecma-private-to-ts-private";
 import prefixUnderscoreForAccessModifiers from "./fix/prefix-underscore-for-access-modifiers";
+import convertSdSheetBindingsInInlineTemplate
+  from "./fix/convert-sd-sheet-bindings-inInline-template";
+import convertOrderingInterface from "./fix/convert-ordering-interface";
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
@@ -252,11 +255,17 @@ await yargs(hideBin(process.argv))
     () => {
       convertEcmaPrivateToTsPrivate();
       prefixUnderscoreForAccessModifiers();
+      convertSdSheetBindingsInInlineTemplate();
+      convertOrderingInterface();
     },
   )
   .strict()
   .recommendCommands()
   .fail((msg, err, cmd) => {
+    if (Boolean(err)) {
+      throw err;
+    }
+
     console.error("지원되지 않는 명령입니다.");
     console.error(msg);
     console.log("\n명령어 목록:");

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

@@ -136,11 +136,9 @@ export class SdTsCompiler {
         ...args,
       );
 
-      if (sf) {
-        this._sourceFileCacheMap.set(fileNPath, sf);
-      }
-      else {
+      if (!sf) {
         this._sourceFileCacheMap.delete(fileNPath);
+        return undefined;
       }
 
       return sf;
@@ -522,10 +520,17 @@ ${affectedFileTree.map(item => getTreeText(item)).join("\n")}`.trim());
       let transformers: ts.CustomTransformers = {};
 
       if (this._ngProgram) {
-        transformers = {
-          ...transformers,
-          ...this._ngProgram.compiler.prepareEmit().transformers,
-        };
+        const angularTransfomers = this._ngProgram.compiler.prepareEmit().transformers;
+        (transformers.before ??= []).push(
+          ...(angularTransfomers.before ?? []),
+        );
+        (transformers.after ??= []).push(
+          ...(angularTransfomers.after ?? []),
+        );
+        (transformers.afterDeclarations ??= []).push(
+          ...(angularTransfomers.afterDeclarations ?? []),
+        );
+
         (transformers.before ??= []).push(replaceBootstrap(() => this._program!.getTypeChecker()));
         (transformers.before ??= []).push(
           createWorkerTransformer((file, importer) => {