fix: internal module imports

src/Array.ts

@@ -1,4 +1,4 @@
-import { doesExist, isNone, Maybe } from './Maybe';
+import { doesExist, isNone, Maybe } from './Maybe.js';
 
 /**
  * Merge arguments, which may or may not be arrays, into one return that is definitely an array.

src/ArrayMapper.ts

@@ -1,4 +1,4 @@
-import { setOrPush } from './Map';
+import { setOrPush } from './Map.js';
 
 export interface ArrayMapperOptions {
   /**

src/Async.ts

@@ -1,5 +1,5 @@
-import { TimeoutError } from './error/TimeoutError';
-import { PredicateC0 } from './Predicate';
+import { TimeoutError } from './error/TimeoutError.js';
+import { PredicateC0 } from './Predicate.js';
 
 /**
  * Resolve after a set amount of time.

src/Buffer.ts

@@ -1,4 +1,4 @@
-import { sum } from './Math';
+import { sum } from './Math.js';
 
 export type AllowedBufferEncoding = 'ascii' | 'utf-8';
 

src/Child.ts

@@ -2,10 +2,10 @@ import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 import { BaseError } from 'noicejs';
 import { Writable } from 'stream';
 
-import { encode } from './Buffer';
-import { ChildProcessError } from './error/ChildProcessError';
-import { NameValuePair } from './Map';
-import { doesExist, Maybe } from './Maybe';
+import { encode } from './Buffer.js';
+import { ChildProcessError } from './error/ChildProcessError.js';
+import { NameValuePair } from './Map.js';
+import { doesExist, Maybe } from './Maybe.js';
 
 export interface ChildProcessOptions {
   cwd: string;

src/Logger.ts

@@ -1,5 +1,6 @@
 import { ConsoleLogger, Logger, NullLogger } from 'noicejs';
-import { isDebug } from './Env';
+
+import { isDebug } from './Env.js';
 
 /**
  * Get a test logger. Returns a null logger unless `verbose` is true or run under debug mode.

src/Map.ts

@@ -1,6 +1,6 @@
-import { mergeArrays, toArray } from './Array';
-import { NotFoundError } from './error/NotFoundError';
-import { doesExist, isNone, Maybe, mustExist } from './Maybe';
+import { mergeArrays, toArray } from './Array.js';
+import { NotFoundError } from './error/NotFoundError.js';
+import { doesExist, isNone, Maybe, mustExist } from './Maybe.js';
 
 export interface Dict<TVal> {
   [key: string]: TVal;

src/Maybe.ts

@@ -1,5 +1,5 @@
-import { NotFoundError } from './error/NotFoundError';
-import { PredicateC1 } from './Predicate';
+import { NotFoundError } from './error/NotFoundError.js';
+import { PredicateC1 } from './Predicate.js';
 
 /**
  * Unset value.

src/Optional.ts

@@ -1,5 +1,5 @@
 // deprecated alternative names for Maybe
-import { isNone, Maybe, None } from '.';
+import { isNone, Maybe, None } from './Maybe.js';
 
 
 /**

src/Reflect.ts

@@ -1,5 +1,5 @@
-import { InvalidArgumentError } from './error/InvalidArgumentError';
-import { doesExist, isNone } from './Maybe';
+import { InvalidArgumentError } from './error/InvalidArgumentError.js';
+import { doesExist, isNone } from './Maybe.js';
 
 /* eslint-disable-next-line @typescript-eslint/ban-types */
 type Reflectable = object;

src/app.ts

@@ -1,4 +1,4 @@
-import { VERSION_INFO } from './version';
+import { VERSION_INFO } from './version.js';
 
 export async function main(argv: Array<string>): Promise<number> {
   /* eslint-disable-next-line no-console */

src/error/MissingKeyError.ts

@@ -1,4 +1,4 @@
-import { NotFoundError } from './NotFoundError';
+import { NotFoundError } from './NotFoundError.js';
 
 /**
  * Error indicating that a required key did not exist in a map-like.

src/index.ts

@@ -1,9 +1,9 @@
-export { ChildProcessError } from './error/ChildProcessError';
-export { InvalidArgumentError } from './error/InvalidArgumentError';
-export { MissingKeyError } from './error/MissingKeyError';
-export { NotFoundError } from './error/NotFoundError';
-export { NotImplementedError } from './error/NotImplementedError';
-export { TimeoutError } from './error/TimeoutError';
+export { ChildProcessError } from './error/ChildProcessError.js';
+export { InvalidArgumentError } from './error/InvalidArgumentError.js';
+export { MissingKeyError } from './error/MissingKeyError.js';
+export { NotFoundError } from './error/NotFoundError.js';
+export { NotImplementedError } from './error/NotImplementedError.js';
+export { TimeoutError } from './error/TimeoutError.js';
 
 export {
   mergeArray,
@@ -15,28 +15,28 @@ export {
   filterZip,
   lengthOf,
   toArray,
-} from './Array';
+} from './Array.js';
 export {
   ArrayMapper,
   ArrayMapperOptions,
-} from './ArrayMapper';
+} from './ArrayMapper.js';
 export {
   defer,
   deferUntil,
   deferValue,
   timeout,
   waitFor,
-} from './Async';
+} from './Async.js';
 export {
   AllowedBufferEncoding,
   concat,
   encode,
-} from './Buffer';
+} from './Buffer.js';
 export {
   Checklist,
   ChecklistMode,
   ChecklistOptions,
-} from './Checklist';
+} from './Checklist.js';
 export {
   ChildOptions,
   ChildResult,
@@ -45,14 +45,14 @@ export {
   waitForChild,
   writeInput,
   writeValue,
-} from './Child';
+} from './Child.js';
 export {
   isDebug
-} from './Env';
+} from './Env.js';
 export {
   getTestLogger,
   spyLogger,
-} from './Logger';
+} from './Logger.js';
 export {
   Dict,
   MapLike,
@@ -68,10 +68,10 @@ export {
   pairsToMap,
   pushMergeMap,
   setOrPush,
-} from './Map';
+} from './Map.js';
 export {
   sum,
-} from './Math';
+} from './Math.js';
 export {
   Maybe,
   None,
@@ -84,24 +84,24 @@ export {
   mustExist,
   mustFind,
   removeNone,
-} from './Maybe';
+} from './Maybe.js';
 export {
   Nil,
   Optional,
   isNil,
-} from './Optional';
+} from './Optional.js';
 export {
   constructorName,
   getConstructor,
   getMethods,
-} from './Reflect';
+} from './Reflect.js';
 export {
   SIGNAL_RELOAD,
   SIGNAL_RESET,
   SIGNAL_STOP,
   signal,
-} from './Signal';
+} from './Signal.js';
 export {
   leftPad,
   trim,
-} from './String';
+} from './String.js';

test/TestApp.ts

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import sinon from 'sinon';
 
-import { main } from '../src/app';
+import { main } from '../src/app.js';
 
 const { spy } = sinon;
 

test/TestLogger.ts

@@ -1,23 +1,23 @@
 import { expect } from 'chai';
 import { ConsoleLogger, NullLogger } from 'noicejs';
 
-import { getTestLogger, spyLogger } from '../src/Logger';
+import { getTestLogger, spyLogger } from '../src/Logger.js';
 
 describe('logger utils', () => {
   describe('get test logger helper', () => {
-    it('should return console logger in verbose mode', () => {
+    it('should return console logger in verbose mode', async () => {
       expect(getTestLogger(true)).to.equal(ConsoleLogger.global);
     });
 
     it('should return console logger in debug mode');
 
-    it('should return null logger otherwise', () => {
+    it('should return null logger otherwise', async () => {
       expect(getTestLogger()).to.equal(NullLogger.global);
     });
   });
 
   describe('spy logger helper', () => {
-    it('should return itself as a child', () => {
+    it('should return itself as a child', async () => {
       const logger = spyLogger({});
       expect(logger.child({})).to.equal(logger);
     });

test/error/TestError.ts

@@ -1,11 +1,11 @@
 import { expect } from 'chai';
 
-import { ChildProcessError } from '../../../js-utils/src/error/ChildProcessError';
-import { InvalidArgumentError } from '../../../js-utils/src/error/InvalidArgumentError';
-import { MissingKeyError } from '../../../js-utils/src/error/MissingKeyError';
-import { NotFoundError } from '../../src/error/NotFoundError';
-import { NotImplementedError } from '../../../js-utils/src/error/NotImplementedError';
-import { TimeoutError } from '../../../js-utils/src/error/TimeoutError';
+import { ChildProcessError } from '../../src/error/ChildProcessError.js';
+import { InvalidArgumentError } from '../../src/error/InvalidArgumentError.js';
+import { MissingKeyError } from '../../src/error/MissingKeyError.js';
+import { NotFoundError } from '../../src/error/NotFoundError.js';
+import { NotImplementedError } from '../../src/error/NotImplementedError.js';
+import { TimeoutError } from '../../src/error/TimeoutError.js';
 
 const errors = [
   ChildProcessError,
@@ -19,18 +19,18 @@ const errors = [
 describe('errors', () => {
   for (const errorType of errors) {
     describe(errorType.name, () => {
-      it('should have a message', () => {
+      it('should have a message', async () => {
         const err = new errorType();
         expect(err.message).to.not.equal('');
       });
 
-      it('should include nested errors in the stack trace', () => {
+      it('should include nested errors in the stack trace', async () => {
         const inner = new Error('inner error');
         const err = new errorType('outer error', inner);
         expect(err.stack).to.include('inner', 'inner error message').and.include('outer', 'outer error message');
       });
 
-      it('should have the nested error', () => {
+      it('should have the nested error', async () => {
         const inner = new Error('inner error');
         const err = new errorType('outer error', inner);
         expect(err.cause()).to.equal(inner);

test/utils/TestArray.ts

@@ -4,9 +4,9 @@ import { array, falsy, integer } from 'fast-check';
 import { over } from 'mocha-foam';
 import sinon from 'sinon';
 
-import { isNone } from '../../src';
-import { ensureArray, filterZip, hasItems, isEmpty, lengthOf, mergeArray, toArray } from '../../src/Array';
-import { sum } from '../../src/Math';
+import { isNone } from '../../src/index.js';
+import { ensureArray, filterZip, hasItems, isEmpty, lengthOf, mergeArray, toArray } from '../../src/Array.js';
+import { sum } from '../../src/Math.js';
 
 const { match, stub } = sinon;
 

test/utils/TestArrayMapper.ts

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 
-import { ArrayMapper } from '../../src/ArrayMapper';
+import { ArrayMapper } from '../../src/ArrayMapper.js';
 
 describe('utils', async () => {
   describe('array mapper', async () => {

test/utils/TestAsync.ts

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 
-import { defer, deferValue, timeout } from '../../src/Async';
-import { TimeoutError } from '../../src/error/TimeoutError';
+import { defer, deferValue, timeout } from '../../src/Async.js';
+import { TimeoutError } from '../../src/error/TimeoutError.js';
 
 const TEST_DEFER = 10;
 const TEST_TOO_LONG = 25;

test/utils/TestBuffer.ts

@@ -2,8 +2,8 @@ import { expect } from 'chai';
 import { array, uint8Array } from 'fast-check';
 import { over } from 'mocha-foam';
 
-import { concat, encode } from '../../src/Buffer';
-import { sum } from '../../src/Math';
+import { concat, encode } from '../../src/Buffer.js';
+import { sum } from '../../src/Math.js';
 
 describe('buffer utils', async () => {
   describe('concat', async () => {

test/utils/TestChecklist.ts

@@ -2,7 +2,7 @@ import { expect } from 'chai';
 import { array, constant, integer, record } from 'fast-check';
 import { over } from 'mocha-foam';
 
-import { Checklist, ChecklistMode } from '../../src/Checklist';
+import { Checklist, ChecklistMode } from '../../src/Checklist.js';
 
 const EXISTING_ITEM = 'foo';
 const MISSING_ITEM = 'bin';

test/utils/TestChild.ts

@@ -1,9 +1,9 @@
 import { expect } from 'chai';
 import sinon from 'sinon';
 
-import { ChildProcessError } from '../../src';
-import { ChildStreams, childResult } from '../../src/Child';
-import { Maybe, mustExist } from '../../src/Maybe';
+import { ChildProcessError } from '../../src/error/ChildProcessError.js';
+import { ChildStreams, childResult } from '../../src/Child.js';
+import { Maybe, mustExist } from '../../src/Maybe.js';
 
 const { match, stub } = sinon;