@bitblit/ratchet-node-only 6.0.145-alpha → 6.0.147-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitblit/ratchet-node-only",
-  "version": "6.0.145-alpha",
+  "version": "6.0.147-alpha",
   "description": "Ratchet tools for use on node-only",
   "note-on-side-effects": "Technically the entries in 'bin' below might be side effects, but they are called explicitly",
   "sideEffects": false,
@@ -9,6 +9,7 @@
   },
   "type": "module",
   "files": [
+    "src/**",
     "lib/**",
     "bin/**"
   ],
@@ -58,7 +59,7 @@
     "run-file-server": "node bin/cli.js run-file-server --https true"
   },
   "dependencies": {
-    "@bitblit/ratchet-common": "6.0.145-alpha"
+    "@bitblit/ratchet-common": "6.0.147-alpha"
   },
   "optionalDependencies": {
     "cheerio": "1.1.2",
@@ -69,7 +70,7 @@
     "warc": "1.0.1"
   },
   "peerDependencies": {
-    "@bitblit/ratchet-common": "6.0.145-alpha",
+    "@bitblit/ratchet-common": "6.0.147-alpha",
     "cheerio": "^1.1.2",
     "csv": "^6.4.1",
     "jsonwebtoken": "^9.0.2",

package/src/build/ratchet-node-only-info.ts

@@ -0,0 +1,19 @@
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export class RatchetNodeOnlyInfo {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static buildInformation(): BuildInformation {
+    const val: BuildInformation = {
+      version: 'LOCAL-SNAPSHOT',
+      hash: 'LOCAL-HASH',
+      branch: 'LOCAL-BRANCH',
+      tag: 'LOCAL-TAG',
+      timeBuiltISO: 'LOCAL-TIME-ISO',
+      notes: 'LOCAL-NOTES',
+    };
+    return val;
+  }
+}

package/src/ci/apply-ci-env-variables-to-files.spec.ts

@@ -0,0 +1,30 @@
+import { ApplyCiEnvVariablesToFiles } from './apply-ci-env-variables-to-files.js';
+import { CiRunInformationUtil } from './ci-run-information-util.js';
+import { describe, expect, test } from 'vitest';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { GlobalRatchet } from '@bitblit/ratchet-common/lang/global-ratchet';
+
+describe('#applyCiEnvVariablesToFiles', function () {
+  test.skip('should fail if not in a ci environment', async () => {
+    try {
+      const _result: number = await ApplyCiEnvVariablesToFiles.process(
+        ['test1.txt'],
+        CiRunInformationUtil.createDefaultCircleCiRunInformation(),
+      );
+      this.bail();
+    } catch (err) {
+      Logger.debug('Caught expected error : %s', err['message']);
+      // Expected, return ok
+    }
+  });
+
+  test('should not fail if in a ci environment', async () => {
+    GlobalRatchet.setGlobalEnvVar('CIRCLE_BUILD_NUM', '1');
+    GlobalRatchet.setGlobalEnvVar('CIRCLE_BRANCH', 'B');
+    GlobalRatchet.setGlobalEnvVar('CIRCLE_TAG', 'T');
+    GlobalRatchet.setGlobalEnvVar('CIRCLE_SHA1', 'S');
+
+    const result: number = await ApplyCiEnvVariablesToFiles.process([], CiRunInformationUtil.createDefaultCircleCiRunInformation());
+    expect(result).toEqual(0);
+  });
+});

package/src/ci/apply-ci-env-variables-to-files.ts

@@ -0,0 +1,98 @@
+import fs from 'fs';
+import { CiRunInformation } from './ci-run-information.js';
+import { CiRunInformationUtil } from './ci-run-information-util.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class ApplyCiEnvVariablesToFiles {
+  public static async process(
+    fileNames: string[],
+    cfg: CiRunInformation,
+    buildFinder = 'LOCAL-SNAPSHOT',
+    branchFinder = 'LOCAL-BRANCH',
+    hashFinder = 'LOCAL-HASH',
+    tagFinder = 'LOCAL-TAG',
+    timeFinder = 'LOCAL-TIME',
+  ): Promise<number> {
+    RequireRatchet.notNullOrUndefined(cfg, 'cfg');
+    RequireRatchet.notNullOrUndefined(cfg.buildNumber, 'cfg.buildNumber');
+    RequireRatchet.notNullOrUndefined(cfg.localTime, 'cfg.localTime');
+    if (!fileNames) {
+      throw new Error('fileNames must be defined');
+    }
+    if (fileNames.length === 0) {
+      Logger.warn('Warning - no files supplied to process');
+    }
+    if (!cfg.buildNumber) {
+      ErrorRatchet.throwFormattedErr('%s env var not set - apparently not in a CI environment', cfg.buildNumber);
+    }
+
+    Logger.info('Processing files %j with run info %j', cfg);
+
+    let foundCount = 0;
+    fileNames.forEach((f) => {
+      if (!fs.existsSync(f)) {
+        Logger.error('Could not find file %s to process, continuing', f);
+      } else {
+        try {
+          let contents: string = fs.readFileSync(f).toString();
+          contents = contents.split(buildFinder).join(cfg.buildNumber);
+          contents = contents.split(branchFinder).join(cfg.branch || '');
+          contents = contents.split(hashFinder).join(cfg.commitHash || '');
+          contents = contents.split(tagFinder).join(cfg.tag || '');
+          contents = contents.split(timeFinder).join(cfg.localTime || '');
+          fs.writeFileSync(f, contents);
+          foundCount++;
+        } catch (err) {
+          Logger.error('Error processing %s , continuing: %s', f, err, err);
+        }
+      }
+    });
+
+    return foundCount;
+  }
+
+  public static extractFileNames(): string[] {
+    let rval: string[] = [];
+    if (process && process.argv && process.argv.length > 3) {
+      rval = process.argv.slice(3);
+    }
+    return rval;
+  }
+
+  public static extractVariableConfig(inName: string): CiRunInformation {
+    let rval: CiRunInformation = null;
+    const name: string = StringRatchet.trimToEmpty(inName).toLowerCase();
+    switch (name) {
+      case 'circleci':
+        rval = CiRunInformationUtil.createDefaultCircleCiRunInformation();
+        break;
+      case 'github':
+        rval = CiRunInformationUtil.createDefaultGithubActionsRunInformation();
+        break;
+      case 'test':
+        rval = CiRunInformationUtil.createTestingCiRunInformation();
+        break;
+      default:
+        ErrorRatchet.throwFormattedErr('Unrecognized env var config type : %s', name);
+    }
+    Logger.info('Using variable config : %j', rval);
+
+    return rval;
+  }
+
+  /**
+   And, in case you are running this command line...
+   TODO: should use switches to allow setting the various non-filename params
+   **/
+  public static async runFromCliArgs(args: string[]): Promise<number> {
+    if (args.length > 1) {
+      return ApplyCiEnvVariablesToFiles.process(args.slice(1), ApplyCiEnvVariablesToFiles.extractVariableConfig(args[0]));
+    } else {
+      Logger.infoP('Usage : apply-ci-env-variables-to-files {file1} {file2} ...');
+      return -1;
+    }
+  }
+}

package/src/ci/ci-run-information-util.ts

@@ -0,0 +1,48 @@
+import { DateTime } from 'luxon';
+import { CiRunInformation } from './ci-run-information.js';
+import { GlobalRatchet } from '@bitblit/ratchet-common/lang/global-ratchet';
+
+export class CiRunInformationUtil {
+  public static readonly DEFAULT_TIME_FORMAT: string = 'yyyy-MM-dd HH:mm:ss a z';
+  public static readonly DEFAULT_TIME_ZONE: string = 'America/Los_Angeles';
+
+  public static createTestingCiRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE): CiRunInformation {
+    const now: string = new Date().toISOString();
+    const rval: CiRunInformation = {
+      buildNumber: 'Test_buildNumberVar_' + now,
+      localTime: DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+      branch: 'Test_branchVar_' + now,
+      tag: 'Test_tagVar_' + now,
+      commitHash: 'Test_hashVar_' + now,
+      userName: 'Test_userNameVar_' + now,
+      projectName: 'Test_projectNameVar_' + now,
+    };
+    return rval;
+  }
+
+  public static createDefaultCircleCiRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE): CiRunInformation {
+    const rval: CiRunInformation = {
+      buildNumber: GlobalRatchet.fetchGlobalEnvVar('CIRCLE_BUILD_NUM'),
+      branch: GlobalRatchet.fetchGlobalEnvVar('CIRCLE_BRANCH'),
+      tag: GlobalRatchet.fetchGlobalEnvVar('CIRCLE_TAG'),
+      commitHash: GlobalRatchet.fetchGlobalEnvVar('CIRCLE_SHA1'),
+      localTime: DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+      userName: GlobalRatchet.fetchGlobalEnvVar('CIRCLE_USERNAME'),
+      projectName: GlobalRatchet.fetchGlobalEnvVar('CIRCLE_PROJECT_REPONAME'),
+    };
+    return rval;
+  }
+
+  public static createDefaultGithubActionsRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE): CiRunInformation {
+    const rval: CiRunInformation = {
+      buildNumber: GlobalRatchet.fetchGlobalEnvVar('GITHUB_RUN_NUMBER'),
+      branch: GlobalRatchet.fetchGlobalEnvVar('GITHUB_REF_NAME'),
+      tag: GlobalRatchet.fetchGlobalEnvVar('GITHUB_REF_NAME'),
+      commitHash: GlobalRatchet.fetchGlobalEnvVar('GITHUB_SHA'),
+      localTime: DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+      userName: GlobalRatchet.fetchGlobalEnvVar('GITHUB_ACTOR'),
+      projectName: GlobalRatchet.fetchGlobalEnvVar('GITHUB_REPOSITORY'),
+    };
+    return rval;
+  }
+}

package/src/ci/ci-run-information.ts

@@ -0,0 +1,9 @@
+export interface CiRunInformation {
+  buildNumber: string; // You MUST set this one
+  localTime: string; // And this one
+  branch?: string;
+  tag?: string;
+  commitHash?: string;
+  userName?: string;
+  projectName?: string;
+}

package/src/cli/abstract-ratchet-cli-handler.ts

@@ -0,0 +1,33 @@
+import { CliRatchet } from './cli-ratchet.js';
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export abstract class AbstractRatchetCliHandler {
+  abstract fetchHandlerMap(): Record<string, any>;
+  abstract fetchVersionInfo(): BuildInformation;
+
+  public async findAndExecuteHandler(useSubstringMatch: boolean = false): Promise<void> {
+    let handler: any = null;
+    const versionArgs: string[] = CliRatchet.argsAfterCommand(['version'], useSubstringMatch);
+    if (versionArgs) {
+      console.log('Version : ' + JSON.stringify(this.fetchVersionInfo()));
+      console.log('Process: ' + JSON.stringify(process?.argv) + ' VersionArgs: ' + JSON.stringify(versionArgs));
+    } else {
+      const handlerMap: Record<string, any> = this.fetchHandlerMap();
+      const keys: string[] = Object.keys(handlerMap);
+      let remainArgs: string[] = null;
+      for (let i = 0; i < keys.length && !handler; i++) {
+        remainArgs = CliRatchet.argsAfterCommand([keys[i], keys[i] + '.js']);
+        if (remainArgs) {
+          handler = handlerMap[keys[i]];
+        }
+      }
+      if (handler) {
+        console.debug('Running command with args ' + JSON.stringify(remainArgs));
+        await handler(remainArgs);
+      } else {
+        console.log('Unrecognized command : ', process.argv);
+        console.log('Valid commands are : ', Object.keys(handlerMap));
+      }
+    }
+  }
+}

package/src/cli/cli-ratchet.ts

@@ -0,0 +1,34 @@
+export class CliRatchet {
+  public static isCalledFromCLI(filenames: string[], useSubstringMatch: boolean = false): boolean {
+    let rval: boolean = false;
+    for (let i = 0; filenames && i < filenames.length && !rval; i++) {
+      rval = CliRatchet.indexOfCommandArgument(filenames[i], useSubstringMatch) !== null;
+    }
+    return rval;
+  }
+
+  public static argsAfterCommand(filenames: string[], useSubstringMatch: boolean = false): string[] {
+    let rval: string[] = null;
+    if (process?.argv?.length && filenames?.length) {
+      let idx: number = null;
+      for (let i = 0; i < filenames.length && idx === null; i++) {
+        idx = CliRatchet.indexOfCommandArgument(filenames[i], useSubstringMatch);
+      }
+      rval = idx !== null ? process.argv.slice(idx + 1, process.argv.length) : null;
+    }
+
+    return rval;
+  }
+
+  public static isCalledFromCLISingle(filename: string, useSubstringMatch: boolean = false): boolean {
+    return CliRatchet.isCalledFromCLI([filename], useSubstringMatch);
+  }
+
+  public static indexOfCommandArgument(filename: string, useSubstringMatch: boolean = false): number {
+    const contFileName: boolean[] = process.argv.map(
+      (arg) => (!useSubstringMatch && arg === filename) || (useSubstringMatch && arg.indexOf(filename) !== -1),
+    );
+    const idx: number = contFileName.indexOf(true);
+    return idx === -1 ? null : idx;
+  }
+}

package/src/cli/ratchet-cli-handler.ts

@@ -0,0 +1,24 @@
+import { RatchetNodeOnlyInfo } from '../build/ratchet-node-only-info.js';
+import { ApplyCiEnvVariablesToFiles } from '../ci/apply-ci-env-variables-to-files.js';
+import { FilesToStaticClass } from '../files/files-to-static-class.js';
+import { PublishCiReleaseToSlack } from '../third-party/slack/publish-ci-release-to-slack.js';
+import { AbstractRatchetCliHandler } from './abstract-ratchet-cli-handler.js';
+import { UniqueFileRename } from '../files/unique-file-rename.js';
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+import { LocalFileServer } from '../http/local-file-server.js';
+
+export class RatchetCliHandler extends AbstractRatchetCliHandler {
+  fetchHandlerMap(): Record<string, any> {
+    return {
+      'apply-ci-env-variables-to-files': ApplyCiEnvVariablesToFiles.runFromCliArgs,
+      'files-to-static-class': FilesToStaticClass.runFromCliArgs,
+      'publish-ci-release-to-slack': PublishCiReleaseToSlack.runFromCliArgs,
+      'unique-file-rename': UniqueFileRename.runFromCliArgs,
+      'run-file-server': LocalFileServer.runLocalFileServerFromCliArgs,
+    };
+  }
+
+  fetchVersionInfo(): BuildInformation {
+    return RatchetNodeOnlyInfo.buildInformation();
+  }
+}

package/src/csv/csv-ratchet.spec.ts

@@ -0,0 +1,59 @@
+import { Subject } from 'rxjs';
+import { CsvRatchet } from './csv-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { StringWritable } from '../stream/string-writable.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#streamObjectsToCsv', function () {
+  test('should parse a string', async () => {
+    const testString: string = 'a,b\n1,2\n3,4\n';
+    const out: TestItem[] = await CsvRatchet.stringParse<TestItem>(testString, CsvRatchet.defaultParseFunction<TestItem>);
+
+    expect(out).toBeTruthy();
+    expect(out.length).toEqual(2);
+    // Need a real parse function to make this a number, and I am not testing that part here
+    expect(out[0].a).toEqual('1');
+    expect(out[1].a).toEqual('3');
+  });
+
+  test('should generate csv data', async () => {
+    const output: TestItem[] = [
+      { a: 1, b: '2' },
+      { a: 3, b: '4' },
+    ];
+    const testString: string = await CsvRatchet.generateCsvData(output);
+
+    expect(testString).toBeTruthy();
+    expect(testString.length).toBeGreaterThan(10);
+  });
+
+  test('should stream objects to a csv', async () => {
+    // Logger.setLevel(LoggerLevelName.debug);
+    const sub: Subject<TestItem> = new Subject<TestItem>();
+    const out: StringWritable = new StringWritable();
+
+    const prom: Promise<number> = CsvRatchet.streamObjectsToCsv<TestItem>(sub, out); //, opts);
+
+    for (let i = 1; i < 6; i++) {
+      Logger.debug('Proc : %d', i);
+      sub.next({ a: i, b: 'test ' + i + ' ,,' });
+      await PromiseRatchet.wait(10);
+    }
+    sub.complete();
+
+    Logger.debug('Waiting on write');
+
+    const result: number = await prom;
+    Logger.debug('Write complete');
+    const val: string = out.value;
+
+    expect(result).toEqual(5);
+    Logger.debug('Have res : %d and val : \n%s', result, val);
+  });
+});
+
+export interface TestItem {
+  a: number;
+  b: string;
+}

package/src/csv/csv-ratchet.ts

@@ -0,0 +1,211 @@
+/*
+    Functions for working with csv data
+*/
+
+import fs, { ReadStream } from 'fs';
+import { Options as ParseOptions, parse } from 'csv-parse';
+import { Options, stringify } from 'csv-stringify';
+import { Subject, Subscription } from 'rxjs';
+import { Readable, Writable } from 'stream';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { MapRatchet } from '@bitblit/ratchet-common/lang/map-ratchet';
+
+export class CsvRatchet {
+  public static defaultParseOptions(): ParseOptions {
+    const rval: ParseOptions = {
+      delimiter: ',',
+      columns: true,
+    };
+    return rval;
+  }
+
+  public static defaultStringifyOptions(): Options {
+    const rval: Options = {
+      header: true,
+    };
+    return rval;
+  }
+
+  public static async stringParse<T>(
+    input: string,
+    pf: ParseFunction<T>,
+    opts: ParseOptions = CsvRatchet.defaultParseOptions(),
+  ): Promise<T[]> {
+    return CsvRatchet.streamParse<T>(Readable.from(input), pf, opts);
+  }
+
+  public static async streamParse<T>(
+    readStream: Readable,
+    pf: ParseFunction<T>,
+    opts: ParseOptions = CsvRatchet.defaultParseOptions(),
+  ): Promise<T[]> {
+    return new Promise((res, rej) => {
+      const rval: T[] = [];
+      const p = parse(opts);
+
+      p.on('readable', () => {
+        let record: any = p.read();
+        while (record) {
+          const newVal: T = pf(record);
+          if (newVal) {
+            rval.push(newVal);
+          } else {
+            // Logger.debug('Stripping %j', record);
+          }
+          record = p.read();
+        }
+      });
+
+      p.on('error', (err) => {
+        rej(err);
+      });
+
+      p.on('end', () => {
+        res(rval);
+      });
+
+      readStream.pipe(p);
+    });
+  }
+
+  public static async fileParse<T>(filename: string, pf: ParseFunction<T>): Promise<T[]> {
+    const readStream: ReadStream = fs.createReadStream(filename);
+    return CsvRatchet.streamParse<T>(readStream, pf);
+  }
+
+  public static async generateCsvData(objectsToConvert: any[], opts: Options = CsvRatchet.defaultStringifyOptions()): Promise<string> {
+    Logger.silly('Converting %d items into csv file', objectsToConvert.length);
+    const genProm: Promise<string> = new Promise<string>((res, rej) => {
+      stringify(objectsToConvert, opts, function (err, data) {
+        if (err) {
+          rej(err);
+        } else {
+          res(data);
+        }
+      });
+    });
+    return genProm;
+  }
+
+  public static async generateComparison(file1: string, file2: string, keyField: string): Promise<ComparisonResults> {
+    RequireRatchet.notNullOrUndefined(file1, 'file1');
+    RequireRatchet.notNullOrUndefined(file2, 'file2');
+    RequireRatchet.notNullOrUndefined(keyField, 'keyField');
+
+    Logger.info('Created csv compare with files %s and %s keyed on %s', file1, file2, keyField);
+    //const file1Raw: string = fs.readFileSync(file1).toString();
+    let file1Parsed: any[] = await this.streamParse(fs.createReadStream(file1), CsvRatchet.defaultParseFunction);
+    file1Parsed = file1Parsed.map((m) => {
+      const next: any = {};
+      Object.keys(m).forEach((k) => {
+        next[k.trim()] = m[k];
+      });
+      return next;
+    });
+    const file1Mapped: Map<string, any> = MapRatchet.mapByUniqueProperty<any, string>(file1Parsed, keyField);
+    //const file2Raw: string = fs.readFileSync(file2).toString();
+
+    let file2Parsed: any[] = await this.streamParse(fs.createReadStream(file2), CsvRatchet.defaultParseFunction);
+    /*
+    let file2Parsed: any[] = parsesync(file2Raw, {
+      columns: true,
+      skip_empty_lines: true,
+    });
+
+     */
+    file2Parsed = file2Parsed.map((m) => {
+      const next: any = {};
+      Object.keys(m).forEach((k) => {
+        next[k.trim()] = m[k];
+      });
+      return next;
+    });
+    const file2Mapped: Map<string, any> = MapRatchet.mapByUniqueProperty<any, string>(file2Parsed, keyField);
+
+    const f1Only: string[] = [];
+    const f2Only: string[] = [];
+    const both: string[] = [];
+
+    Array.from(file1Mapped.keys()).forEach((f1k) => {
+      if (file2Mapped.has(f1k)) {
+        both.push(f1k);
+      } else {
+        f1Only.push(f1k);
+      }
+    });
+
+    Array.from(file2Mapped.keys()).forEach((f1k) => {
+      if (!file1Mapped.has(f1k)) {
+        f2Only.push(f1k);
+      }
+    });
+
+    const rval: ComparisonResults = {
+      file1Data: file1Mapped,
+      file2Data: file2Mapped,
+      file1OnlyKeys: f1Only,
+      file2OnlyKeys: f2Only,
+      bothFilesKeys: both,
+    };
+
+    return rval;
+  }
+
+  public static async streamObjectsToCsv<T>(srcSubject: Subject<T>, output: Writable, inOpts?: Options): Promise<number> {
+    RequireRatchet.notNullOrUndefined(srcSubject, 'srcSubject');
+    RequireRatchet.notNullOrUndefined(output, 'output');
+    const opts: Options = inOpts || CsvRatchet.defaultStringifyOptions();
+
+    Logger.silly('Running pipe to csv output : %j', opts);
+    let count: number = 0;
+    const genProm: Promise<number> = new Promise<number>((res, rej) => {
+      const stringifier = stringify(opts);
+      stringifier.on('error', (err) => {
+        if (sub) {
+          sub.unsubscribe();
+        }
+        rej(err);
+      });
+      stringifier.on('finish', () => {
+        if (sub) {
+          sub.unsubscribe(); // Cleanup
+        }
+        res(count);
+      });
+      stringifier.pipe(output);
+
+      const sub: Subscription = srcSubject.subscribe(
+        (next) => {
+          Logger.debug('Adding %j to csv', next);
+          count++;
+          stringifier.write(next);
+        },
+        (err) => {
+          Logger.error('Error generating : %s', err);
+          rej(err);
+        },
+        () => {
+          Logger.debug('Finished');
+          stringifier.end();
+        },
+      );
+    });
+    return genProm;
+  }
+
+  public static defaultParseFunction<T>(row: any): T {
+    return row as T;
+  }
+}
+
+type ParseFunction<T> = (row: any) => T;
+
+export interface ComparisonResults {
+  file1OnlyKeys: string[];
+  file2OnlyKeys: string[];
+  bothFilesKeys: string[];
+
+  file1Data: Map<string, any>;
+  file2Data: Map<string, any>;
+}

package/src/export-builder/export-map-builder-config.ts

@@ -0,0 +1,10 @@
+import { ExportMapBuilderTargetConfig } from './export-map-builder-target-config.js';
+
+export interface ExportMapBuilderConfig {
+  sourceRoot?: string; // Folder, by default the folder src in the same folder as targetPackageJsonFile
+  targets?: ExportMapBuilderTargetConfig[]; // Defaults to using folder lib, .js for imports, .d.ts for types
+  includes?: RegExp[]; // If file, added, if folder, recursively descended.  Locations mapped from sourceRoot, defaults to .* if not set
+  excludes?: RegExp[]; // Any file/folder matching isn't processed.  Defaults to empty
+  targetPackageJsonFile?: string; // defaults to package.json at root
+  dryRun?: boolean;
+}

package/src/export-builder/export-map-builder-target-config.ts

@@ -0,0 +1,5 @@
+export interface ExportMapBuilderTargetConfig {
+  type: string;
+  prefix: string;
+  suffix: string;
+}

package/src/export-builder/export-map-builder.spec.ts

@@ -0,0 +1,22 @@
+import path from 'path';
+//import { fileURLToPath, URL } from 'url';
+//import { Logger } from '../../common/logger';
+import { describe, expect, test } from 'vitest';
+import { ExportMapBuilder } from './export-map-builder.js';
+import { ExportMapBuilderConfig } from './export-map-builder-config.js';
+import { EsmRatchet } from '@bitblit/ratchet-common/lang/esm-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+const testDirname: string = path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../common');
+
+describe('#exportMapBuilder', function () {
+  test('should build an export map', async () => {
+    const cfg: ExportMapBuilderConfig = {
+      targetPackageJsonFile: path.join(testDirname, 'package.json'),
+      dryRun: true,
+    };
+    const output: Record<string, any> = ExportMapBuilder.process(cfg);
+    expect(output).not.toBeNull;
+    Logger.info('Output: %j', output);
+  });
+});