maishu-scripts 1.4.2 → 1.4.5

package/src/modules/actions/babel-compile.test.ts

@@ -0,0 +1,436 @@
+import { create, generateDeclarationFile } from './babel-compile';
+import * as path from 'path';
+import * as fs from 'fs';
+
+describe('compileFile (via create)', () => {
+    let testDir: string;
+    let fixturesDir: string;
+    let outDir: string;
+    let sourceFile: string;
+
+    const defaultBabelOptions: any = {
+        presets: ['@babel/preset-typescript'],
+        ast: true,
+        code: false,
+    };
+
+    beforeAll(() => {
+        fixturesDir = path.join(__dirname, '..', '..', '..', 'test', 'fixtures', 'compile');
+        outDir = path.join(fixturesDir, 'out');
+
+        if (!fs.existsSync(fixturesDir)) {
+            fs.mkdirSync(fixturesDir, { recursive: true });
+        }
+
+        sourceFile = path.join(fixturesDir, 'simple.ts');
+        const sourceContent = `
+export interface Config {
+    name: string;
+    value: number;
+}
+
+export function greet(name: string): string {
+    return \`Hello, \${name}!\`;
+}
+
+export const VERSION = '1.0.0';
+`;
+        fs.writeFileSync(sourceFile, sourceContent);
+    });
+
+    afterEach(async () => {
+        if (fs.existsSync(outDir)) {
+            fs.rmSync(outDir, { recursive: true, force: true });
+        }
+    });
+
+    afterAll(() => {
+        if (fs.existsSync(sourceFile)) {
+            fs.rmSync(sourceFile, { force: true });
+        }
+        if (fs.existsSync(fixturesDir)) {
+            fs.rmSync(fixturesDir, { recursive: true, force: true });
+        }
+    });
+
+    describe('basic compilation', () => {
+        test('should compile .ts file and generate output', async () => {
+            expect(fs.existsSync(sourceFile)).toBeTruthy();
+
+            const compileFile = create({
+                defaultBabelOptions: {
+                    ...defaultBabelOptions,
+                    sourceMaps: false,
+                }
+            });
+
+            await compileFile(sourceFile, outDir, fixturesDir);
+
+            const expectedOutput = path.join(outDir, 'simple.js');
+            expect(fs.existsSync(expectedOutput)).toBeTruthy();
+
+            const content = fs.readFileSync(expectedOutput, 'utf-8');
+            expect(content.length).toBeGreaterThan(0);
+        });
+
+        test('should compile .ts file with source maps', async () => {
+            const compileFile = create({
+                defaultBabelOptions: {
+                    ...defaultBabelOptions,
+                    sourceMaps: true,
+                }
+            });
+
+            await compileFile(sourceFile, outDir, fixturesDir);
+
+            const expectedOutput = path.join(outDir, 'simple.js');
+            expect(fs.existsSync(expectedOutput)).toBeTruthy();
+
+            const mapFile = path.join(outDir, 'simple.js.map');
+            expect(fs.existsSync(mapFile)).toBeTruthy();
+
+            const mapContent = JSON.parse(fs.readFileSync(mapFile, 'utf-8'));
+            expect(mapContent.file).toBe('simple.js');
+            expect(mapContent.sources).toBeDefined();
+        });
+
+        test('should create output directory if not exists', async () => {
+            const nestedOutDir = path.join(fixturesDir, 'nested', 'deep', 'out');
+
+            const compileFile = create({
+                defaultBabelOptions
+            });
+
+            await compileFile(sourceFile, nestedOutDir, fixturesDir);
+
+            const expectedOutput = path.join(nestedOutDir, 'simple.js');
+            expect(fs.existsSync(expectedOutput)).toBeTruthy();
+
+            fs.rmSync(path.join(fixturesDir, 'nested'), { recursive: true, force: true });
+        });
+    });
+
+    describe('error handling', () => {
+        test('should warn and return early when source file does not exist', async () => {
+            const nonExistentFile = path.join(fixturesDir, 'non-existent.ts');
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+            const compileFile = create({
+                defaultBabelOptions
+            });
+
+            await compileFile(nonExistentFile, outDir, fixturesDir);
+
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Path not exists'));
+            warnSpy.mockRestore();
+
+            const expectedOutput = path.join(outDir, 'non-existent.js');
+            expect(fs.existsSync(expectedOutput)).toBeFalsy();
+        });
+
+        test('should throw error when babel transform fails', async () => {
+            const invalidFile = path.join(fixturesDir, 'invalid.ts');
+            fs.writeFileSync(invalidFile, 'const x: = invalid syntax;');
+
+            const compileFile = create({
+                defaultBabelOptions
+            });
+
+            await expect(compileFile(invalidFile, outDir, fixturesDir)).rejects.toThrow();
+
+            fs.rmSync(invalidFile, { force: true });
+        });
+    });
+
+    describe('output extensions', () => {
+        test('should output .mjs file when specified', async () => {
+            const compileFile = create({
+                defaultBabelOptions,
+                outExt: '.mjs'
+            });
+
+            await compileFile(sourceFile, outDir, fixturesDir);
+
+            const expectedOutput = path.join(outDir, 'simple.mjs');
+            expect(fs.existsSync(expectedOutput)).toBeTruthy();
+        });
+
+        test('should output .cjs file when specified', async () => {
+            const compileFile = create({
+                defaultBabelOptions,
+                outExt: '.cjs'
+            });
+
+            await compileFile(sourceFile, outDir, fixturesDir);
+
+            const expectedOutput = path.join(outDir, 'simple.cjs');
+            expect(fs.existsSync(expectedOutput)).toBeTruthy();
+        });
+    });
+
+    describe('declaration file generation', () => {
+        test('should generate declaration file when generateDeclaration is true', async () => {
+            const declSourceFile = path.join(fixturesDir, 'decl-test.ts');
+            const sourceContent = `
+export interface User {
+    id: number;
+    name: string;
+}
+
+export function greet(name: string): string {
+    return \`Hello, \${name}\`;
+}
+`;
+            fs.writeFileSync(declSourceFile, sourceContent);
+
+            const compileFile = create({
+                defaultBabelOptions,
+                generateDeclaration: true
+            });
+
+            await compileFile(declSourceFile, outDir, fixturesDir);
+
+            const expectedJs = path.join(outDir, 'decl-test.js');
+            const expectedDecl = path.join(outDir, 'decl-test.d.ts');
+
+            expect(fs.existsSync(expectedJs)).toBeTruthy();
+            expect(fs.existsSync(expectedDecl)).toBeTruthy();
+
+            const declContent = fs.readFileSync(expectedDecl, 'utf-8');
+            expect(declContent).toContain('User');
+            expect(declContent).toContain('greet');
+
+            fs.rmSync(declSourceFile, { force: true });
+        });
+
+        test('should not generate declaration file when generateDeclaration is false', async () => {
+            const noDeclSourceFile = path.join(fixturesDir, 'no-decl-test.ts');
+            const sourceContent = `
+export interface Config {
+    key: string;
+}
+`;
+            fs.writeFileSync(noDeclSourceFile, sourceContent);
+
+            const compileFile = create({
+                defaultBabelOptions,
+                generateDeclaration: false
+            });
+
+            await compileFile(noDeclSourceFile, outDir, fixturesDir);
+
+            const expectedJs = path.join(outDir, 'no-decl-test.js');
+            const expectedDecl = path.join(outDir, 'no-decl-test.d.ts');
+
+            expect(fs.existsSync(expectedJs)).toBeTruthy();
+            expect(fs.existsSync(expectedDecl)).toBeFalsy();
+
+            fs.rmSync(noDeclSourceFile, { force: true });
+        });
+    });
+
+    describe('source map behavior', () => {
+        test('should generate map file when sourceMaps is enabled', async () => {
+            const compileWithMaps = create({
+                defaultBabelOptions: {
+                    ...defaultBabelOptions,
+                    sourceMaps: true,
+                }
+            });
+            await compileWithMaps(sourceFile, outDir, fixturesDir);
+
+            const mapFile = path.join(outDir, 'simple.js.map');
+            expect(fs.existsSync(mapFile)).toBeTruthy();
+
+            const outputFile = path.join(outDir, 'simple.js');
+            const content = fs.readFileSync(outputFile, 'utf-8');
+            expect(content).toContain('sourceMappingURL=');
+        });
+
+        test('should not generate map file when sourceMaps is disabled', async () => {
+            const compileWithoutMaps = create({
+                defaultBabelOptions: {
+                    ...defaultBabelOptions,
+                    sourceMaps: false,
+                }
+            });
+            await compileWithoutMaps(sourceFile, outDir, fixturesDir);
+
+            const outputFile = path.join(outDir, 'simple.js');
+            expect(fs.existsSync(outputFile)).toBeTruthy();
+
+            const content = fs.readFileSync(outputFile, 'utf-8');
+            expect(content).not.toContain('sourceMappingURL=');
+        });
+    });
+});
+
+describe('generateDeclarationFile', () => {
+    let testDir: string;
+    let fixturesDir: string;
+
+    beforeAll(() => {
+        testDir = path.join(__dirname, '..', '..', '..', 'test');
+        fixturesDir = path.join(testDir, 'fixtures', 'declaration');
+
+        if (!fs.existsSync(fixturesDir)) {
+            fs.mkdirSync(fixturesDir, { recursive: true });
+        }
+    });
+
+    afterEach(() => {
+        if (fs.existsSync(fixturesDir)) {
+            fs.readdirSync(fixturesDir).forEach(file => {
+                fs.rmSync(path.join(fixturesDir, file), { force: true });
+            });
+        }
+    });
+
+    afterAll(() => {
+        if (fs.existsSync(fixturesDir)) {
+            fs.rmSync(fixturesDir, { recursive: true, force: true });
+        }
+    });
+
+    test('should generate declaration file for .ts source', async () => {
+        const sourcePath = path.join(fixturesDir, 'sample.ts');
+        fs.writeFileSync(sourcePath, 'export const x: number = 1;');
+
+        const targetPath = path.join(fixturesDir, 'sample.js');
+        const outExt: '.js' = '.js';
+        const expectedDeclPath = path.join(fixturesDir, 'sample.d.ts');
+
+        await generateDeclarationFile(path.resolve(), sourcePath, targetPath, outExt);
+
+        expect(fs.existsSync(expectedDeclPath)).toBeTruthy();
+        const content = fs.readFileSync(expectedDeclPath, 'utf-8');
+        expect(content.length).toBeGreaterThan(0);
+    });
+
+    test('should generate declaration file for .tsx source', async () => {
+        const tsxSource = path.join(fixturesDir, 'component.tsx');
+        const tsxContent = `
+export interface ComponentProps {
+    name: string;
+    value?: number;
+}
+
+export function Component(props: ComponentProps): string {
+    return props.name;
+}
+`;
+        fs.writeFileSync(tsxSource, tsxContent);
+
+        const targetPath = path.join(fixturesDir, 'component.js');
+        const outExt: '.js' = '.js';
+        const expectedDeclPath = path.join(fixturesDir, 'component.d.ts');
+
+        await generateDeclarationFile(path.resolve(), tsxSource, targetPath, outExt);
+
+        expect(fs.existsSync(expectedDeclPath)).toBeTruthy();
+        const content = fs.readFileSync(expectedDeclPath, 'utf-8');
+        expect(content).toContain('ComponentProps');
+        expect(content).toContain('Component');
+    });
+
+    test('should skip for .js source file', async () => {
+        const sourcePath = path.join(fixturesDir, 'sample.js');
+        fs.writeFileSync(sourcePath, 'const x = 1;');
+
+        const targetPath = path.join(fixturesDir, 'sample.js');
+        const outExt: '.js' = '.js';
+        const expectedDeclPath = path.join(fixturesDir, 'sample.d.ts');
+
+        await generateDeclarationFile(path.resolve(), sourcePath, targetPath, outExt);
+
+        expect(fs.existsSync(expectedDeclPath)).toBeFalsy();
+    });
+
+    test('should skip for .mjs source file', async () => {
+        const sourcePath = path.join(fixturesDir, 'sample.mjs');
+        fs.writeFileSync(sourcePath, 'export const x = 1;');
+
+        const targetPath = path.join(fixturesDir, 'sample.mjs');
+        const outExt: '.mjs' = '.mjs';
+        const expectedDeclPath = path.join(fixturesDir, 'sample.d.ts');
+
+        await generateDeclarationFile(path.resolve(), sourcePath, targetPath, outExt);
+
+        expect(fs.existsSync(expectedDeclPath)).toBeFalsy();
+    });
+
+    test('should handle .cjs extension correctly', async () => {
+        const sourcePath = path.join(fixturesDir, 'sample.cjs');
+        fs.writeFileSync(sourcePath, 'module.exports = {};');
+
+        const targetPath = path.join(fixturesDir, 'sample.cjs');
+        const outExt: '.cjs' = '.cjs';
+        const expectedDeclPath = path.join(fixturesDir, 'sample.d.ts');
+
+        await generateDeclarationFile(path.resolve(), sourcePath, targetPath, outExt);
+
+        expect(fs.existsSync(expectedDeclPath)).toBeFalsy();
+    });
+
+    test('should generate declaration for module with exports', async () => {
+        const sourcePath = path.join(fixturesDir, 'exports.ts');
+        const exportsContent = `
+export interface User {
+    id: number;
+    name: string;
+}
+
+export type Status = 'active' | 'inactive';
+
+export function greet(name: string): string {
+    return \`Hello, \${name}!\`;
+}
+
+export const VERSION = '1.0.0';
+`;
+        fs.writeFileSync(sourcePath, exportsContent);
+
+        const targetPath = path.join(fixturesDir, 'exports.js');
+        const outExt: '.js' = '.js';
+        const expectedDeclPath = path.join(fixturesDir, 'exports.d.ts');
+
+        await generateDeclarationFile(path.resolve(), sourcePath, targetPath, outExt);
+
+        expect(fs.existsSync(expectedDeclPath)).toBeTruthy();
+        const content = fs.readFileSync(expectedDeclPath, 'utf-8');
+        expect(content).toContain('User');
+        expect(content).toContain('Status');
+        expect(content).toContain('greet');
+        expect(content).toContain('VERSION');
+    });
+
+    test('should handle file with type errors and still generate declaration', async () => {
+        const sourcePath = path.join(fixturesDir, 'with-error.ts');
+        const errorContent = `
+export function add(a: number, b: string): number {
+    return a + b;
+}
+`;
+        fs.writeFileSync(sourcePath, errorContent);
+
+        const targetPath = path.join(fixturesDir, 'with-error.js');
+        const outExt: '.js' = '.js';
+        const expectedDeclPath = path.join(fixturesDir, 'with-error.d.ts');
+
+        await expect(generateDeclarationFile(path.resolve(), sourcePath, targetPath, outExt)).resolves.not.toThrow();
+        expect(fs.existsSync(expectedDeclPath)).toBeTruthy();
+    });
+
+    test('should correctly replace output extension with .d.ts', async () => {
+        const sourcePath = path.join(fixturesDir, 'test.ts');
+        fs.writeFileSync(sourcePath, 'export const x = 1;');
+
+        const targetPath = path.join(fixturesDir, 'output.mjs');
+        const outExt: '.mjs' = '.mjs';
+        const expectedDeclPath = path.join(fixturesDir, 'output.d.ts');
+
+        await generateDeclarationFile(path.resolve(), sourcePath, targetPath, outExt);
+
+        expect(fs.existsSync(expectedDeclPath)).toBeTruthy();
+    });
+});

package/src/modules/actions/babel-compile.ts

@@ -2,6 +2,7 @@
 import * as babel from "@babel/core";
 import * as fs from "fs";
 import * as path from "path";
+import * as ts from "typescript";
 import { errors } from "../errors";
 import { ProjectCompiler } from "../project-compiler";
 import { FileAction, JavaScriptExtension } from "../../types";
@@ -9,32 +10,41 @@ import { FileAction, JavaScriptExtension } from "../../types";
 // const outExt = ProjectCompiler.tsOutExt;
 
 
-export function create(defaultBabelOptions?: babel.TransformOptions, outExit?: JavaScriptExtension): FileAction {
+export function create(defaultBabelOptions?: babel.TransformOptions & { declaration?: boolean }, outExt?: JavaScriptExtension): FileAction {
     const action: FileAction = (sourcePath: string, outputPath: string, projectPath: string) => {
-        outExit = outExit || ".js";
-        if (defaultBabelOptions) {
-            return compileFile(sourcePath, outputPath, projectPath, defaultBabelOptions, outExit);
+        outExt = outExt || ".js";
+
+        let babelOptions = defaultBabelOptions;
+        if (!babelOptions) {
+            // 如果没有 babelOptions，则尝试从项目目录查找 babel 配置文件，如果没有，则使用默认配置。
+            // let babelOptions: babel.TransformOptions;
+            let bablePath: string;
+            let sourceDir = path.dirname(sourcePath);
+            if (projectPath) {
+                let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
+                bablePath = c.path;
+                babelOptions = c.options;
+            }
+            else {
+                babelOptions = ProjectCompiler.getDefaultBabelConfig();
+                bablePath = '';
+            }
+
+            babelOptions.filename = sourcePath;
+            babelOptions.code = false;
+            babelOptions.ast = true;
         }
 
-        // 如果没有 babelOptions，则尝试从项目目录查找 babel 配置文件，如果没有，则使用默认配置。
-        let babelOptions: babel.TransformOptions;
-        let bablePath: string;
-        let sourceDir = path.dirname(sourcePath);
-        if (projectPath) {
-            let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
-            bablePath = c.path;
-            babelOptions = c.options;
+        const declaration = babelOptions.declaration || false;
+        delete babelOptions.declaration;
+        if (declaration) {
+            // 如果需要生成声明文件，则调用 ts-compile 模块的生成声明文件方法
+            const ext = path.extname(sourcePath);
+            let targetPath = path.join(outputPath, path.basename(sourcePath).replace(ext, outExt));
+            generateDeclarationFile(projectPath, sourcePath, targetPath, outExt);
         }
-        else {
-            babelOptions = ProjectCompiler.getDefaultBabelConfig();
-            bablePath = '';
-        }
-
-        babelOptions.filename = sourcePath;
-        babelOptions.code = false;
-        babelOptions.ast = true;
 
-        return compileFile(sourcePath, outputPath, projectPath, babelOptions, outExit);
+        return compileFile(sourcePath, outputPath, projectPath, babelOptions, outExt);
     }
     return action;
 }
@@ -45,41 +55,16 @@ export function create(defaultBabelOptions?: babel.TransformOptions, outExit?: J
  * @param outputPath 输出目录
  * @param projectPath 项目路径
  * */
-async function compileFile(sourcePath: string, outputPath: string, projectPath: string, babelOptions: babel.TransformOptions, outExt: JavaScriptExtension) {
+async function compileFile(sourcePath: string, outputPath: string, projectPath: string, babelOptions: babel.TransformOptions, outExt: JavaScriptExtension, generateDeclaration = false): Promise<void> {
     if (!sourcePath) throw errors.argumentNull("sourcePath");
     if (!outputPath) throw errors.argumentNull("outputPath");
     if (!projectPath) throw errors.argumentNull("projectPath");
 
-    // if (!fs.existsSync(sourcePath)) throw errors.pathNotExists(sourcePath);
     if (!fs.existsSync(sourcePath)) {
         console.warn(`Path not exists: ${sourcePath}`);
         return;
     }
 
-    let sourceDir = path.dirname(sourcePath);
-    // let babelOptions: babel.TransformOptions;
-    let bablePath: string;
-    //= projectPath ?
-    //  ProjectCompiler.getBabelConfig(projectPath, sourceDir) : ProjectCompiler.getDefaultBabelConfig();
-    if (projectPath) {
-        //     let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
-        //     bablePath = c.path;
-        //     babelOptions = c.options;
-    }
-    else {
-        //     babelOptions = ProjectCompiler.getDefaultBabelConfig();
-        //     bablePath = '';
-    }
-
-    // babelOptions.filename = sourcePath;
-    // babelOptions.code = false;
-    // babelOptions.ast = true;
-
-
-    // let fileResult = babel.transformFileSync(sourcePath, {
-    //     filename: sourcePath, code: false, ast: true, plugins,
-    //     presets
-    // });
     let fileResult = babel.transformFileSync(sourcePath, babelOptions);
     if (!fileResult)
         throw errors.compileError(sourcePath);
@@ -122,6 +107,10 @@ async function compileFile(sourcePath: string, outputPath: string, projectPath:
 
     fs.writeFileSync(targetPath, r.code);
 
+    if (generateDeclaration) {
+        await generateDeclarationFile(projectPath, sourcePath, targetPath, outExt);
+    }
+
 }
 
 function extname(file: string) {
@@ -130,22 +119,6 @@ function extname(file: string) {
     return ext;
 }
 
-/** 
- * 获取源文件所对应生成文件的扩展名 
- * @param file 源文件名
- * */
-// function fileOutExt(file: string) {
-//     let ext = extname(file);
-//     if (ext === ".ts")
-//         return outExt;
-
-//     if (ext === ".tsx")
-//         return outExt;
-
-//     return ext;
-// }
-
-
 class ImportPathRewrite {
     constructor(private filePath: string, node: babel.types.File, private outExt: JavaScriptExtension) {
         this.traverse(node);
@@ -176,7 +149,50 @@ class ImportPathRewrite {
 
         }
     }
-
 }
 
 
+/**
+ * 生成声明文件
+ * @param projectPath 项目路径
+ * @param sourcePath 源文件
+ * @param targetPath 目标文件
+ * @param outExt 输出扩展名
+ */
+export function generateDeclarationFile(projectPath: string, sourcePath: string, targetPath: string, outExt: JavaScriptExtension): Promise<void> {
+    if (!projectPath) throw errors.argumentNull("projectPath");
+    if (!sourcePath) throw errors.argumentNull("sourcePath");
+    if (!targetPath) throw errors.argumentNull("targetPath");
+
+    const sourceExt = path.extname(sourcePath);
+    if (!sourceExt || (sourceExt !== ".ts" && sourceExt !== ".tsx")) {
+        return Promise.resolve();
+    }
+
+    const declarationPath = targetPath.endsWith(outExt)
+        ? targetPath.slice(0, targetPath.length - outExt.length) + ".d.ts"
+        : targetPath.replace(path.extname(targetPath), ".d.ts");
+
+    const content = fs.readFileSync(sourcePath, "utf-8");
+    const result = ts.transpileDeclaration(content, {
+        fileName: path.basename(sourcePath),
+        reportDiagnostics: false,
+        compilerOptions: {
+            declaration: true,
+            emitDeclarationOnly: true,
+            skipLibCheck: true,
+            esModuleInterop: true,
+            jsx: ts.JsxEmit.React,
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.NodeNext,
+        }
+    });
+
+    const outDir = path.dirname(declarationPath);
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+    }
+
+    fs.writeFileSync(declarationPath, result.outputText || "");
+    return Promise.resolve();
+}

package/src/modules/actions/copy-file.ts

@@ -8,15 +8,23 @@ let copyFile: FileAction = (filePath: string, outPath: string) => {
     if (!outPath) throw errors.argumentNull("outPath");
 
     if (!fs.existsSync(filePath)) {
+        throw errors.pathNotExists(filePath);
+    }
+
+    if (!fs.statSync(filePath).isFile()) {
         return;
     }
 
-    let out = filePath.replace(path.dirname(filePath), outPath);
-    let outDirPath = path.resolve(out, "..");
+    const destFilePath = path.join(outPath, path.basename(filePath));
+    const destDirPath = path.dirname(destFilePath);
 
-    fs.mkdirSync(outDirPath, { recursive: true });
+    fs.mkdirSync(destDirPath, { recursive: true });
 
-    fs.copyFileSync(filePath, out);
+    try {
+        fs.copyFileSync(filePath, destFilePath);
+    } catch (err) {
+        throw errors.copyFileError(filePath, destFilePath, err as Error);
+    }
 }
 
 export default copyFile;

package/src/modules/compile.ts

@@ -89,10 +89,10 @@ type Options = {
 }
 function generateCodeByOptions(options: Options) {
 
-    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
-
-    if (!defaultAction)
-        defaultAction = copyFile;
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
+
+    // if (!defaultAction)
+    //     defaultAction = copyFile;
 
 
     if (!sourceDir) throw errors.argumentNull("sourceDir");
@@ -140,9 +140,9 @@ function generateCodeByOptions(options: Options) {
 }
 
 function watchDirectoryByOptions(options: Options) {
-    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
-
-    if (!defaultAction)
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
+
+    if (!defaultAction)
         defaultAction = copyFile;
 
     watch(sourceDir, { recursive: true }, async (evt: "update" | "remove", name: string) => {