@atlaspack/utils 2.17.3-typescript-bc4459c37.0 → 2.17.3

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

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 import type SourceMap from '@parcel/source-map';
 import type {
   Async,
@@ -18,10 +20,7 @@ import {bufferStream, relativeBundlePath, urlJoin} from './';
 
 type ReplacementMap = Map<
   string /* dependency id */,
-  {
-    from: string;
-    to: string;
-  }
+  {|from: string, to: string|},
 >;
 
 /*
@@ -36,21 +35,18 @@ export function replaceURLReferences({
   bundleGraph,
   contents,
   map,
-  getReplacement = (s: string) => s,
+  getReplacement = (s) => s,
   relative = true,
-}: {
-  bundle: NamedBundle;
-  bundleGraph: BundleGraph<NamedBundle>;
-  contents: string;
-  relative?: boolean;
-  map?: SourceMap | null | undefined;
-  getReplacement?: (arg1: string) => string;
-}): {
-  readonly contents: string;
-  readonly map: SourceMap | null | undefined;
-} {
+}: {|
+  bundle: NamedBundle,
+  bundleGraph: BundleGraph<NamedBundle>,
+  contents: string,
+  relative?: boolean,
+  map?: ?SourceMap,
+  getReplacement?: (string) => string,
+|}): {|+contents: string, +map: ?SourceMap|} {
   let replacements = new Map();
-  let urlDependencies: Array<Dependency> = [];
+  let urlDependencies = [];
   bundle.traverse((node) => {
     if (node.type === 'dependency' && node.value.specifierType === 'url') {
       urlDependencies.push(node.value);
@@ -106,32 +102,24 @@ export async function replaceInlineReferences({
   map,
   getInlineReplacement,
   getInlineBundleContents,
-}: {
-  bundle: Bundle;
-  bundleGraph: BundleGraph<NamedBundle>;
-  contents: string;
+}: {|
+  bundle: Bundle,
+  bundleGraph: BundleGraph<NamedBundle>,
+  contents: string,
   getInlineReplacement: (
-    arg1: Dependency,
-    arg2: 'string' | null | undefined,
-    arg3: string,
-  ) => {
-    from: string;
-    to: string;
-  };
+    Dependency,
+    ?'string',
+    string,
+  ) => {|from: string, to: string|},
   getInlineBundleContents: (
-    arg1: Bundle,
-    arg2: BundleGraph<NamedBundle>,
-  ) => Async<{
-    contents: Blob;
-  }>;
-  map?: SourceMap | null | undefined;
-}): Promise<{
-  readonly contents: string;
-  readonly map: SourceMap | null | undefined;
-}> {
+    Bundle,
+    BundleGraph<NamedBundle>,
+  ) => Async<{|contents: Blob|}>,
+  map?: ?SourceMap,
+|}): Promise<{|+contents: string, +map: ?SourceMap|}> {
   let replacements = new Map();
 
-  let dependencies: Array<Dependency> = [];
+  let dependencies = [];
   bundle.traverse((node) => {
     if (node.type === 'dependency') {
       dependencies.push(node.value);
@@ -174,16 +162,13 @@ export function getURLReplacement({
   toBundle,
   relative,
   getReplacement,
-}: {
-  dependency: Dependency;
-  fromBundle: NamedBundle;
-  toBundle: NamedBundle;
-  relative: boolean;
-  getReplacement?: (arg1: string) => string;
-}): {
-  from: string;
-  to: string;
-} {
+}: {|
+  dependency: Dependency,
+  fromBundle: NamedBundle,
+  toBundle: NamedBundle,
+  relative: boolean,
+  getReplacement?: (string) => string,
+|}): {|from: string, to: string|} {
   let to;
 
   let orig = URL.parse(dependency.specifier);
@@ -223,11 +208,8 @@ export function getURLReplacement({
 function performReplacement(
   replacements: ReplacementMap,
   contents: string,
-  map?: SourceMap | null,
-): {
-  readonly contents: string;
-  readonly map: SourceMap | null | undefined;
-} {
+  map?: ?SourceMap,
+): {|+contents: string, +map: ?SourceMap|} {
   let finalContents = contents;
 
   if (getFeatureFlag('inlineStringReplacementPerf')) {

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

@@ -1,3 +1,4 @@
+// @flow strict-local
 import ThrowableDiagnostic, {
   generateJSONCodeHighlights,
   escapeMarkdown,
@@ -18,107 +19,105 @@ 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 | 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 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 SchemaError =
-  | {
-      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>;
-    };
+  | {|
+      type: 'type',
+      expectedTypes: Array<string>,
+      dataType: ?'key' | 'value',
 
-function validateSchema(
-  schema: SchemaEntity,
-  data: unknown,
-): Array<SchemaError> {
+      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>,
+    |};
+
+function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
   function walk(
-    // @ts-expect-error TS7006
     schemaAncestors,
-    dataNode: unknown,
-    dataPath: string,
-  ): SchemaError | null | undefined | Array<SchemaError> {
+    dataNode,
+    dataPath,
+  ): ?SchemaError | Array<SchemaError> {
     let [schemaNode] = schemaAncestors;
 
     if (schemaNode.type) {
@@ -137,26 +136,23 @@ function validateSchema(
           case 'array': {
             if (schemaNode.items) {
               let results: Array<SchemaError | Array<SchemaError>> = [];
-              // @ts-expect-error TS18046
+              // $FlowFixMe type was already checked
               for (let i = 0; i < dataNode.length; i++) {
                 let result = walk(
                   [schemaNode.items].concat(schemaAncestors),
-                  // @ts-expect-error TS18046
+                  // $FlowFixMe type was already checked
                   dataNode[i],
                   dataPath + '/' + i,
                 );
                 if (result) results.push(result);
               }
               if (results.length)
-                return results.reduce<Array<any>>(
-                  (acc, v) => acc.concat(v),
-                  [],
-                );
+                return results.reduce((acc, v) => acc.concat(v), []);
             }
             break;
           }
           case 'string': {
-            // @ts-expect-error TS2322
+            // $FlowFixMe type was already checked
             let value: string = dataNode;
             if (schemaNode.enum) {
               if (!schemaNode.enum.includes(value)) {
@@ -185,7 +181,7 @@ function validateSchema(
             break;
           }
           case 'number': {
-            // @ts-expect-error TS2322
+            // $FlowFixMe type was already checked
             let value: number = dataNode;
             if (schemaNode.enum) {
               if (!schemaNode.enum.includes(value)) {
@@ -205,15 +201,13 @@ function validateSchema(
             let results: Array<Array<SchemaError> | SchemaError> = [];
             let invalidProps;
             if (schemaNode.__forbiddenProperties) {
-              // @ts-expect-error TS2769
+              // $FlowFixMe type was already checked
               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',
@@ -223,20 +217,18 @@ function validateSchema(
                       expectedProps: Object.keys(schemaNode.properties),
                       actualProps: keys,
                       ancestors: schemaAncestors,
-                    }) as SchemaError,
+                    }: SchemaError),
                 ),
               );
             }
             if (schemaNode.required) {
-              // @ts-expect-error TS2769
+              // $FlowFixMe type was already checked
               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',
@@ -246,13 +238,13 @@ function validateSchema(
                       expectedProps: schemaNode.required,
                       actualProps: keys,
                       ancestors: schemaAncestors,
-                    }) as SchemaError,
+                    }: SchemaError),
                 ),
               );
             }
             if (schemaNode.properties) {
               let {additionalProperties = true} = schemaNode;
-              // @ts-expect-error TS2407
+              // $FlowFixMe type was already checked
               for (let k in dataNode) {
                 if (invalidProps && invalidProps.includes(k)) {
                   // Don't check type on forbidden props
@@ -260,7 +252,7 @@ function validateSchema(
                 } else if (k in schemaNode.properties) {
                   let result = walk(
                     [schemaNode.properties[k]].concat(schemaAncestors),
-                    // @ts-expect-error TS18046
+                    // $FlowFixMe type was already checked
                     dataNode[k],
                     dataPath + '/' + encodeJSONKeyComponent(k),
                   );
@@ -274,8 +266,10 @@ function validateSchema(
                         dataPath: dataPath + '/' + encodeJSONKeyComponent(k),
                         expectedValues: Object.keys(
                           schemaNode.properties,
-                          // @ts-expect-error TS18046
-                        ).filter((p) => !(p in dataNode)),
+                        ).filter(
+                          // $FlowFixMe type was already checked
+                          (p) => !(p in dataNode),
+                        ),
                         actualValue: k,
                         ancestors: schemaAncestors,
                         prettyType: schemaNode.__type,
@@ -284,7 +278,7 @@ function validateSchema(
                   } else {
                     let result = walk(
                       [additionalProperties].concat(schemaAncestors),
-                      // @ts-expect-error TS18046
+                      // $FlowFixMe type was already checked
                       dataNode[k],
                       dataPath + '/' + encodeJSONKeyComponent(k),
                     );
@@ -294,7 +288,7 @@ function validateSchema(
               }
             }
             if (results.length)
-              return results.reduce<Array<any>>((acc, v) => acc.concat(v), []);
+              return results.reduce((acc, v) => acc.concat(v), []);
             break;
           }
           case 'boolean':
@@ -334,10 +328,10 @@ function validateSchema(
               ? 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];
@@ -348,7 +342,6 @@ function validateSchema(
           dataNode,
           dataPath,
         );
-        // @ts-expect-error TS2339
         if (!result || result.length == 0) {
           return {
             type: 'other',
@@ -378,38 +371,33 @@ export function fuzzySearch(
     .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]: [any, any]) => d * 2 < actualValue.length,
+      ([, d]) => d * 2 < actualValue.length,
     );
-  // @ts-expect-error TS2345
-  result.sort(([, a]: [any, any], [, b]: [any, any]) => a - b);
-  // @ts-expect-error TS2345
-  return result.map(([v]: [any]) => v);
+  result.sort(([, a], [, b]) => a - b);
+  return result.map(([v]) => v);
 }
 
 validateSchema.diagnostic = function (
   schema: SchemaEntity,
-  data: (
-    | {
-        source?: string | null | undefined;
-        data?: unknown;
-      }
-    | {
-        source: string;
-        map: {
-          data: unknown;
-          pointers: {
-            [key: string]: Mapping;
-          };
-        };
-      }
-  ) & {
-    filePath?: string | null | undefined;
-    prependKey?: string | null | undefined;
-  },
+  data: {|
+    ...
+      | {|
+          source?: ?string,
+          data?: mixed,
+        |}
+      | {|
+          source: string,
+          map: {|
+            data: mixed,
+            pointers: {|[key: string]: Mapping|},
+          |},
+        |},
+    filePath?: ?string,
+    prependKey?: ?string,
+  |},
   origin: string,
   message: string,
-): undefined {
+): void {
   if (
     'source' in data &&
     'data' in data &&
@@ -420,12 +408,10 @@ validateSchema.diagnostic = function (
       'At least one of data.source and data.data must be defined!',
     );
   }
-  // @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));
+    ? data.map.data
+    : // $FlowFixMe we can assume it's a JSON object
+      data.data ?? JSON.parse(data.source);
   let errors = validateSchema(schema, object);
   if (errors.length) {
     let keys = errors.map((e) => {
@@ -483,13 +469,11 @@ 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;
     } else {
-      // @ts-expect-error TS2339
+      // $FlowFixMe we can assume that data is valid JSON
       map = data.source ?? JSON.stringify(nullthrows(data.data), 0, '\t');
       code = map;
     }
@@ -513,7 +497,6 @@ validateSchema.diagnostic = function (
       diagnostic: {
         message: message,
         origin,
-        // @ts-expect-error TS2322
         codeFrames,
       },
     });

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

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

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

@@ -1,3 +1,4 @@
+// @flow
 import type {SourceLocation} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
 import SourceMap from '@parcel/source-map';
@@ -20,7 +21,7 @@ export const SOURCEMAP_EXTENSIONS: Set<string> = new Set<string>([
 
 export function matchSourceMappingURL(
   contents: string,
-): RegExpMatchArray | null {
+): null | RegExp$matchResult {
   return contents.match(SOURCEMAP_RE);
 }
 
@@ -28,15 +29,7 @@ export async function loadSourceMapUrl(
   fs: FileSystem,
   filename: string,
   contents: string,
-): Promise<
-  | {
-      filename: string;
-      map: any;
-      url: string;
-    }
-  | null
-  | undefined
-> {
+): Promise<?{|filename: string, map: any, url: string|}> {
   let match = matchSourceMappingURL(contents);
   if (match) {
     let url = match[1].trim();
@@ -67,11 +60,8 @@ export async function loadSourceMapUrl(
 export async function loadSourceMap(
   filename: string,
   contents: string,
-  options: {
-    fs: FileSystem;
-    projectRoot: string;
-  },
-): Promise<SourceMap | null | undefined> {
+  options: {fs: FileSystem, projectRoot: string, ...},
+): Promise<?SourceMap> {
   let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
   if (foundMap) {
     let mapSourceRoot = path.dirname(filename);
@@ -85,7 +75,7 @@ export async function loadSourceMap(
     let sourcemapInstance = new SourceMap(options.projectRoot);
     sourcemapInstance.addVLQMap({
       ...foundMap.map,
-      sources: foundMap.map.sources.map((s: string) => {
+      sources: foundMap.map.sources.map((s) => {
         return path.join(mapSourceRoot, s);
       }),
     });