@travetto/pack 2.1.3 → 2.2.2

package/README.md

@@ -39,14 +39,14 @@ Assemble is the operation that stages the project's code for deployment.  The as
 
    
    1. Cleaning Workspace - Cleans workspace to start with an empty workspace
-   1. Copying Dependencies - Computes the prod depedencies and copies them into the new workspace
+   1. Copying Dependencies - Computes the prod dependencies and copies them into the new workspace
    1. Copying App Content - Copies over application content (src/resources/support/bin)
    1. Excluding Pre-Compile Files - Any files that should be excluded pre-compilation, are removed
    1. Compiling - Compiles the code in the new workspace, isolating it from your local development
    1. Excluding Post-Compile Files - Removes any files that should be excluded, post compilation
    1. Copying Added Content - Adds in any additional content that is not in the standard locations
    1. Removing Empty Folders - Purge all empty folders, recursively
-   1. Writng Env.js - Write out the .env.js file with computed any env vars that should be set for the deployed app
+   1. Writing Env.js - Write out the .env.js file with computed any env vars that should be set for the deployed app
    1. Remove Source Maps - If keep source is false, all source maps are purged from your app's code
    1. Emptying .ts Files - If keep source is false, all .ts files are emptied, as compilation will not occur at runtime
 
@@ -168,7 +168,7 @@ Various modules may provide customizations to the default `pack.config.ts` to al
 
 **Code: Rest, pack.lambda.ts**
 ```typescript
-import * as fs from 'fs';
+import * as fs from 'fs/promises';
 
 import { PathUtil } from '@travetto/boot';
 import type { AllConfigPartial } from '@travetto/pack';
@@ -186,7 +186,7 @@ export const config: AllConfigPartial = {
     },
     postProcess: [{
       ['Lambda Entrypoint']: cfg =>
-        fs.promises.copyFile(
+        fs.copyFile(
           PathUtil.resolveUnix(__dirname, 'aws-lambda.handler.js'),
           PathUtil.resolveUnix(cfg.workspace, 'index.js')
         )

package/bin/cli-pack.ts

@@ -1,10 +1,10 @@
-import { BasePackPlugin } from './pack-base';
+import { BaseOptions, BasePackPlugin } from './pack-base';
 import { Pack, AllConfig } from './operation/pack';
 
-export class PackPlugin extends BasePackPlugin<AllConfig> {
+export class PackPlugin extends BasePackPlugin<BaseOptions, AllConfig> {
   operation = Pack;
 
-  getOptions() {
+  getOptions(): BaseOptions {
     return this.defaultOptions();
   }
 }

package/bin/cli-pack_assemble.ts

@@ -1,9 +1,17 @@
-import { BasePackPlugin } from './pack-base';
+import { OptionConfig } from '@travetto/cli/src/plugin-base';
+
+import { BaseOptions, BasePackPlugin } from './pack-base';
 import { Assemble, AssembleConfig } from './operation/assemble';
 
-export class PackAssemblePlugin extends BasePackPlugin<AssembleConfig> {
+type Options = BaseOptions & {
+  keepSource: OptionConfig<boolean>;
+  readonly: OptionConfig<boolean>;
+};
+
+export class PackAssemblePlugin extends BasePackPlugin<Options, AssembleConfig> {
   operation = Assemble;
-  getOptions() {
+
+  getOptions(): Options {
     return {
       ...this.defaultOptions(),
       keepSource: this.boolOption({ desc: 'Should source be preserved' }),

package/bin/cli-pack_docker-export.ts

@@ -1,13 +1,21 @@
 import * as fs from 'fs/promises';
 
 import { FsUtil, PathUtil } from '@travetto/boot';
-import { BasePlugin } from '@travetto/cli/src/plugin-base';
+import { BasePlugin, OptionConfig } from '@travetto/cli/src/plugin-base';
 
-export class PackDockerExportPlugin extends BasePlugin {
+type Options = {
+  app: OptionConfig<string>;
+  image: OptionConfig<string>;
+  port: OptionConfig<number>;
+  add: OptionConfig<string[]>;
+  output: OptionConfig<string>;
+};
+
+export class PackDockerExportPlugin extends BasePlugin<Options> {
 
   name = 'pack:docker-export';
 
-  getOptions() {
+  getOptions(): Options {
     return {
       app: this.option({ desc: 'The application target to run', def: 'rest' }),
       image: this.option({ desc: 'Docker image to extend', def: 'node:16-alpine' }),
@@ -17,7 +25,7 @@ export class PackDockerExportPlugin extends BasePlugin {
     };
   }
 
-  async action(...args: unknown[]) {
+  async action(...args: unknown[]): Promise<void> {
     const files = ['src', 'bin', 'support', 'resources', 'package.json', 'package-lock.json', ...this.cmd.add]
       .filter(x => FsUtil.existsSync(PathUtil.resolveUnix(x)));
 

package/bin/cli-pack_docker.ts

@@ -1,10 +1,21 @@
-import { BasePackPlugin } from './pack-base';
+import { OptionConfig } from '@travetto/cli/src/plugin-base';
+
+import { BaseOptions, BasePackPlugin } from './pack-base';
 import { Docker, DockerConfig } from './operation/docker';
 
-export class PackDockerPlugin extends BasePackPlugin<DockerConfig> {
+type Options = BaseOptions & {
+  image: OptionConfig<string>;
+  name: OptionConfig<string>;
+  tag: OptionConfig<string[]>;
+  port: OptionConfig<string[]>;
+  push: OptionConfig<boolean>;
+  registry: OptionConfig<string>;
+};
+
+export class PackDockerPlugin extends BasePackPlugin<Options, DockerConfig> {
   operation = Docker;
 
-  getOptions() {
+  getOptions(): Options {
     return {
       ...this.defaultOptions(),
       image: this.option({ desc: 'Docker Image to extend' }),

package/bin/cli-pack_zip.ts

@@ -1,10 +1,16 @@
-import { BasePackPlugin } from './pack-base';
+import { OptionConfig } from '@travetto/cli/src/plugin-base';
+
+import { BaseOptions, BasePackPlugin } from './pack-base';
 import { Zip, ZipConfig } from './operation/zip';
 
-export class PackZipPlugin extends BasePackPlugin<ZipConfig> {
+type Options = BaseOptions & {
+  output: OptionConfig<string>;
+};
+
+export class PackZipPlugin extends BasePackPlugin<Options, ZipConfig> {
   operation = Zip;
 
-  getOptions() {
+  getOptions(): Options {
     return {
       ...this.defaultOptions(),
       output: this.option({ desc: 'Output File' })

package/bin/lib/assemble.ts

@@ -3,20 +3,20 @@ import { promises as fs } from 'fs';
 
 import { ExecUtil, PathUtil, ScanFs, FsUtil } from '@travetto/boot';
 
-import { DependenciesUtil, DepType } from './depdencies';
+import { DependenciesUtil, DepType } from './dependencies';
 import { PackUtil } from './util';
 
 const MODULE_DIRS = ['src', 'bin', 'support', 'resources', 'index.ts', 'package.json', 'tsconfig.trv.json'];
 
 /**
- * Utils for assmbling
+ * Utils for assembling
  */
 export class AssembleUtil {
 
   /**
    * Minimize cached source files, by removing source mapping info
    */
-  static async cleanCache(cache: string) {
+  static async cleanCache(cache: string): Promise<void> {
     for (const el of await fs.readdir(cache)) {
       if (el.endsWith('.ts')) {
         const content = (await fs.readFile(`${cache}/${el}`, 'utf8')).replace(/\/\/# sourceMap.*/g, '');
@@ -28,10 +28,10 @@ export class AssembleUtil {
   /**
    * Truncate all app source files, and framework source files
    */
-  static async purgeSource(folders: string[]) {
+  static async purgeSource(folders: string[]): Promise<void> {
     for (const sub of folders) {
       for (const f of await ScanFs.scanDir({ testFile: x => x.endsWith('.ts'), testDir: x => true }, sub)) {
-        if (f.stats.isFile() && !f.module.startsWith('cli/')) {
+        if (f.stats?.isFile() && !f.module.startsWith('cli/')) {
           await fs.writeFile(f.file, '');
         }
       }
@@ -41,17 +41,17 @@ export class AssembleUtil {
   /**
    * Copy a module
    */
-  static async copyModule(root: string, target: string) {
+  static async copyModule(root: string, target: string): Promise<void> {
     for (const f of MODULE_DIRS) {
-      const stgt = PathUtil.resolveUnix(root, f);
-      const ftgt = PathUtil.resolveUnix(target, f);
-      const found = await FsUtil.exists(stgt);
+      const sourceFile = PathUtil.resolveUnix(root, f);
+      const targetFile = PathUtil.resolveUnix(target, f);
+      const found = await FsUtil.exists(sourceFile);
       if (found) {
         if (found.isFile()) {
-          await fs.copyFile(stgt, ftgt);
+          await fs.copyFile(sourceFile, targetFile);
         } else {
-          await fs.mkdir(ftgt, { recursive: true });
-          await FsUtil.copyRecursive(`${stgt}/*`, ftgt);
+          await fs.mkdir(targetFile, { recursive: true });
+          await FsUtil.copyRecursive(`${sourceFile}/*`, targetFile);
         }
       }
     }
@@ -60,10 +60,10 @@ export class AssembleUtil {
   /**
    * Purge workspace using file rules
    */
-  static async excludeFiles(root: string, files: string[]) {
+  static async excludeFiles(root: string, files: string[]): Promise<void> {
     const checker = PackUtil.excludeChecker(files, root);
     for (const el of await ScanFs.scanDir({ testDir: x => true, testFile: checker, withHidden: true }, root)) {
-      if (!el.stats.isFile()) { continue; }
+      if (!el.stats || !el.stats.isFile()) { continue; }
       try {
         await fs.unlink(el.file);
       } catch { }
@@ -71,9 +71,9 @@ export class AssembleUtil {
   }
 
   /**
-   * Copy over all prod dependnecies
+   * Copy over all prod dependencies
    */
-  static async copyDependencies(workspace: string, types: DepType[] = ['prod', 'opt', 'optPeer']) {
+  static async copyDependencies(workspace: string, types: DepType[] = ['prod', 'opt', 'optPeer']): Promise<void> {
 
     for (const el of await DependenciesUtil.resolveDependencies({ types })) {
       const sub = PathUtil.normalizeFrameworkPath(el.file, 'node_modules/')
@@ -103,7 +103,7 @@ export class AssembleUtil {
   /**
    * Compile workspace
    */
-  static async buildWorkspace(root: string, cacheDir: string) {
+  static async buildWorkspace(root: string, cacheDir: string): Promise<void> {
     await ExecUtil.spawn('node', ['./node_modules/@travetto/cli/bin/trv.js', 'build'],
       {
         cwd: root, isolatedEnv: true,
@@ -115,7 +115,7 @@ export class AssembleUtil {
   /**
    * Copy over added content
    */
-  static async copyAddedContent(workspace: string, files: Record<string, string>[]) {
+  static async copyAddedContent(workspace: string, files: Record<string, string>[]): Promise<void> {
     for (const a of files) {
       let [src, dest] = Object.entries(a)[0];
       [src, dest] = [PathUtil.resolveUnix(src), PathUtil.resolveUnix(workspace, dest)];

package/bin/lib/{depdencies.ts → dependencies.ts}

@@ -15,6 +15,14 @@ const DEP_MAPPING = {
   optPeer: 'optionalPeerDependencies'
 };
 
+type PackageShape = {
+  name: string;
+} & {
+  [key: string]: {
+    [key: string]: string;
+  };
+};
+
 /**
  * Utilities for processing the package.json dependencies
  */
@@ -25,7 +33,7 @@ export class DependenciesUtil {
    * @param dep
    * @param root
    */
-  static resolveDependencyPackageJson(dep: string, root: string) {
+  static resolveDependencyPackageJson(dep: string, root: string): string {
     const paths = [root, ...(require.resolve.paths(root) || [])];
     let folder: string;
     try {
@@ -52,8 +60,8 @@ export class DependenciesUtil {
     root = PathUtil.cwd,
     types = ['prod'],
     maxDepth = Number.MAX_SAFE_INTEGER
-  }: DepResolveConfig) {
-    const pending = [[root, 0]] as [string, number][];
+  }: DepResolveConfig): Promise<ResolvedDep[]> {
+    const pending: [string, number][] = [[root, 0]];
     const foundSet = new Set<string>();
     const found: ResolvedDep[] = [];
     while (pending.length) {
@@ -61,14 +69,15 @@ export class DependenciesUtil {
       if (depth > maxDepth) { // Ignore if greater than valid max depth
         continue;
       }
-      const p = await import(`${top}/package.json`) as Record<string, Record<string, string>> & { name: string };
-      const deps = [] as (readonly [name: string, type: DepType, version: string])[];
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const p = await import(`${top}/package.json`) as PackageShape;
+      const deps: (readonly [name: string, type: DepType, version: string])[] = [];
       for (const type of types) {
         if (
           type !== 'dev' ||
           maxDepth === 0
         ) {
-          deps.push(...Object.entries(p[DEP_MAPPING[type]] ?? {}).map(([name, version]) => [name, type as DepType, version] as const));
+          deps.push(...Object.entries(p[DEP_MAPPING[type]] ?? {}).map(([name, version]) => [name, type, version] as const));
         }
       }
       for (const [dep, type, version] of deps) {
@@ -80,7 +89,7 @@ export class DependenciesUtil {
             found.push({ file: resolved, type, dep, version });
             pending.push([resolved, depth + 1]);
           }
-        } catch (err) {
+        } catch {
           if (!dep.startsWith('@types') && type !== 'opt' && type !== 'optPeer') {
             console.error('Unable to resolve', { type, dependency: dep });
           }

package/bin/lib/util.ts

@@ -18,23 +18,25 @@ export class PackUtil {
   static #modes: Partial<CommonConfig>[];
 
   static commonExtend<T extends CommonConfig>(a: T, b: Partial<T>): T {
-    return {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const out = {
       active: b.active ?? a.active,
       workspace: b.workspace ?? a.workspace,
       preProcess: [...(b.preProcess ?? []), ...(a.preProcess ?? [])],
       postProcess: [...(b.postProcess ?? []), ...(a.postProcess ?? [])],
-    } as T;
+    } as unknown as T;
+    return out;
   }
 
   /**
    * Find pack modes with associated metadata
    */
-  static async modeList() {
+  static async modeList(): Promise<Partial<CommonConfig>[]> {
     if (!this.#modes) {
       this.#modes = await Promise.all(
         SourceIndex.find({ folder: 'support', filter: f => /\/pack[.].*[.]ts/.test(f) })
           .map(async (x) => {
-            const req = (await import(x.file)).config as Partial<CommonConfig>;
+            const req: Partial<CommonConfig> = (await import(x.file)).config;
             req.file = x.module.replace(/^node_modules\//, '');
             return req;
           })
@@ -47,7 +49,7 @@ export class PackUtil {
   /**
    * Build file include/exclude lists/checker
    */
-  static excludeChecker(files: string[], base: string) {
+  static excludeChecker(files: string[], base: string): (file: string) => boolean {
     const all = files.map(x => {
       const negate = x.startsWith('!') || x.startsWith('^');
       x = negate ? x.substring(1) : x;
@@ -57,7 +59,7 @@ export class PackUtil {
       return [match, negate] as const;
     });
 
-    return (f: string) => {
+    return (f: string): boolean => {
       let exclude = undefined;
       f = PathUtil.resolveUnix(base, f);
       for (const [match, n] of all) {
@@ -75,13 +77,13 @@ export class PackUtil {
   /**
    * Update .env.js with new env data
    */
-  static async writeEnvJs(workspace: string, env: Record<string, string | undefined>) {
+  static async writeEnvJs(workspace: string, env: Record<string, string | undefined>): Promise<void> {
     const out = `${workspace}/.env.js`;
     let src = '';
     if (!!(await FsUtil.exists(out))) {
       src = await fs.readFile(out, 'utf8');
     }
-    const lines = Object.entries(env).map(([k, v]) => v ? `process.env['${k}'] = \`${v!.replace(/`/g, '\\`')}\`;` : '');
+    const lines = Object.entries(env).map(([k, v]) => v ? `process.env['${k}'] = \`${v.replace(/`/g, '\\`')}\`;` : '');
     const content = `${src}\n${lines.join('\n')}`;
     await fs.writeFile(PathUtil.resolveUnix(workspace, '.env.js'), content, { encoding: 'utf8' });
   }
@@ -89,7 +91,7 @@ export class PackUtil {
   /**
    * Delete all empty folders
    */
-  static async removeEmptyFolders(root: string) {
+  static async removeEmptyFolders(root: string): Promise<void> {
     for (const el of await ScanFs.scanDir({ testDir: x => true, testFile: x => false, withHidden: true }, root)) {
       let dir = el.file;
       while ((await fs.readdir(dir)).length === 0) { // empty
@@ -102,14 +104,14 @@ export class PackUtil {
   /**
    * Run operation with logging
    */
-  static async runOperation<T extends CommonConfig>(op: PackOperation<T>, cfg: T, indent = 0) {
+  static async runOperation<T extends CommonConfig>(op: PackOperation<T>, cfg: T, indent = 0): Promise<void> {
     const spacer = ' '.repeat(indent);
     const ctx = await op.context(cfg);
     const title = color`${{ title: op.title }} ${ctx}`;
     const width = Math.max(title.replace(/\x1b\[\d+m/g, '').length, 50); // eslint-disable-line
 
     let i = 0;
-    function stdout(msg?: string) {
+    function stdout(msg?: string): void {
       if (i++ > 0) {
         process.stdout.write(color`${spacer}${{ param: 'done' }}\n`);
       }
@@ -118,7 +120,7 @@ export class PackUtil {
       }
     }
 
-    async function runPhase(phase: 'preProcess' | 'postProcess') {
+    async function runPhase(phase: 'preProcess' | 'postProcess'): Promise<void> {
       for (const el of cfg[phase] ?? []) {
         const [name, fn] = Object.entries(el)[0];
         await stdout(name);

package/bin/operation/assemble.ts

@@ -56,7 +56,7 @@ export const Assemble: PackOperation<AssembleConfig> = {
     yield 'Excluding Post-Compile Files'; await AssembleUtil.excludeFiles(ws, exclude);
     yield 'Copying Added Content'; await AssembleUtil.copyAddedContent(ws, add);
     yield 'Removing Empty Folders'; await PackUtil.removeEmptyFolders(ws);
-    yield 'Writng Env.js'; await PackUtil.writeEnvJs(ws, {
+    yield 'Writing Env.js'; await PackUtil.writeEnvJs(ws, {
       ...env,
       TRV_CACHE: `\${__dirname}/${cacheDir}`,
       ...(readonly ? { TRV_READONLY: '1' } : {})

package/bin/operation/docker.ts

@@ -19,7 +19,7 @@ export interface DockerConfig extends CommonConfig {
   push?: boolean;
 }
 
-const dockerFileBuilder = ({ image, port, app = 'rest', env }: DockerConfig) => `
+const dockerFileBuilder = ({ image, port, app = 'rest', env }: DockerConfig): string => `
 FROM ${image}
 WORKDIR /app
 COPY . .

package/bin/operation/pack.ts

@@ -26,6 +26,8 @@ export type AllConfig = CommonConfig &
 
 export type AllConfigPartial = DeepPartial<AllConfig>;
 
+type DefaultOpType = ['assemble', typeof Assemble];
+
 export const Pack: PackOperation<AllConfig> = {
   key: '',
   title: 'Packing',
@@ -33,23 +35,33 @@ export const Pack: PackOperation<AllConfig> = {
     const ret: Partial<AllConfig> = {
       workspace: b.workspace ?? a.workspace,
     };
-    for (const [k, op] of Object.entries(ops) as ['assemble', typeof Assemble][]) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    for (const [k, op] of (Object.entries(ops) as DefaultOpType[])) {
       ret[k] = op.extend(op.extend(a[k] ?? {}, b[k] ?? {}), op.overrides ?? {});
     }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return ret as AllConfig;
   },
   async context(cfg: AllConfig) {
-    return `[ ${Object.entries(ops).filter(x => cfg[x[0] as 'assemble'].active).map(x => x[0]).join(', ')} ]`;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return `[ ${(Object.entries(ops) as DefaultOpType[])
+      .filter(x => cfg[x[0]].active)
+      .map(x => x[0])
+      .join(', ')} ]`;
   },
   async * exec(cfg: AllConfig) {
-    const steps = Object.entries(ops).filter(x => cfg[x[0] as 'assemble'].active);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const steps = (Object.entries(ops) as DefaultOpType[])
+      .filter(x => cfg[x[0]].active);
+
     if (!steps.length) {
       throw new Error('Pack operation has zero active steps');
     }
-    for (const [step, op] of steps) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    for (const [step, op] of steps as DefaultOpType[]) {
       process.stdout.write('\n');
-      cfg[step as 'assemble'].workspace = cfg.workspace;
-      await PackUtil.runOperation(op as typeof Assemble, cfg[step as 'assemble'], 2);
+      cfg[step].workspace = cfg.workspace;
+      await PackUtil.runOperation(op, cfg[step], 2);
     }
     process.stdout.write('\n');
     yield color`${{ success: 'Successfully' }} packed project`;

package/bin/pack-base.ts

@@ -1,6 +1,6 @@
 import * as os from 'os';
 
-import { BasePlugin } from '@travetto/cli/src/plugin-base';
+import { BasePlugin, OptionConfig } from '@travetto/cli/src/plugin-base';
 import { color } from '@travetto/cli/src/color';
 import { PathUtil, Package, FsUtil } from '@travetto/boot';
 
@@ -12,21 +12,25 @@ const packName = `pack_${Package.name}`
   .replace(/[^a-z]+/g, '_')
   .replace(/_+/g, '_');
 
+export type BaseOptions = {
+  workspace: OptionConfig<string>;
+};
+
 /**
  * Supports packing a project into a directory, ready for archiving
  */
-export abstract class BasePackPlugin<C extends CommonConfig> extends BasePlugin {
+export abstract class BasePackPlugin<V extends BaseOptions, C extends CommonConfig> extends BasePlugin<V> {
 
   /**
    * Package stage name
    */
   abstract get operation(): PackOperation<C>;
 
-  get name() {
+  get name(): string {
     return this.operation.key ? `pack:${this.operation.key}` : 'pack';
   }
 
-  defaultOptions() {
+  defaultOptions(): BaseOptions {
     return { workspace: this.option({ desc: 'Working directory' }) } as const;
   }
 
@@ -41,19 +45,21 @@ export abstract class BasePackPlugin<C extends CommonConfig> extends BasePlugin
       this.showHelp(`Unknown config mode: ${this.args[0]}`);
     }
     const def = list.find(c => c.name === 'default');
-    const out: C = [def, cfg, extra]
+    const out = [def, cfg, extra]
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       .map(x => this.operation.key && this.operation.key in (x ?? {}) ? ((x as Record<string, C>)[this.operation.key] as C) : x as C)
-      .reduce((acc, l) => this.operation.extend(acc, l ?? {}), (this.operation.overrides ?? {}) as C);
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      .reduce<C>((acc, l) => this.operation.extend(acc, l ?? {}), (this.operation.overrides ?? {}) as C);
     out.workspace ??= PathUtil.resolveUnix(os.tmpdir(), packName);
     out.active = true;
     return out;
   }
 
-  getArgs() {
+  getArgs(): string {
     return '[mode]';
   }
 
-  async help() {
+  async help(): Promise<string> {
     const lines = await PackUtil.modeList();
 
     const out = [];
@@ -67,15 +73,15 @@ export abstract class BasePackPlugin<C extends CommonConfig> extends BasePlugin
     return out.join('\n');
   }
 
-  override async complete() {
+  override async complete(): Promise<Record<string, string[]>> {
     return { '': (await PackUtil.modeList()).map(x => x.name!) };
   }
 
-  async action() {
-    const resolved = await this.resolveConfigs();
+  async action(): Promise<void> {
+    const resolved: C = await this.resolveConfigs();
     if (await FsUtil.exists(PathUtil.resolveUnix(resolved.workspace, '.git'))) {
       throw new Error('Refusing to use workspace with a .git directory');
     }
-    return PackUtil.runOperation(this.operation, resolved as C);
+    return PackUtil.runOperation(this.operation, resolved);
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/pack",
   "displayName": "Pack",
-  "version": "2.1.3",
+  "version": "2.2.2",
   "description": "Code packing utilities",
   "keywords": [
     "travetto",
@@ -25,12 +25,12 @@
     "directory": "module/pack"
   },
   "dependencies": {
-    "@travetto/base": "^2.1.3",
+    "@travetto/base": "^2.2.2",
     "@types/picomatch": "^2.3.0",
     "picomatch": "^2.3.1"
   },
   "optionalPeerDependencies": {
-    "@travetto/cli": "^2.1.3"
+    "@travetto/cli": "^2.2.2"
   },
   "docDependencies": {
     "@travetto/rest": true

package/support/pack.config.ts

@@ -1,6 +1,6 @@
 import { AllConfigPartial } from '../bin/operation/pack';
 
-const mod = (f: string) => `node_modules/${f}`;
+const mod = (f: string): string => `node_modules/${f}`;
 
 export const config: AllConfigPartial = {
   name: 'default',