@eggjs/bin 7.0.0-beta.4 → 7.0.0

package/src/baseCommand.ts

@@ -1,14 +1,15 @@
 import { debuglog } from 'node:util';
-// import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import path from 'node:path';
 import { fork, ForkOptions, ChildProcess } from 'node:child_process';
 import { Command, Flags, Interfaces } from '@oclif/core';
 import { importResolve } from '@eggjs/utils';
+import { runScript } from 'runscript';
 import {
-  addNodeOptionsToEnv,
   getSourceDirname,
-  // readPackageJSON, hasTsConfig, getSourceFilename,
+  readPackageJSON, hasTsConfig,
 } from './utils.js';
+import { PackageEgg } from './types.js';
 
 const debug = debuglog('@eggjs/bin/baseCommand');
 
@@ -40,7 +41,7 @@ function graceful(proc: ChildProcess) {
   }
 }
 
-class ForkError extends Error {
+export class ForkError extends Error {
   code: number | null;
   constructor(message: string, code: number | null) {
     super(message);
@@ -48,8 +49,12 @@ class ForkError extends Error {
   }
 }
 
-export type Flags<T extends typeof Command> = Interfaces.InferredFlags<typeof BaseCommand['baseFlags'] & T['flags']>;
-export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export interface ForkNodeOptions extends ForkOptions {
+  dryRun?: boolean;
+}
+
+type Flags<T extends typeof Command> = Interfaces.InferredFlags<typeof BaseCommand['baseFlags'] & T['flags']>;
+type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
 
 export abstract class BaseCommand<T extends typeof Command> extends Command {
   // add the --json flag
@@ -63,7 +68,7 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
     //   options: ['debug', 'warn', 'error', 'info', 'trace'] as const,
     //   summary: 'Specify level for logging.',
     // })(),
-    dryRun: Flags.boolean({
+    'dry-run': Flags.boolean({
       default: false,
       helpGroup: 'GLOBAL',
       summary: 'whether show full command script only',
@@ -75,21 +80,66 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
       char: 'r',
       multiple: true,
     }),
+    import: Flags.string({
+      helpGroup: 'GLOBAL',
+      summary: 'import the given module, only work on ESM',
+      multiple: true,
+    }),
     base: Flags.string({
       helpGroup: 'GLOBAL',
-      summary: 'directory of application, default to `process.cwd()`',
+      summary: 'directory of application',
       aliases: [ 'baseDir' ],
       default: process.cwd(),
     }),
+    tscompiler: Flags.string({
+      helpGroup: 'GLOBAL',
+      summary: 'TypeScript compiler, like ts-node/register',
+      aliases: [ 'tsc' ],
+    }),
+    // flag with no value (--typescript)
+    typescript: Flags.boolean({
+      helpGroup: 'GLOBAL',
+      description: '[default: true] use TypeScript to run the test',
+      allowNo: true,
+    }),
+    ts: Flags.string({
+      helpGroup: 'GLOBAL',
+      description: 'shortcut for --typescript, e.g.: --ts=false',
+      options: [ 'true', 'false' ],
+    }),
+    javascript: Flags.boolean({
+      helpGroup: 'GLOBAL',
+      description: 'use JavaScript to run the test',
+      aliases: [ 'js' ],
+    }),
+    declarations: Flags.boolean({
+      helpGroup: 'GLOBAL',
+      description: 'whether create typings, will add `--require egg-ts-helper/register`',
+      aliases: [ 'dts' ],
+    }),
+    // https://nodejs.org/dist/latest-v18.x/docs/api/cli.html#--inspect-brkhostport
+    inspect: Flags.boolean({
+      helpGroup: 'GLOBAL',
+      description: 'Activate inspector',
+    }),
+    'inspect-brk': Flags.boolean({
+      helpGroup: 'GLOBAL',
+      description: 'Activate inspector and break at start of user script',
+    }),
   };
 
   protected flags!: Flags<T>;
   protected args!: Args<T>;
 
-  protected env = process.env;
+  protected env = { ...process.env };
+  protected pkg: Record<string, any>;
+  protected isESM: boolean;
+  protected pkgEgg: PackageEgg;
+  protected globalExecArgv: string[] = [];
 
   public async init(): Promise<void> {
     await super.init();
+    debug('[init] raw args: %o, NODE_ENV: %o', this.argv, this.env.NODE_ENV);
     const { args, flags } = await this.parse({
       flags: this.ctor.flags,
       baseFlags: (super.ctor as typeof BaseCommand).baseFlags,
@@ -100,18 +150,151 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
     this.flags = flags as Flags<T>;
     this.args = args as Args<T>;
 
-    // use ts-node/esm loader on esm
-    let esmLoader = importResolve('ts-node/esm', {
-      paths: [ getSourceDirname() ],
-    });
-    // ES Module loading with absolute path fails on windows
-    // https://github.com/nodejs/node/issues/31710#issuecomment-583916239
-    // https://nodejs.org/api/url.html#url_url_pathtofileurl_path
-    // Error [ERR_UNSUPPORTED_ESM_URL_SCHEME]: Only URLs with a scheme in: file, data, and node are supported by the default ESM loader. On Windows, absolute paths must be valid file:// URLs. Received protocol 'd:'
-    esmLoader = pathToFileURL(esmLoader).href;
-    // wait for https://github.com/nodejs/node/issues/40940
-    addNodeOptionsToEnv('--no-warnings', this.env);
-    addNodeOptionsToEnv(`--loader ${esmLoader}`, this.env);
+    await this.#afterInit();
+  }
+
+  async #afterInit() {
+    const { args, flags } = this;
+    debug('before: args: %o, flags: %o', args, flags);
+    if (!path.isAbsolute(flags.base)) {
+      flags.base = path.join(process.cwd(), flags.base);
+    }
+    const pkg = await readPackageJSON(flags.base);
+    this.pkg = pkg;
+    this.pkgEgg = pkg.egg ?? {};
+    flags.tscompiler = flags.tscompiler ?? this.env.TS_COMPILER ?? this.pkgEgg.tscompiler;
+
+    let typescript: boolean = flags.typescript;
+    // keep compatible with old ts flag: `--ts=true` or `--ts=false`
+    if (flags.ts === 'true') {
+      typescript = true;
+    } else if (flags.ts === 'false') {
+      typescript = false;
+    }
+
+    if (typescript === undefined) {
+      // try to ready EGG_TYPESCRIPT env first, only accept 'true' or 'false' string
+      if (this.env.EGG_TYPESCRIPT === 'false') {
+        typescript = false;
+        debug('detect typescript=%o from EGG_TYPESCRIPT=%o', false, this.env.EGG_TYPESCRIPT);
+      } else if (this.env.EGG_TYPESCRIPT === 'true') {
+        typescript = true;
+        debug('detect typescript=%o from EGG_TYPESCRIPT=%o', true, this.env.EGG_TYPESCRIPT);
+      } else if (typeof this.pkgEgg.typescript === 'boolean') {
+        // read `egg.typescript` from package.json if not pass argv
+        typescript = this.pkgEgg.typescript;
+        debug('detect typescript=%o from pkg.egg.typescript=%o', typescript, this.pkgEgg.typescript);
+      } else if (pkg.dependencies?.typescript) {
+        // auto detect pkg.dependencies.typescript or pkg.devDependencies.typescript
+        typescript = true;
+        debug('detect typescript=%o from pkg.dependencies.typescript=%o', true, pkg.dependencies.typescript);
+      } else if (pkg.devDependencies?.typescript) {
+        typescript = true;
+        debug('detect typescript=%o from pkg.devDependencies.typescript=%o', true, pkg.devDependencies.typescript);
+      } else if (await hasTsConfig(flags.base)) {
+        // tsconfig.json exists
+        typescript = true;
+        debug('detect typescript=%o cause tsconfig.json exists', true);
+      } else if (flags.tscompiler) {
+        typescript = true;
+        debug('detect typescript=%o from --tscompiler=%o', true, flags.tscompiler);
+      }
+    }
+    flags.typescript = typescript;
+
+    this.isESM = pkg.type === 'module';
+    if (typescript) {
+      const findPaths: string[] = [ getSourceDirname() ];
+      if (flags.tscompiler) {
+        // try app baseDir first on custom tscompiler
+        // then try to find tscompiler in @eggjs/bin/node_modules
+        findPaths.unshift(flags.base);
+      }
+      flags.tscompiler = flags.tscompiler ?? 'ts-node/register';
+      const tsNodeRegister = importResolve(flags.tscompiler, {
+        paths: findPaths,
+      });
+      flags.tscompiler = tsNodeRegister;
+      // should require tsNodeRegister on current process, let it can require *.ts files
+      // e.g.: dev command will execute egg loader to find configs and plugins
+      // await importModule(tsNodeRegister);
+      // let child process auto require ts-node too
+      this.addNodeOptions(this.formatImportModule(tsNodeRegister));
+      // tell egg loader to load ts file
+      // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L443
+      this.env.EGG_TYPESCRIPT = 'true';
+      // set current process.env.EGG_TYPESCRIPT too
+      process.env.EGG_TYPESCRIPT = 'true';
+      // load files from tsconfig on startup
+      this.env.TS_NODE_FILES = process.env.TS_NODE_FILES ?? 'true';
+      // keep same logic with egg-core, test cmd load files need it
+      // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L49
+      // addNodeOptionsToEnv(`--require ${importResolve('tsconfig-paths/register', {
+      //   paths: [ getSourceDirname() ],
+      // })}`, ctx.env);
+    }
+    if (this.isESM) {
+      // use ts-node/esm loader on esm
+      let esmLoader = importResolve('ts-node/esm', {
+        paths: [ getSourceDirname() ],
+      });
+      // ES Module loading with absolute path fails on windows
+      // https://github.com/nodejs/node/issues/31710#issuecomment-583916239
+      // https://nodejs.org/api/url.html#url_url_pathtofileurl_path
+      // Error [ERR_UNSUPPORTED_ESM_URL_SCHEME]: Only URLs with a scheme in: file, data, and node are supported by the default ESM loader. On Windows, absolute paths must be valid file:// URLs. Received protocol 'd:'
+      esmLoader = pathToFileURL(esmLoader).href;
+      // wait for https://github.com/nodejs/node/issues/40940
+      this.addNodeOptions('--no-warnings');
+      this.addNodeOptions(`--loader ${esmLoader}`);
+    }
+
+    if (flags.declarations === undefined) {
+      if (typeof this.pkgEgg.declarations === 'boolean') {
+        // read `egg.declarations` from package.json if not pass argv
+        flags.declarations = this.pkgEgg.declarations;
+        debug('detect declarations from pkg.egg.declarations=%o', this.pkgEgg.declarations);
+      }
+    }
+    if (flags.declarations) {
+      const etsBin = importResolve('egg-ts-helper/dist/bin', {
+        paths: [
+          flags.base,
+          getSourceDirname(),
+        ],
+      });
+      debug('run ets first: %o', etsBin);
+      await runScript(`node ${etsBin}`);
+    }
+
+    if (this.pkgEgg.revert) {
+      const reverts = Array.isArray(this.pkgEgg.revert) ? this.pkgEgg.revert : [ this.pkgEgg.revert ];
+      for (const revert of reverts) {
+        this.globalExecArgv.push(`--security-revert=${revert}`);
+      }
+    }
+
+    let hasInspectOption = false;
+    if (flags.inspect) {
+      this.addNodeOptions('--inspect');
+      hasInspectOption = true;
+    }
+    if (flags['inspect-brk']) {
+      this.addNodeOptions('--inspect-brk');
+      hasInspectOption = true;
+    }
+    if (hasInspectOption) {
+      Reflect.set(flags, 'timeout', 0);
+      debug('set timeout = 0 when inspect enable');
+    } else if (this.env.JB_DEBUG_FILE) {
+      // others like WebStorm 2019 will pass NODE_OPTIONS, and @eggjs/bin itself will be debug, so could detect `process.env.JB_DEBUG_FILE`.
+      Reflect.set(flags, 'timeout', 0);
+      debug('set timeout = false when process.env.JB_DEBUG_FILE=%o', this.env.JB_DEBUG_FILE);
+    }
+
+    debug('baseDir: %o, isESM: %o', flags.base, this.isESM);
+    debug('set NODE_OPTIONS: %o', this.env.NODE_OPTIONS);
+    debug('after: args: %o, flags: %o', args, flags);
+    debug('enter real command: %o', this.id);
   }
 
   protected async catch(err: Error & {exitCode?: number}): Promise<any> {
@@ -126,42 +309,70 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
   }
 
   protected async formatRequires(): Promise<string[]> {
-    const requires = this.args.require ?? [];
-    // const eggRequire = this.args.pkgEgg.require;
-    // if (Array.isArray(eggRequire)) {
-    //   for (const r of eggRequire) {
-    //     requires.push(r);
-    //   }
-    // } else if (typeof eggRequire === 'string' && eggRequire) {
-    //   requires.push(eggRequire);
-    // }
-    return requires;
+    const requires = this.flags.require ?? [];
+    const imports = this.flags.import ?? [];
+    let eggRequires = this.pkgEgg.require as string[] ?? [];
+    if (typeof eggRequires === 'string') {
+      eggRequires = [ eggRequires ];
+    }
+    let eggImports = this.pkgEgg.import as string[] ?? [];
+    if (typeof eggImports === 'string') {
+      eggImports = [ eggImports ];
+    }
+    return [
+      ...requires,
+      ...imports,
+      ...eggRequires,
+      ...eggImports,
+    ];
   }
 
-  protected async forkNode(modulePath: string, forkArgs: string[], options: ForkOptions = {}) {
-    const { args } = this;
-    if (args.dryRun) {
-      console.log('dry run: $ %o', `${process.execPath} ${modulePath} ${args.join(' ')}`);
-      return;
+  protected formatImportModule(modulePath: string) {
+    if (this.isESM) {
+      return `--import ${pathToFileURL(modulePath).href}`;
     }
+    return `--require ${modulePath}`;
+  }
+
+  protected addNodeOptions(options: string) {
+    if (this.env.NODE_OPTIONS) {
+      if (!this.env.NODE_OPTIONS.includes(options)) {
+        this.env.NODE_OPTIONS = `${this.env.NODE_OPTIONS} ${options}`;
+      }
+    } else {
+      this.env.NODE_OPTIONS = options;
+    }
+  }
+
+  protected async forkNode(modulePath: string, forkArgs: string[], options: ForkNodeOptions = {}) {
+    const env = {
+      ...this.env,
+      ...options.env,
+    };
     const forkExecArgv = [
-      // ...this.ctx.args.execArgv || [],
+      ...this.globalExecArgv,
       ...options.execArgv || [],
     ];
+    const NODE_OPTIONS = env.NODE_OPTIONS ? `NODE_OPTIONS='${env.NODE_OPTIONS}' ` : '';
+    const forkExecArgvString = forkExecArgv.length ? ' ' + forkExecArgv.join(' ') + ' ' : ' ';
+    const forkArgsString = forkArgs.map(a => `'${a}'`).join(' ');
+    const fullCommand = `${NODE_OPTIONS}${process.execPath}${forkExecArgvString}${modulePath} ${forkArgsString}`;
+    if (options.dryRun) {
+      console.log('dry run: $ %s', fullCommand);
+      return;
+    }
 
     options = {
       stdio: 'inherit',
-      env: this.env,
-      cwd: args.base,
+      env,
+      cwd: this.flags.base,
       ...options,
       execArgv: forkExecArgv,
     };
     const proc = fork(modulePath, forkArgs, options);
-    debug('Run fork pid: %o\n\n$ %s%s %s %s\n\n',
+    debug('Run fork pid: %o\n\n$ %s\n\n',
       proc.pid,
-      options.env?.NODE_OPTIONS ? `NODE_OPTIONS='${options.env.NODE_OPTIONS}' ` : '',
-      process.execPath,
-      modulePath, forkArgs.map(a => `'${a}'`).join(' '));
+      fullCommand);
     graceful(proc);
 
     return new Promise<void>((resolve, reject) => {

package/src/commands/cov.ts

@@ -1,30 +1,100 @@
-import { Args, Command, Flags } from '@oclif/core';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { Flags } from '@oclif/core';
+import Test from './test.js';
+import { importResolve } from '@eggjs/utils';
+import { ForkNodeOptions } from '../baseCommand.js';
 
-export default class Cov extends Command {
-  static override args = {
-    file: Args.string({ description: 'file to read' }),
-  };
-
-  static override description = 'describe the command here';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+export default class Cov<T extends typeof Cov> extends Test<T> {
+  static override description = 'Run the test with coverage';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> test/index.test.ts',
   ];
 
   static override flags = {
-    // flag with no value (-f, --force)
-    force: Flags.boolean({ char: 'f' }),
-    // flag with a value (-n, --name=VALUE)
-    name: Flags.string({ char: 'n', description: 'name to print' }),
+    ...Test.flags,
+    // will use on egg-mock https://github.com/eggjs/egg-mock/blob/84a64bd19d0569ec94664c898fb1b28367b95d60/index.js#L7
+    prerequire: Flags.boolean({
+      description: 'prerequire files for coverage instrument',
+    }),
+    exclude: Flags.string({
+      description: 'coverage ignore, one or more files patterns`',
+      multiple: true,
+      char: 'x',
+    }),
+    c8: Flags.string({
+      description: 'c8 instruments passthrough`',
+      default: '--temp-directory node_modules/.c8_output -r text-summary -r json-summary -r json -r lcov -r cobertura',
+    }),
   };
 
-  public async run(): Promise<void> {
-    const { args, flags } = await this.parse(Cov);
+  protected get defaultExcludes() {
+    return [
+      'example/',
+      'examples/',
+      'mocks**/',
+      'docs/',
+      // https://github.com/JaKXz/test-exclude/blob/620a7be412d4fc2070d50f0f63e3228314066fc9/index.js#L73
+      'test/**',
+      'test{,-*}.js',
+      '**/*.test.js',
+      '**/__tests__/**',
+      '**/node_modules/**',
+      'typings',
+      '**/*.d.ts',
+    ];
+  }
+
+  protected override async forkNode(modulePath: string, forkArgs: string[], options: ForkNodeOptions = {}) {
+    const { flags } = this;
+    if (flags.prerequire) {
+      this.env.EGG_BIN_PREREQUIRE = 'true';
+    }
 
-    const name = flags.name ?? 'world';
-    this.log(`hello ${name} from /Users/fengmk2/git/github.com/eggjs/bin/src/commands/cov.ts`);
-    if (args.file && flags.force) {
-      this.log(`you input --force and --file: ${args.file}`);
+    // add c8 args
+    // https://github.com/eggjs/egg/issues/3930
+    const c8Args = [
+      // '--show-process-tree',
+      ...flags.c8.split(' ').filter(a => a.trim()),
+    ];
+    if (flags.typescript) {
+      this.env.SPAWN_WRAP_SHIM_ROOT = path.join(flags.base, 'node_modules');
+      c8Args.push('--extension');
+      c8Args.push('.ts');
     }
+
+    const excludes = new Set([
+      ...process.env.COV_EXCLUDES?.split(',') ?? [],
+      ...this.defaultExcludes,
+      ...Array.from(flags.exclude ?? []),
+    ]);
+    for (const exclude of excludes) {
+      c8Args.push('-x');
+      c8Args.push(exclude);
+    }
+    const c8File = importResolve('c8/bin/c8.js');
+    const outputDir = path.join(flags.base, 'node_modules/.c8_output');
+    await fs.rm(outputDir, { force: true, recursive: true });
+    const coverageDir = path.join(flags.base, 'coverage');
+    await fs.rm(coverageDir, { force: true, recursive: true });
+
+    const execArgv = [
+      ...this.globalExecArgv,
+      ...options.execArgv || [],
+    ];
+    this.globalExecArgv = [];
+
+    // $ c8 node mocha
+    await super.forkNode(c8File, [
+      ...c8Args,
+      process.execPath,
+      ...execArgv,
+      modulePath,
+      ...forkArgs,
+    ]);
   }
 }

package/src/commands/dev.ts

@@ -1,30 +1,99 @@
-import { Args, Command, Flags } from '@oclif/core';
+import { debuglog } from 'node:util';
+import { Flags } from '@oclif/core';
+import { getConfig, getFrameworkPath } from '@eggjs/utils';
+import { detect } from 'detect-port';
+import { getSourceFilename } from '../utils.js';
+import { BaseCommand } from '../baseCommand.js';
 
-export default class Dev extends Command {
-  static override args = {
-    file: Args.string({ description: 'file to read' }),
-  };
+const debug = debuglog('@eggjs/bin/commands/dev');
 
-  static override description = 'describe the command here';
+export default class Dev<T extends typeof Dev> extends BaseCommand<T> {
+  static override description = 'Start server at local dev mode';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
   ];
 
   static override flags = {
-    // flag with no value (-f, --force)
-    force: Flags.boolean({ char: 'f' }),
-    // flag with a value (-n, --name=VALUE)
-    name: Flags.string({ char: 'n', description: 'name to print' }),
+    port: Flags.integer({
+      description: 'listening port, default to 7001',
+      char: 'p',
+    }),
+    workers: Flags.integer({
+      char: 'c',
+      aliases: [ 'cluster' ],
+      description: 'numbers of app workers',
+      default: 1,
+    }),
+    framework: Flags.string({
+      description: 'specify framework that can be absolute path or npm package, default is "egg"',
+    }),
+    sticky: Flags.boolean({
+      description: 'start a sticky cluster server',
+    }),
   };
 
   public async run(): Promise<void> {
-    const { args, flags } = await this.parse(Dev);
+    debug('NODE_ENV: %o', this.env);
+    this.env.NODE_ENV = this.env.NODE_ENV ?? 'development';
+    this.env.EGG_MASTER_CLOSE_TIMEOUT = '1000';
+    const ext = this.isESM ? 'mjs' : 'cjs';
+    const serverBin = getSourceFilename(`../scripts/start-cluster.${ext}`);
+    const eggStartOptions = await this.formatEggStartOptions();
+    const args = [ JSON.stringify(eggStartOptions) ];
+    const requires = await this.formatRequires();
+    const execArgv: string[] = [];
+    for (const r of requires) {
+      const imports = this.formatImportModule(r).split(' ');
+      execArgv.push(...imports);
+    }
+    await this.forkNode(serverBin, args, { execArgv });
+  }
 
-    const name = flags.name ?? 'world';
-    this.log(`hello ${name} from /Users/fengmk2/git/github.com/eggjs/bin/src/commands/dev.ts`);
-    if (args.file && flags.force) {
-      this.log(`you input --force and --file: ${args.file}`);
+  protected async formatEggStartOptions() {
+    const { flags } = this;
+    flags.framework = getFrameworkPath({
+      framework: flags.framework,
+      baseDir: flags.base,
+    });
+
+    if (!flags.port) {
+      let configuredPort: number | undefined;
+      try {
+        const configuration = await getConfig({
+          framework: flags.framework,
+          baseDir: flags.base,
+          env: 'local',
+        });
+        configuredPort = configuration?.cluster?.listen?.port;
+      } catch (err) {
+        /** skip when failing to read the configuration */
+        debug('getConfig error: %s, framework: %o, baseDir: %o, env: local',
+          err, flags.framework, flags.base);
+      }
+      if (configuredPort) {
+        flags.port = configuredPort;
+        debug(`use port ${flags.port} from configuration file`);
+      } else {
+        const defaultPort = parseInt(process.env.EGG_BIN_DEFAULT_PORT ?? '7001');
+        debug('detect available port');
+        flags.port = await detect(defaultPort);
+        if (flags.port !== defaultPort) {
+          console.warn('[@eggjs/bin] server port %o is unavailable, now using port %o',
+            defaultPort, flags.port);
+        }
+        debug(`use available port ${flags.port}`);
+      }
     }
+
+    return {
+      baseDir: flags.base,
+      workers: flags.workers,
+      port: flags.port,
+      framework: flags.framework,
+      typescript: flags.typescript,
+      tscompiler: flags.tscompiler,
+      sticky: flags.sticky,
+    };
   }
 }