@atlaspack/utils 2.17.1 → 2.17.3-typescript-08dcc1c9b.0

package/lib/schema.js

@@ -30,7 +30,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function validateSchema(schema, data) {
-  function walk(schemaAncestors, dataNode, dataPath) {
+  function walk(
+  // @ts-expect-error TS7006
+  schemaAncestors, dataNode, dataPath) {
     let [schemaNode] = schemaAncestors;
     if (schemaNode.type) {
       let type = Array.isArray(dataNode) ? 'array' : typeof dataNode;
@@ -49,10 +51,10 @@ function validateSchema(schema, data) {
             {
               if (schemaNode.items) {
                 let results = [];
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS18046
                 for (let i = 0; i < dataNode.length; i++) {
                   let result = walk([schemaNode.items].concat(schemaAncestors),
-                  // $FlowFixMe type was already checked
+                  // @ts-expect-error TS18046
                   dataNode[i], dataPath + '/' + i);
                   if (result) results.push(result);
                 }
@@ -62,7 +64,7 @@ function validateSchema(schema, data) {
             }
           case 'string':
             {
-              // $FlowFixMe type was already checked
+              // @ts-expect-error TS2322
               let value = dataNode;
               if (schemaNode.enum) {
                 if (!schemaNode.enum.includes(value)) {
@@ -92,7 +94,7 @@ function validateSchema(schema, data) {
             }
           case 'number':
             {
-              // $FlowFixMe type was already checked
+              // @ts-expect-error TS2322
               let value = dataNode;
               if (schemaNode.enum) {
                 if (!schemaNode.enum.includes(value)) {
@@ -113,10 +115,13 @@ function validateSchema(schema, data) {
               let results = [];
               let invalidProps;
               if (schemaNode.__forbiddenProperties) {
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS2769
                 let keys = Object.keys(dataNode);
+                // @ts-expect-error TS7006
                 invalidProps = schemaNode.__forbiddenProperties.filter(val => keys.includes(val));
-                results.push(...invalidProps.map(k => ({
+                results.push(...invalidProps.map(
+                // @ts-expect-error TS7006
+                k => ({
                   type: 'forbidden-prop',
                   dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
                   dataType: 'key',
@@ -127,10 +132,14 @@ function validateSchema(schema, data) {
                 })));
               }
               if (schemaNode.required) {
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS2769
                 let keys = Object.keys(dataNode);
-                let missingKeys = schemaNode.required.filter(val => !keys.includes(val));
-                results.push(...missingKeys.map(k => ({
+                let missingKeys = schemaNode.required.filter(
+                // @ts-expect-error TS7006
+                val => !keys.includes(val));
+                results.push(...missingKeys.map(
+                // @ts-expect-error TS7006
+                k => ({
                   type: 'missing-prop',
                   dataPath,
                   dataType: 'value',
@@ -144,14 +153,14 @@ function validateSchema(schema, data) {
                 let {
                   additionalProperties = true
                 } = schemaNode;
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS2407
                 for (let k in dataNode) {
                   if (invalidProps && invalidProps.includes(k)) {
                     // Don't check type on forbidden props
                     continue;
                   } else if (k in schemaNode.properties) {
                     let result = walk([schemaNode.properties[k]].concat(schemaAncestors),
-                    // $FlowFixMe type was already checked
+                    // @ts-expect-error TS18046
                     dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
                     if (result) results.push(result);
                   } else {
@@ -161,9 +170,9 @@ function validateSchema(schema, data) {
                           type: 'enum',
                           dataType: 'key',
                           dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
-                          expectedValues: Object.keys(schemaNode.properties).filter(
-                          // $FlowFixMe type was already checked
-                          p => !(p in dataNode)),
+                          expectedValues: Object.keys(schemaNode.properties
+                          // @ts-expect-error TS18046
+                          ).filter(p => !(p in dataNode)),
                           actualValue: k,
                           ancestors: schemaAncestors,
                           prettyType: schemaNode.__type
@@ -171,7 +180,7 @@ function validateSchema(schema, data) {
                       }
                     } else {
                       let result = walk([additionalProperties].concat(schemaAncestors),
-                      // $FlowFixMe type was already checked
+                      // @ts-expect-error TS18046
                       dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
                       if (result) results.push(result);
                     }
@@ -213,6 +222,7 @@ function validateSchema(schema, data) {
         }
       } else if (schemaNode.not) {
         let result = walk([schemaNode.not].concat(schemaAncestors), dataNode, dataPath);
+        // @ts-expect-error TS2339
         if (!result || result.length == 0) {
           return {
             type: 'other',
@@ -234,16 +244,22 @@ var _default = exports.default = validateSchema;
 function fuzzySearch(expectedValues, actualValue) {
   let result = expectedValues.map(exp => [exp, levenshtein().distance(exp, actualValue)]).filter(
   // Remove if more than half of the string would need to be changed
+  // @ts-expect-error TS2769
   ([, d]) => d * 2 < actualValue.length);
+  // @ts-expect-error TS2345
   result.sort(([, a], [, b]) => a - b);
+  // @ts-expect-error TS2345
   return result.map(([v]) => v);
 }
 validateSchema.diagnostic = function (schema, data, origin, message) {
   if ('source' in data && 'data' in data && typeof data.source !== 'string' && !data) {
     throw new Error('At least one of data.source and data.data must be defined!');
   }
-  let object = data.map ? data.map.data :
-  // $FlowFixMe we can assume it's a JSON object
+  // @ts-expect-error TS2339
+  let object = data.map ?
+  // @ts-expect-error TS2339
+  data.map.data :
+  // @ts-expect-error TS2339
   data.data ?? JSON.parse(data.source);
   let errors = validateSchema(schema, object);
   if (errors.length) {
@@ -303,11 +319,13 @@ validateSchema.diagnostic = function (schema, data, origin, message) {
       };
     });
     let map, code;
+    // @ts-expect-error TS2339
     if (data.map) {
+      // @ts-expect-error TS2339
       map = data.map;
       code = data.source;
     } else {
-      // $FlowFixMe we can assume that data is valid JSON
+      // @ts-expect-error TS2339
       map = data.source ?? JSON.stringify((0, _nullthrows().default)(data.data), 0, '\t');
       code = map;
     }
@@ -329,6 +347,7 @@ validateSchema.diagnostic = function (schema, data, origin, message) {
       diagnostic: {
         message: message,
         origin,
+        // @ts-expect-error TS2322
         codeFrames
       }
     });

package/lib/shared-buffer.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.SharedBuffer = void 0;
 let SharedBuffer = exports.SharedBuffer = void 0;
 
-// $FlowFixMe[prop-missing]
+// @ts-expect-error process.browser is a browser-specific property
 if (process.browser) {
   exports.SharedBuffer = SharedBuffer = ArrayBuffer;
   // Safari has removed the constructor

package/lib/urlJoin.js

@@ -28,7 +28,7 @@ function urlJoin(publicURL, assetPath) {
   // Leading / ensures that paths with colons are not parsed as a protocol.
   let p = assetPath.startsWith('/') ? assetPath : '/' + assetPath;
   const assetUrl = _url().default.parse(p);
-  url.pathname = _path().default.posix.join(url.pathname, assetUrl.pathname);
+  url.pathname = _path().default.posix.join(url.pathname ?? '', assetUrl.pathname ?? '');
   url.search = assetUrl.search;
   url.hash = assetUrl.hash;
   return _url().default.format(url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/utils",
-  "version": "2.17.1",
+  "version": "2.17.3-typescript-08dcc1c9b.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -11,7 +11,7 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
-  "source": "src/index.js",
+  "source": "src/index.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
@@ -30,17 +30,16 @@
     }
   },
   "dependencies": {
-    "@atlaspack/codeframe": "2.13.4",
-    "@atlaspack/diagnostic": "2.14.1",
-    "@atlaspack/feature-flags": "2.19.1",
-    "@atlaspack/logger": "2.14.13",
-    "@atlaspack/markdown-ansi": "2.14.1",
-    "@atlaspack/rust": "3.4.1",
-    "@parcel/source-map": "^2.1.1",
-    "chalk": "^4.1.0",
-    "nullthrows": "^1.1.1",
+    "@atlaspack/codeframe": "2.13.5-typescript-08dcc1c9b.0",
+    "@atlaspack/diagnostic": "2.14.2-typescript-08dcc1c9b.0",
+    "@atlaspack/feature-flags": "2.19.3-typescript-08dcc1c9b.0",
+    "@atlaspack/logger": "2.14.14-typescript-08dcc1c9b.0",
+    "@atlaspack/markdown-ansi": "2.14.2-typescript-08dcc1c9b.0",
+    "@atlaspack/rust": "3.4.2-typescript-08dcc1c9b.0",
     "@iarna/toml": "^2.2.0",
+    "@parcel/source-map": "^2.1.1",
     "ansi-html-community": "0.0.8",
+    "chalk": "^4.1.0",
     "clone": "^2.1.1",
     "fast-glob": "^3.2.12",
     "fastest-levenshtein": "^1.0.16",
@@ -50,13 +49,14 @@
     "lru-cache": "^6.0.0",
     "micromatch": "^4.0.4",
     "node-forge": "^1.2.1",
+    "nullthrows": "^1.1.1",
     "open": "^7.0.3",
     "snarkdown": "^2.0.0",
     "strip-ansi": "^6.0.0",
     "terminal-link": "^2.1.1"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.1",
+    "@atlaspack/babel-register": "2.14.2-typescript-08dcc1c9b.0",
     "benny": "^3.7.1",
     "random-int": "^1.0.0"
   },
@@ -66,5 +66,10 @@
     "./src/openInBrowser.js": false,
     "@atlaspack/markdown-ansi": false
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "scripts": {
+    "check-ts": "tsc --noEmit"
+  },
+  "types": "src/index.ts",
+  "gitHead": "08dcc1c9bcdc6ab931d55e05ccc0f45669de2f22"
 }

package/src/{DefaultMap.js → DefaultMap.ts}

@@ -1,9 +1,7 @@
-// @flow strict-local
-
 export class DefaultMap<K, V> extends Map<K, V> {
-  _getDefault: (K) => V;
+  _getDefault: (arg1: K) => V;
 
-  constructor(getDefault: (K) => V, entries?: Iterable<[K, V]>) {
+  constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>) {
     super(entries);
     this._getDefault = getDefault;
   }
@@ -17,8 +15,7 @@ export class DefaultMap<K, V> extends Map<K, V> {
       this.set(key, ret);
     }
 
-    // $FlowFixMe
-    return ret;
+    return ret as V;
   }
 }
 
@@ -26,11 +23,11 @@ interface Key {}
 
 // Duplicated from DefaultMap implementation for Flow
 // Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-export class DefaultWeakMap<K: Key, V> extends WeakMap<K, V> {
-  _getDefault: (K) => V;
+export class DefaultWeakMap<K extends Key, V> extends WeakMap<K, V> {
+  _getDefault: (arg1: K) => V;
 
-  constructor(getDefault: (K) => V, entries?: Iterable<[K, V]>) {
-    super(entries);
+  constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>) {
+    super(entries as Iterable<readonly [K, V]>);
     this._getDefault = getDefault;
   }
 
@@ -43,7 +40,6 @@ export class DefaultWeakMap<K: Key, V> extends WeakMap<K, V> {
       this.set(key, ret);
     }
 
-    // $FlowFixMe
-    return ret;
+    return ret as V;
   }
 }

package/src/Deferred.ts

@@ -0,0 +1,26 @@
+import invariant from 'assert';
+
+export type Deferred<T> = {
+  resolve(arg1: T): void;
+  reject(arg1: unknown): void;
+};
+
+export function makeDeferredWithPromise<T>(): {
+  deferred: Deferred<T>;
+  promise: Promise<T>;
+} {
+  let deferred: Deferred<T> | null | undefined;
+  let promise = new Promise<T>(
+    (
+      resolve: (result: Promise<T> | T) => void,
+      reject: (error?: any) => void,
+    ) => {
+      deferred = {resolve, reject};
+    },
+  );
+
+  // Promise constructor callback executes synchronously, so this is defined
+  invariant(deferred != null);
+
+  return {deferred, promise};
+}

package/src/{PromiseQueue.js → PromiseQueue.ts}

@@ -1,16 +1,16 @@
-// @flow strict-local
+import {makeDeferredWithPromise, Deferred} from './Deferred';
 
-import {makeDeferredWithPromise, type Deferred} from './Deferred';
-
-type PromiseQueueOpts = {|maxConcurrent: number|};
+type PromiseQueueOpts = {
+  maxConcurrent: number;
+};
 
 export default class PromiseQueue<T> {
-  _deferred: ?Deferred<Array<T>>;
+  _deferred: Deferred<Array<T>> | null | undefined;
   _maxConcurrent: number;
   _numRunning: number = 0;
   _queue: Array<() => Promise<void>> = [];
-  _runPromise: ?Promise<Array<T>> = null;
-  _error: mixed;
+  _runPromise: Promise<Array<T>> | null | undefined = null;
+  _error: unknown;
   _count: number = 0;
   _results: Array<T> = [];
   _addSubscriptions: Set<() => void> = new Set();
@@ -28,30 +28,35 @@ export default class PromiseQueue<T> {
   }
 
   add(fn: () => Promise<T>): void {
-    new Promise((resolve, reject) => {
-      let i = this._count++;
-      let wrapped = () =>
-        fn().then(
-          (result) => {
-            this._results[i] = result;
-            resolve(result);
-          },
-          (err) => {
-            reject(err);
-            throw err;
-          },
-        );
-
-      this._queue.push(wrapped);
-
-      for (const addFn of this._addSubscriptions) {
-        addFn();
-      }
-
-      if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
-        this._next();
-      }
-    }).catch(() => {});
+    new Promise(
+      (
+        resolve: (result: Promise<T> | T) => void,
+        reject: (error?: any) => void,
+      ) => {
+        let i = this._count++;
+        let wrapped = () =>
+          fn().then(
+            (result) => {
+              this._results[i] = result;
+              resolve(result);
+            },
+            (err) => {
+              reject(err);
+              throw err;
+            },
+          );
+
+        this._queue.push(wrapped);
+
+        for (const addFn of this._addSubscriptions) {
+          addFn();
+        }
+
+        if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
+          this._next();
+        }
+      },
+    ).catch(() => {});
   }
 
   subscribeToAdd(fn: () => void): () => void {
@@ -71,9 +76,9 @@ export default class PromiseQueue<T> {
       return Promise.resolve([]);
     }
 
-    let {deferred, promise} = makeDeferredWithPromise();
+    let {deferred, promise} = makeDeferredWithPromise<Array<T>>();
     this._deferred = deferred;
-    this._runPromise = promise;
+    this._runPromise = promise as Promise<Array<T>>;
 
     while (this._queue.length && this._numRunning < this._maxConcurrent) {
       this._next();
@@ -84,7 +89,7 @@ export default class PromiseQueue<T> {
 
   async _next(): Promise<void> {
     let fn = this._queue.shift();
-    await this._runFn(fn);
+    await this._runFn(fn as () => unknown);
     if (this._queue.length) {
       this._next();
     } else if (this._numRunning === 0) {
@@ -92,11 +97,11 @@ export default class PromiseQueue<T> {
     }
   }
 
-  async _runFn(fn: () => mixed): Promise<void> {
+  async _runFn(fn: () => unknown): Promise<void> {
     this._numRunning++;
     try {
       await fn();
-    } catch (e) {
+    } catch (e: any) {
       // Only store the first error that occurs.
       // We don't reject immediately so that any other concurrent
       // requests have time to complete.

package/src/{TapStream.js → TapStream.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {Transform} from 'stream';
 
 /*
@@ -7,21 +5,24 @@ import {Transform} from 'stream';
  * callback. Continues to pass data chunks down the stream.
  */
 export default class TapStream extends Transform {
-  _tap: (Buffer) => mixed;
-  constructor(tap: (Buffer) => mixed, options: mixed) {
-    super({...options});
+  _tap: (arg1: Buffer) => unknown;
+  constructor(tap: (arg1: Buffer) => unknown, options: unknown) {
+    super({...(options as any)});
     this._tap = tap;
   }
 
   _transform(
     chunk: Buffer | string,
     encoding: string,
-    callback: (err: ?Error, chunk?: Buffer | string) => mixed,
+    callback: (
+      err?: Error | null | undefined,
+      chunk?: Buffer | string,
+    ) => unknown,
   ) {
     try {
       this._tap(Buffer.from(chunk));
       callback(null, chunk);
-    } catch (err) {
+    } catch (err: any) {
       callback(err);
     }
   }

package/src/{alternatives.js → alternatives.ts}

@@ -1,4 +1,3 @@
-// @flow
 import path from 'path';
 import type {FileSystem} from '@atlaspack/types';
 import {fuzzySearch} from './schema';
@@ -48,7 +47,7 @@ export async function findAlternativeNodeModules(
           potentialModules.push(...modules);
         }
       }
-    } catch (err) {
+    } catch (err: any) {
       // ignore
     }
 
@@ -68,16 +67,16 @@ async function findAllFilesUp({
   collected,
   leadingDotSlash = true,
   includeDirectories = true,
-}: {|
-  fs: FileSystem,
-  dir: string,
-  root: string,
-  basedir: string,
-  maxlength: number,
-  collected: Array<string>,
-  leadingDotSlash?: boolean,
-  includeDirectories?: boolean,
-|}): Promise<mixed> {
+}: {
+  fs: FileSystem;
+  dir: string;
+  root: string;
+  basedir: string;
+  maxlength: number;
+  collected: Array<string>;
+  leadingDotSlash?: boolean;
+  includeDirectories?: boolean;
+}): Promise<unknown> {
   let dirContent = (await fs.readdir(dir)).sort();
   return Promise.all(
     dirContent.map(async (item) => {
@@ -111,9 +110,9 @@ export async function findAlternativeFiles(
   fileSpecifier: string,
   dir: string,
   projectRoot: string,
-  leadingDotSlash?: boolean = true,
-  includeDirectories?: boolean = true,
-  includeExtension?: boolean = false,
+  leadingDotSlash: boolean = true,
+  includeDirectories: boolean = true,
+  includeExtension: boolean = false,
 ): Promise<Array<string>> {
   let potentialFiles: Array<string> = [];
   // Find our root, we won't recommend files above the package root as that's bad practise

package/src/{ansi-html.js → ansi-html.ts}

@@ -1,4 +1,3 @@
-// @flow strict-local
 import ansiHTML from 'ansi-html-community';
 import {escapeHTML} from './escape-html';
 

package/src/{blob.js → blob.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Blob} from '@atlaspack/types';
 
 import {Buffer} from 'buffer';
@@ -12,7 +10,7 @@ export function blobToBuffer(blob: Blob): Promise<Buffer> {
   } else if (blob instanceof Buffer) {
     return Promise.resolve(Buffer.from(blob));
   } else {
-    return Promise.resolve(Buffer.from(blob, 'utf8'));
+    return Promise.resolve(Buffer.from(blob as string, 'utf8'));
   }
 }
 
@@ -22,6 +20,6 @@ export async function blobToString(blob: Blob): Promise<string> {
   } else if (blob instanceof Buffer) {
     return blob.toString();
   } else {
-    return blob;
+    return blob as string;
   }
 }

package/src/{bundle-url.js → bundle-url.ts}

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-let bundleURL: ?string = null;
+let bundleURL: string | null | undefined = null;
 function getBundleURLCached(): string {
   if (bundleURL == null) {
     bundleURL = _getBundleURL();
@@ -13,7 +11,7 @@ function _getBundleURL(): string {
   // Attempt to find the URL of the current script and use that as the base URL
   try {
     throw new Error();
-  } catch (err) {
+  } catch (err: any) {
     let stack: string = typeof err.stack === 'string' ? err.stack : '';
     let matches = stack.match(/(https?|file|ftp):\/\/[^)\n]+/g);
     if (matches) {
@@ -24,7 +22,7 @@ function _getBundleURL(): string {
   return '/';
 }
 
-export function getBaseURL(url: ?string): string {
+export function getBaseURL(url?: string | null): string {
   if (url == null) {
     return '/';
   }