@atlaspack/utils 2.14.5-canary.26 → 2.14.5-canary.261

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import ThrowableDiagnostic, {
   generateJSONCodeHighlights,
   escapeMarkdown,
@@ -19,105 +18,107 @@ export type SchemaEntity =
   | SchemaAllOf
   | SchemaNot
   | SchemaAny;
-export type SchemaArray = {|
-  type: 'array',
-  items?: SchemaEntity,
-  __type?: string,
-|};
-export type SchemaBoolean = {|
-  type: 'boolean',
-  __type?: string,
-|};
-export type SchemaOneOf = {|
-  oneOf: Array<SchemaEntity>,
-|};
-export type SchemaAllOf = {|
-  allOf: Array<SchemaEntity>,
-|};
-export type SchemaNot = {|
-  not: SchemaEntity,
-  __message: string,
-|};
-export type SchemaString = {|
-  type: 'string',
-  enum?: Array<string>,
-  __validate?: (val: string) => ?string,
-  __type?: string,
-|};
-export type SchemaNumber = {|
-  type: 'number',
-  enum?: Array<number>,
-  __type?: string,
-|};
-export type SchemaEnum = {|
-  enum: Array<mixed>,
-|};
-export type SchemaObject = {|
-  type: 'object',
-  properties: {[string]: SchemaEntity, ...},
-  additionalProperties?: boolean | SchemaEntity,
-  required?: Array<string>,
-  __forbiddenProperties?: Array<string>,
-  __type?: string,
-|};
-export type SchemaAny = {||};
+export type SchemaArray = {
+  type: 'array';
+  items?: SchemaEntity;
+  __type?: string;
+};
+export type SchemaBoolean = {
+  type: 'boolean';
+  __type?: string;
+};
+export type SchemaOneOf = {
+  oneOf: Array<SchemaEntity>;
+};
+export type SchemaAllOf = {
+  allOf: Array<SchemaEntity>;
+};
+export type SchemaNot = {
+  not: SchemaEntity;
+  __message: string;
+};
+export type SchemaString = {
+  type: 'string';
+  enum?: Array<string>;
+  __validate?: (val: string) => string | null | undefined;
+  __type?: string;
+};
+export type SchemaNumber = {
+  type: 'number';
+  enum?: Array<number>;
+  __type?: string;
+};
+export type SchemaEnum = {
+  enum: Array<unknown>;
+};
+export type SchemaObject = {
+  type: 'object';
+  properties: {
+    [key: string]: SchemaEntity;
+  };
+  additionalProperties?: boolean | SchemaEntity;
+  required?: Array<string>;
+  __forbiddenProperties?: Array<string>;
+  __type?: string;
+};
+export type SchemaAny = Record<any, any>;
 export type SchemaError =
-  | {|
-      type: 'type',
-      expectedTypes: Array<string>,
-      dataType: ?'key' | 'value',
-
-      dataPath: string,
-      ancestors: Array<SchemaEntity>,
-      prettyType?: string,
-    |}
-  | {|
-      type: 'enum',
-      expectedValues: Array<mixed>,
-      dataType: 'key' | 'value',
-      actualValue: mixed,
-
-      dataPath: string,
-      ancestors: Array<SchemaEntity>,
-      prettyType?: string,
-    |}
-  | {|
-      type: 'forbidden-prop',
-      prop: string,
-      expectedProps: Array<string>,
-      actualProps: Array<string>,
-      dataType: 'key',
-
-      dataPath: string,
-      ancestors: Array<SchemaEntity>,
-      prettyType?: string,
-    |}
-  | {|
-      type: 'missing-prop',
-      prop: string,
-      expectedProps: Array<string>,
-      actualProps: Array<string>,
-      dataType: 'key' | 'value',
-
-      dataPath: string,
-      ancestors: Array<SchemaEntity>,
-      prettyType?: string,
-    |}
-  | {|
-      type: 'other',
-      actualValue: mixed,
-      dataType: ?'key' | 'value',
-      message?: string,
-      dataPath: string,
-      ancestors: Array<SchemaEntity>,
-    |};
+  | {
+      type: 'type';
+      expectedTypes: Array<string>;
+      dataType: 'key' | null | undefined | 'value';
+      dataPath: string;
+      ancestors: Array<SchemaEntity>;
+      prettyType?: string;
+    }
+  | {
+      type: 'enum';
+      expectedValues: Array<unknown>;
+      dataType: 'key' | 'value';
+      actualValue: unknown;
+      dataPath: string;
+      ancestors: Array<SchemaEntity>;
+      prettyType?: string;
+    }
+  | {
+      type: 'forbidden-prop';
+      prop: string;
+      expectedProps: Array<string>;
+      actualProps: Array<string>;
+      dataType: 'key';
+      dataPath: string;
+      ancestors: Array<SchemaEntity>;
+      prettyType?: string;
+    }
+  | {
+      type: 'missing-prop';
+      prop: string;
+      expectedProps: Array<string>;
+      actualProps: Array<string>;
+      dataType: 'key' | 'value';
+      dataPath: string;
+      ancestors: Array<SchemaEntity>;
+      prettyType?: string;
+    }
+  | {
+      type: 'other';
+      actualValue: unknown;
+      dataType: 'key' | null | undefined | 'value';
+      message?: string;
+      dataPath: string;
+      ancestors: Array<SchemaEntity>;
+    };
 
-function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
+function validateSchema(
+  schema: SchemaEntity,
+  data: unknown,
+): Array<SchemaError> {
   function walk(
+    // @ts-expect-error TS7006
     schemaAncestors,
-    dataNode,
-    dataPath,
-  ): ?SchemaError | Array<SchemaError> {
+    dataNode: unknown,
+    dataPath: string,
+  ): SchemaError | null | undefined | Array<SchemaError> {
     let [schemaNode] = schemaAncestors;
 
     if (schemaNode.type) {
@@ -136,23 +137,26 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
           case 'array': {
             if (schemaNode.items) {
               let results: Array<SchemaError | Array<SchemaError>> = [];
-              // $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);
               }
               if (results.length)
-                return results.reduce((acc, v) => acc.concat(v), []);
+                return results.reduce<Array<any>>(
+                  (acc, v) => acc.concat(v),
+                  [],
+                );
             }
             break;
           }
           case 'string': {
-            // $FlowFixMe type was already checked
+            // @ts-expect-error TS2322
             let value: string = dataNode;
             if (schemaNode.enum) {
               if (!schemaNode.enum.includes(value)) {
@@ -181,7 +185,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
             break;
           }
           case 'number': {
-            // $FlowFixMe type was already checked
+            // @ts-expect-error TS2322
             let value: number = dataNode;
             if (schemaNode.enum) {
               if (!schemaNode.enum.includes(value)) {
@@ -201,13 +205,15 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
             let results: Array<Array<SchemaError> | SchemaError> = [];
             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(
+                  // @ts-expect-error TS7006
                   (k) =>
                     ({
                       type: 'forbidden-prop',
@@ -217,18 +223,20 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                       expectedProps: Object.keys(schemaNode.properties),
                       actualProps: keys,
                       ancestors: schemaAncestors,
-                    }: SchemaError),
+                    }) as SchemaError,
                 ),
               );
             }
             if (schemaNode.required) {
-              // $FlowFixMe type was already checked
+              // @ts-expect-error TS2769
               let keys = Object.keys(dataNode);
               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',
@@ -238,13 +246,13 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                       expectedProps: schemaNode.required,
                       actualProps: keys,
                       ancestors: schemaAncestors,
-                    }: SchemaError),
+                    }) as SchemaError,
                 ),
               );
             }
             if (schemaNode.properties) {
               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
@@ -252,7 +260,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                 } 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 + '/' + encodeJSONKeyComponent(k),
                   );
@@ -266,10 +274,8 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                         dataPath: dataPath + '/' + encodeJSONKeyComponent(k),
                         expectedValues: Object.keys(
                           schemaNode.properties,
-                        ).filter(
-                          // $FlowFixMe type was already checked
-                          (p) => !(p in dataNode),
-                        ),
+                          // @ts-expect-error TS18046
+                        ).filter((p) => !(p in dataNode)),
                         actualValue: k,
                         ancestors: schemaAncestors,
                         prettyType: schemaNode.__type,
@@ -278,7 +284,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                   } else {
                     let result = walk(
                       [additionalProperties].concat(schemaAncestors),
-                      // $FlowFixMe type was already checked
+                      // @ts-expect-error TS18046
                       dataNode[k],
                       dataPath + '/' + encodeJSONKeyComponent(k),
                     );
@@ -288,7 +294,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
               }
             }
             if (results.length)
-              return results.reduce((acc, v) => acc.concat(v), []);
+              return results.reduce<Array<any>>((acc, v) => acc.concat(v), []);
             break;
           }
           case 'boolean':
@@ -328,10 +334,10 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
               ? Array.isArray(a) && !Array.isArray(b)
                 ? -1
                 : !Array.isArray(a) && Array.isArray(b)
-                ? 1
-                : Array.isArray(a) && Array.isArray(b)
-                ? b.length - a.length
-                : 0
+                  ? 1
+                  : Array.isArray(a) && Array.isArray(b)
+                    ? b.length - a.length
+                    : 0
               : b.dataPath.length - a.dataPath.length,
           );
           return results[0];
@@ -342,6 +348,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
           dataNode,
           dataPath,
         );
+        // @ts-expect-error TS2339
         if (!result || result.length == 0) {
           return {
             type: 'other',
@@ -371,47 +378,64 @@ export function fuzzySearch(
     .map((exp) => [exp, levenshtein.distance(exp, actualValue)])
     .filter(
       // Remove if more than half of the string would need to be changed
-      ([, d]) => d * 2 < actualValue.length,
+      // @ts-expect-error TS2769
+      ([, d]: [any, any]) => d * 2 < actualValue.length,
     );
-  result.sort(([, a], [, b]) => a - b);
-  return result.map(([v]) => v);
+  // @ts-expect-error TS2345
+  result.sort(([, a]: [any, any], [, b]: [any, any]) => a - b);
+  // @ts-expect-error TS2345
+  return result.map(([v]: [any]) => v);
 }
 
 validateSchema.diagnostic = function (
   schema: SchemaEntity,
-  data: {|
-    ...
-      | {|
-          source?: ?string,
-          data?: mixed,
-        |}
-      | {|
-          source: string,
-          map: {|
-            data: mixed,
-            pointers: {|[key: string]: Mapping|},
-          |},
-        |},
-    filePath?: ?string,
-    prependKey?: ?string,
-  |},
+  data: (
+    | {
+        source?: (() => string) | string | null | undefined;
+        data?: unknown;
+      }
+    | {
+        source: string | (() => string);
+        map: {
+          data: unknown;
+          pointers: {
+            [key: string]: Mapping;
+          };
+        };
+      }
+  ) & {
+    filePath?: string | null | undefined;
+    prependKey?: string | null | undefined;
+  },
   origin: string,
   message: string,
-): void {
-  if (
-    'source' in data &&
-    'data' in data &&
-    typeof data.source !== 'string' &&
-    !data
-  ) {
+): undefined {
+  if (!('map' in data) && !('source' in data || 'data' in data)) {
     throw new Error(
-      'At least one of data.source and data.data must be defined!',
+      'At least one of data.source, data.data, or data.map must be defined!',
     );
   }
+  let loadedSource: string | null | undefined;
+  function loadSource(
+    loader: string | (() => string) | null | undefined,
+  ): string | null | undefined {
+    if (loadedSource !== undefined) {
+      return loadedSource;
+    } else if (typeof loader === 'function') {
+      loadedSource = loader();
+      return loadedSource;
+    } else if (typeof loader === 'string') {
+      loadedSource = loader;
+      return loadedSource;
+    }
+    return loadedSource;
+  }
+  // @ts-expect-error TS2339
   let object = data.map
-    ? data.map.data
-    : // $FlowFixMe we can assume it's a JSON object
-      data.data ?? JSON.parse(data.source);
+    ? // @ts-expect-error TS2339
+      data.map.data
+    : // @ts-expect-error TS2339
+      (data.data ?? JSON.parse(loadSource(data.source)));
   let errors = validateSchema(schema, object);
   if (errors.length) {
     let keys = errors.map((e) => {
@@ -469,12 +493,16 @@ validateSchema.diagnostic = function (
       return {key: e.dataPath, type: e.dataType, message};
     });
     let map, code;
+    // @ts-expect-error TS2339
     if (data.map) {
+      // @ts-expect-error TS2339
       map = data.map;
-      code = data.source;
+      code = loadSource(data.source);
     } else {
-      // $FlowFixMe we can assume that data is valid JSON
-      map = data.source ?? JSON.stringify(nullthrows(data.data), 0, '\t');
+      map =
+        loadSource(data.source) ??
+        // @ts-expect-error TS2339
+        JSON.stringify(nullthrows(data.data), 0, '\t');
       code = map;
     }
     let codeFrames = [
@@ -497,6 +525,7 @@ validateSchema.diagnostic = function (
       diagnostic: {
         message: message,
         origin,
+        // @ts-expect-error TS2322
         codeFrames,
       },
     });

package/src/{shared-buffer.js → shared-buffer.ts}

@@ -1,8 +1,10 @@
-// @flow
+// flow-to-ts helpers
+export type Class<T> = new (...args: any[]) => T;
+// /flow-to-ts helpers
 
 export let SharedBuffer: Class<ArrayBuffer> | Class<SharedArrayBuffer>;
 
-// $FlowFixMe[prop-missing]
+// @ts-expect-error process.browser is a browser-specific property
 if (process.browser) {
   SharedBuffer = ArrayBuffer;
   // Safari has removed the constructor
@@ -12,7 +14,7 @@ if (process.browser) {
       // Firefox might throw when sending the Buffer over a MessagePort
       channel.port1.postMessage(new SharedArrayBuffer(0));
       SharedBuffer = SharedArrayBuffer;
-    } catch (_) {
+    } catch (_: any) {
       // NOOP
     }
     channel.port1.close();

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

@@ -1,6 +1,5 @@
-// @flow
-import type {SourceLocation} from '@atlaspack/types';
-import type {FileSystem} from '@atlaspack/fs';
+import type {SourceLocation, FileSystem} from '@atlaspack/types-internal';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import SourceMap from '@parcel/source-map';
 import path from 'path';
 import {normalizeSeparators, isAbsolute} from './path';
@@ -21,7 +20,7 @@ export const SOURCEMAP_EXTENSIONS: Set<string> = new Set<string>([
 
 export function matchSourceMappingURL(
   contents: string,
-): null | RegExp$matchResult {
+): RegExpMatchArray | null {
   return contents.match(SOURCEMAP_RE);
 }
 
@@ -29,7 +28,15 @@ export async function loadSourceMapUrl(
   fs: FileSystem,
   filename: string,
   contents: string,
-): Promise<?{|filename: string, map: any, url: string|}> {
+): Promise<
+  | {
+      filename: string;
+      map: any;
+      url: string;
+    }
+  | null
+  | undefined
+> {
   let match = matchSourceMappingURL(contents);
   if (match) {
     let url = match[1].trim();
@@ -60,8 +67,11 @@ export async function loadSourceMapUrl(
 export async function loadSourceMap(
   filename: string,
   contents: string,
-  options: {fs: FileSystem, projectRoot: string, ...},
-): Promise<?SourceMap> {
+  options: {
+    fs: FileSystem;
+    projectRoot: string;
+  },
+): Promise<SourceMap | null | undefined> {
   let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
   if (foundMap) {
     let mapSourceRoot = path.dirname(filename);
@@ -75,7 +85,7 @@ export async function loadSourceMap(
     let sourcemapInstance = new SourceMap(options.projectRoot);
     sourcemapInstance.addVLQMap({
       ...foundMap.map,
-      sources: foundMap.map.sources.map((s) => {
+      sources: foundMap.map.sources.map((s: string) => {
         return path.join(mapSourceRoot, s);
       }),
     });
@@ -86,6 +96,7 @@ export async function loadSourceMap(
 export function remapSourceLocation(
   loc: SourceLocation,
   originalMap: SourceMap,
+  projectRoot: string,
 ): SourceLocation {
   let {
     filePath,
@@ -99,7 +110,14 @@ export function remapSourceLocation(
 
   if (start?.original) {
     if (start.source) {
-      filePath = start.source;
+      if (
+        getFeatureFlag('symbolLocationFix') &&
+        !path.isAbsolute(start.source)
+      ) {
+        filePath = path.join(projectRoot, start.source);
+      } else {
+        filePath = start.source;
+      }
     }
 
     ({line: startLine, column: startCol} = start.original);

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

@@ -1,17 +1,20 @@
-// @flow strict-local
-
 import {Readable, PassThrough} from 'stream';
-import type {Blob} from '@atlaspack/types';
+import type {Blob} from '@atlaspack/types-internal';
 
 export function measureStreamLength(stream: Readable): Promise<number> {
-  return new Promise((resolve, reject) => {
-    let length = 0;
-    stream.on('data', (chunk) => {
-      length += chunk;
-    });
-    stream.on('end', () => resolve(length));
-    stream.on('error', reject);
-  });
+  return new Promise(
+    (
+      resolve: (result: Promise<number> | number) => void,
+      reject: (error?: any) => void,
+    ) => {
+      let length = 0;
+      stream.on('data', (chunk) => {
+        length += chunk;
+      });
+      stream.on('end', () => resolve(length));
+      stream.on('error', reject);
+    },
+  );
 }
 
 export function readableFromStringOrBuffer(str: string | Buffer): Readable {
@@ -23,16 +26,21 @@ export function readableFromStringOrBuffer(str: string | Buffer): Readable {
 }
 
 export function bufferStream(stream: Readable): Promise<Buffer> {
-  return new Promise((resolve, reject) => {
-    let buf = Buffer.from([]);
-    stream.on('data', (data) => {
-      buf = Buffer.concat([buf, data]);
-    });
-    stream.on('end', () => {
-      resolve(buf);
-    });
-    stream.on('error', reject);
-  });
+  return new Promise(
+    (
+      resolve: (result: Promise<Buffer> | Buffer) => void,
+      reject: (error?: any) => void,
+    ) => {
+      let buf = Buffer.from([]);
+      stream.on('data', (data) => {
+        buf = Buffer.concat([buf, data]);
+      });
+      stream.on('end', () => {
+        resolve(buf);
+      });
+      stream.on('error', reject);
+    },
+  );
 }
 
 export function blobToStream(blob: Blob): Readable {
@@ -62,7 +70,7 @@ export function fallbackStream(
 ): Readable {
   const res = new PassThrough();
   stream.on('error', (err) => {
-    if (err.code === 'ENOENT') {
+    if ((err as any).code === 'ENOENT') {
       fallback().pipe(res);
     } else {
       res.emit('error', err);

package/src/throttle.ts

@@ -0,0 +1,13 @@
+export default function throttle<TArgs extends Array<unknown>>(
+  fn: (...args: TArgs) => unknown,
+  delay: number,
+): (...args: TArgs) => void {
+  let lastCalled: number | null | undefined;
+
+  return function throttled(this: any, ...args: TArgs) {
+    if (lastCalled == null || lastCalled + delay <= Date.now()) {
+      fn.call(this, ...args);
+      lastCalled = Date.now();
+    }
+  };
+}