@atlaspack/diagnostic 2.14.2-typescript-d6e6d169c.0 → 2.14.2-typescript-e769947a5.0

package/src/{index.mts → diagnostic.js}

@@ -1,12 +1,14 @@
-import assert from 'node:assert';
+// @flow strict-local
+
+import invariant from 'assert';
 import nullthrows from 'nullthrows';
-import * as jsonSourcemap from '@mischnic/json-sourcemap';
+import {parse, type Mapping} from '@mischnic/json-sourcemap';
 
 /** These positions are 1-based (so <code>1</code> is the first line/column) */
-export type DiagnosticHighlightLocation = {
-  line: number;
-  column: number;
-};
+export type DiagnosticHighlightLocation = {|
+  +line: number,
+  +column: number,
+|};
 
 export type DiagnosticSeverity = 'error' | 'warn' | 'info';
 
@@ -14,21 +16,21 @@ export type DiagnosticSeverity = 'error' | 'warn' | 'info';
  * Note: A tab character is always counted as a single character
  * This is to prevent any mismatch of highlighting across machines
  */
-export type DiagnosticCodeHighlight = {
+export type DiagnosticCodeHighlight = {|
   /** Location of the first character that should get highlighted for this highlight. */
-  start: DiagnosticHighlightLocation;
+  start: DiagnosticHighlightLocation,
   /** Location of the last character that should get highlighted for this highlight. */
-  end: DiagnosticHighlightLocation;
+  end: DiagnosticHighlightLocation,
   /** A message that should be displayed at this location in the code (optional). */
-  message?: string;
-};
+  message?: string,
+|};
 
 /**
  * Describes how to format a code frame.
  * A code frame is a visualization of a piece of code with a certain amount of
  * code highlights that point to certain chunk(s) inside the code.
  */
-export type DiagnosticCodeFrame = {
+export type DiagnosticCodeFrame = {|
   /**
    * The contents of the source file.
    *
@@ -36,50 +38,50 @@ export type DiagnosticCodeFrame = {
    * the asset's current code could be different from the input contents.
    *
    */
-  code?: string;
+  code?: string,
   /** Path to the file this code frame is about (optional, absolute or relative to the project root) */
-  filePath?: string;
+  filePath?: string,
   /** Language of the file this code frame is about (optional) */
-  language?: string;
-  codeHighlights: Array<DiagnosticCodeHighlight>;
-};
+  language?: string,
+  codeHighlights: Array<DiagnosticCodeHighlight>,
+|};
 
 /** A JSON object (as in "map") */
-export type JSONObject = {
+type JSONObject = {
   // $FlowFixMe
-  [key: string]: any;
+  [key: string]: any,
 };
 
 /**
  * A style agnostic way of emitting errors, warnings and info.
  * Reporters are responsible for rendering the message, codeframes, hints, ...
  */
-export type Diagnostic = {
+export type Diagnostic = {|
   /** This is the message you want to log. */
-  message: string;
+  message: string,
   /** Name of plugin or file that threw this error */
-  origin?: string;
+  origin?: string,
 
   /** A stacktrace of the error (optional) */
-  stack?: string;
+  stack?: string,
   /** Name of the error (optional) */
-  name?: string;
+  name?: string,
 
   /** A code frame points to a certain location(s) in the file this diagnostic is linked to (optional) */
-  codeFrames?: Array<DiagnosticCodeFrame>;
+  codeFrames?: ?Array<DiagnosticCodeFrame>,
 
   /** An optional list of strings that suggest ways to resolve this issue */
-  hints?: Array<string>;
+  hints?: Array<string>,
 
   /** @private */
-  skipFormatting?: boolean;
+  skipFormatting?: boolean,
 
   /** A URL to documentation to learn more about the diagnostic. */
-  documentationURL?: string;
+  documentationURL?: string,
 
   /** Diagnostic specific metadata (optional) */
-  meta?: JSONObject;
-};
+  meta?: JSONObject,
+|};
 
 // This type should represent all error formats Atlaspack can encounter...
 export interface PrintableError extends Error {
@@ -87,16 +89,18 @@ export interface PrintableError extends Error {
   filePath?: string;
   codeFrame?: string;
   highlightedCodeFrame?: string;
-  loc?: {
-    column: number;
-    line: number;
+  loc?: ?{
+    column: number,
+    line: number,
+    ...
   };
   source?: string;
 }
 
-export type DiagnosticWithoutOrigin = Diagnostic & {
-  origin?: string;
-};
+export type DiagnosticWithoutOrigin = {|
+  ...Diagnostic,
+  origin?: string,
+|};
 
 /** Something that can be turned into a diagnostic. */
 export type Diagnostifiable =
@@ -127,12 +131,12 @@ export function anyToDiagnostic(input: Diagnostifiable): Array<Diagnostic> {
 /** Normalize the given error into a diagnostic. */
 export function errorToDiagnostic(
   error: ThrowableDiagnostic | PrintableError | string,
-  defaultValues?: {
-    origin?: string;
-    filePath?: string;
-  },
+  defaultValues?: {|
+    origin?: ?string,
+    filePath?: ?string,
+  |},
 ): Array<Diagnostic> {
-  let codeFrames: Array<DiagnosticCodeFrame> | undefined = undefined;
+  let codeFrames: ?Array<DiagnosticCodeFrame> = undefined;
 
   if (typeof error === 'string') {
     return [
@@ -191,8 +195,9 @@ export function errorToDiagnostic(
   ];
 }
 
-export type ThrowableDiagnosticOpts = {
-  diagnostic: Diagnostic | Array<Diagnostic>;
+type ThrowableDiagnosticOpts = {
+  diagnostic: Diagnostic | Array<Diagnostic>,
+  ...
 };
 
 /**
@@ -229,18 +234,18 @@ export default class ThrowableDiagnostic extends Error {
 export function generateJSONCodeHighlights(
   data:
     | string
-    | {
-        data: any;
-        pointers: {[key: string]: jsonSourcemap.Mapping};
-      },
-  ids: Array<{key: string; type?: 'key' | 'value'; message?: string}>,
+    | {|
+        data: mixed,
+        pointers: {|[key: string]: Mapping|},
+      |},
+  ids: Array<{|key: string, type?: ?'key' | 'value', message?: string|}>,
 ): Array<DiagnosticCodeHighlight> {
   let map =
     typeof data == 'string'
-      ? jsonSourcemap.default.parse(data, undefined, {dialect: 'JSON5', tabWidth: 1})
+      ? parse(data, undefined, {dialect: 'JSON5', tabWidth: 1})
       : data;
   return ids.map(({key, type, message}) => {
-    let pos = nullthrows.default(map.pointers[key]);
+    let pos = nullthrows(map.pointers[key]);
     return {
       ...getJSONHighlightLocation(pos, type),
       message,
@@ -253,12 +258,12 @@ export function generateJSONCodeHighlights(
  * <code>result.pointers</code> array.
  */
 export function getJSONHighlightLocation(
-  pos: jsonSourcemap.Mapping,
-  type?: 'key' | 'value',
-): {
-  start: DiagnosticHighlightLocation;
-  end: DiagnosticHighlightLocation;
-} {
+  pos: Mapping,
+  type?: ?'key' | 'value',
+): {|
+  start: DiagnosticHighlightLocation,
+  end: DiagnosticHighlightLocation,
+|} {
   let key = 'key' in pos ? pos.key : undefined;
   let keyEnd = 'keyEnd' in pos ? pos.keyEnd : undefined;
   if (!type && key && pos.value) {
@@ -268,7 +273,7 @@ export function getJSONHighlightLocation(
       end: {line: pos.valueEnd.line + 1, column: pos.valueEnd.column},
     };
   } else if (type == 'key' || !pos.value) {
-    assert(key && keyEnd);
+    invariant(key && keyEnd);
     return {
       start: {line: key.line + 1, column: key.column + 1},
       end: {line: keyEnd.line + 1, column: keyEnd.column},
@@ -283,34 +288,35 @@ export function getJSONHighlightLocation(
 
 /** Result is 1-based, but end is exclusive */
 export function getJSONSourceLocation(
-  pos: jsonSourcemap.Mapping,
-  type?: 'key' | 'value',
-): {
-  start: {
-    line: number;
-    column: number;
-  };
-  end: {
-    line: number;
-    column: number;
-  };
-} {
+  pos: Mapping,
+  type?: ?'key' | 'value',
+): {|
+  start: {|
+    +line: number,
+    +column: number,
+  |},
+  end: {|
+    +line: number,
+    +column: number,
+  |},
+|} {
   let v = getJSONHighlightLocation(pos, type);
   return {start: v.start, end: {line: v.end.line, column: v.end.column + 1}};
 }
 
 export function convertSourceLocationToHighlight<
-  Location extends {
+  Location: {
     /** 1-based, inclusive */
-    start: {
-      line: number;
-      column: number;
-    };
+    +start: {|
+      +line: number,
+      +column: number,
+    |},
     /** 1-based, exclusive */
-    end: {
-      line: number;
-      column: number;
-    };
+    +end: {|
+      +line: number,
+      +column: number,
+    |},
+    ...
   },
 >({start, end}: Location, message?: string): DiagnosticCodeHighlight {
   return {message, start, end: {line: end.line, column: end.column - 1}};
@@ -332,20 +338,11 @@ export function escapeMarkdown(s: string): string {
   return result;
 }
 
-export type TemplateInput = any;
+type TemplateInput = $FlowFixMe;
 
 const mdVerbatim = Symbol();
-
-export interface MdFunction {
-  (strings: TemplateStringsArray, ...params: Array<TemplateInput>): string;
-  bold: (s: TemplateInput) => TemplateInput
-  italic: (s: TemplateInput) => TemplateInput
-  underline: (s: TemplateInput) => TemplateInput
-  strikethrough: (s: TemplateInput) => TemplateInput
-}
-
-export const md: MdFunction = function (
-  strings: TemplateStringsArray,
+export function md(
+  strings: Array<string>,
   ...params: Array<TemplateInput>
 ): string {
   let result = [];
@@ -365,7 +362,7 @@ export const md: MdFunction = function (
     }
   }
   return result.join('') + strings[strings.length - 1];
-};
+}
 
 md.bold = function (s: TemplateInput): TemplateInput {
   // $FlowFixMe[invalid-computed-prop]

package/test/{JSONCodeHighlights.test.mts → JSONCodeHighlights.test.js}

@@ -1,6 +1,7 @@
+// @flow strict-local
 import assert from 'assert';
 
-import {generateJSONCodeHighlights} from '../src/index.mts';
+import {generateJSONCodeHighlights} from '../src/diagnostic';
 
 describe('generateJSONCodeHighlights', () => {
   it('returns an escaped string 01', () => {

package/test/{markdown.test.mts → markdown.test.js}

@@ -1,6 +1,7 @@
+// @flow
 import assert from 'assert';
 
-import {escapeMarkdown, md} from '../src/index.mts';
+import {escapeMarkdown, md} from '../src/diagnostic';
 
 describe('escapeMarkdown', () => {
   it('returns an escaped string 01', () => {

package/lib/index.js

@@ -1,325 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-function _export(target, all) {
-  for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name],
-    });
-}
-_export(exports, {
-  anyToDiagnostic: function () {
-    return anyToDiagnostic;
-  },
-  convertSourceLocationToHighlight: function () {
-    return convertSourceLocationToHighlight;
-  },
-  /**
-   * An error wrapper around a diagnostic that can be <code>throw</code>n (e.g. to signal a
-   * build error).
-   */ default: function () {
-    return ThrowableDiagnostic;
-  },
-  encodeJSONKeyComponent: function () {
-    return encodeJSONKeyComponent;
-  },
-  errorToDiagnostic: function () {
-    return errorToDiagnostic;
-  },
-  escapeMarkdown: function () {
-    return escapeMarkdown;
-  },
-  generateJSONCodeHighlights: function () {
-    return generateJSONCodeHighlights;
-  },
-  getJSONHighlightLocation: function () {
-    return getJSONHighlightLocation;
-  },
-  getJSONSourceLocation: function () {
-    return getJSONSourceLocation;
-  },
-  md: function () {
-    return md;
-  },
-});
-const _nodeassert = /*#__PURE__*/ _interop_require_default(
-  require('node:assert'),
-);
-const _nullthrows = /*#__PURE__*/ _interop_require_default(
-  require('nullthrows'),
-);
-const _jsonsourcemap = /*#__PURE__*/ _interop_require_wildcard(
-  require('@mischnic/json-sourcemap'),
-);
-function _interop_require_default(obj) {
-  return obj && obj.__esModule
-    ? obj
-    : {
-        default: obj,
-      };
-}
-function _getRequireWildcardCache(nodeInterop) {
-  if (typeof WeakMap !== 'function') return null;
-  var cacheBabelInterop = new WeakMap();
-  var cacheNodeInterop = new WeakMap();
-  return (_getRequireWildcardCache = function (nodeInterop) {
-    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-  })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-  if (!nodeInterop && obj && obj.__esModule) {
-    return obj;
-  }
-  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
-    return {
-      default: obj,
-    };
-  }
-  var cache = _getRequireWildcardCache(nodeInterop);
-  if (cache && cache.has(obj)) {
-    return cache.get(obj);
-  }
-  var newObj = {
-    __proto__: null,
-  };
-  var hasPropertyDescriptor =
-    Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var key in obj) {
-    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
-      var desc = hasPropertyDescriptor
-        ? Object.getOwnPropertyDescriptor(obj, key)
-        : null;
-      if (desc && (desc.get || desc.set)) {
-        Object.defineProperty(newObj, key, desc);
-      } else {
-        newObj[key] = obj[key];
-      }
-    }
-  }
-  newObj.default = obj;
-  if (cache) {
-    cache.set(obj, newObj);
-  }
-  return newObj;
-}
-function anyToDiagnostic(input) {
-  if (Array.isArray(input)) {
-    return input.flatMap((e) => anyToDiagnostic(e));
-  } else if (input instanceof ThrowableDiagnostic) {
-    return input.diagnostics;
-  } else if (input instanceof Error) {
-    return errorToDiagnostic(input);
-  } else if (typeof input === 'string') {
-    return [
-      {
-        message: input,
-      },
-    ];
-  } else if (typeof input === 'object') {
-    return [input];
-  } else {
-    return errorToDiagnostic(input);
-  }
-}
-function errorToDiagnostic(error, defaultValues) {
-  let codeFrames = undefined;
-  if (typeof error === 'string') {
-    return [
-      {
-        origin: defaultValues?.origin ?? 'Error',
-        message: escapeMarkdown(error),
-      },
-    ];
-  }
-  if (error instanceof ThrowableDiagnostic) {
-    return error.diagnostics.map((d) => {
-      return {
-        ...d,
-        origin: d.origin ?? defaultValues?.origin ?? 'unknown',
-      };
-    });
-  }
-  if (error.loc && error.source != null) {
-    codeFrames = [
-      {
-        filePath:
-          error.filePath ??
-          error.fileName ??
-          defaultValues?.filePath ??
-          undefined,
-        code: error.source,
-        codeHighlights: [
-          {
-            start: {
-              line: error.loc.line,
-              column: error.loc.column,
-            },
-            end: {
-              line: error.loc.line,
-              column: error.loc.column,
-            },
-          },
-        ],
-      },
-    ];
-  }
-  return [
-    {
-      origin: defaultValues?.origin ?? 'Error',
-      message: escapeMarkdown(error.message),
-      name: error.name,
-      stack:
-        codeFrames == null
-          ? error.highlightedCodeFrame ?? error.codeFrame ?? error.stack
-          : undefined,
-      codeFrames,
-    },
-  ];
-}
-class ThrowableDiagnostic extends Error {
-  diagnostics;
-  constructor(opts) {
-    let diagnostics = Array.isArray(opts.diagnostic)
-      ? opts.diagnostic
-      : [opts.diagnostic];
-    // Construct error from diagnostics
-    super(diagnostics[0].message);
-    // @ts-ignore
-    this.stack = diagnostics[0].stack ?? super.stack;
-    // @ts-ignore
-    this.name = diagnostics[0].name ?? super.name;
-    this.diagnostics = diagnostics;
-  }
-}
-function generateJSONCodeHighlights(data, ids) {
-  let map =
-    typeof data == 'string'
-      ? _jsonsourcemap.default.parse(data, undefined, {
-          dialect: 'JSON5',
-          tabWidth: 1,
-        })
-      : data;
-  return ids.map(({key, type, message}) => {
-    let pos = _nullthrows.default.default(map.pointers[key]);
-    return {
-      ...getJSONHighlightLocation(pos, type),
-      message,
-    };
-  });
-}
-function getJSONHighlightLocation(pos, type) {
-  let key = 'key' in pos ? pos.key : undefined;
-  let keyEnd = 'keyEnd' in pos ? pos.keyEnd : undefined;
-  if (!type && key && pos.value) {
-    // key and value
-    return {
-      start: {
-        line: key.line + 1,
-        column: key.column + 1,
-      },
-      end: {
-        line: pos.valueEnd.line + 1,
-        column: pos.valueEnd.column,
-      },
-    };
-  } else if (type == 'key' || !pos.value) {
-    (0, _nodeassert.default)(key && keyEnd);
-    return {
-      start: {
-        line: key.line + 1,
-        column: key.column + 1,
-      },
-      end: {
-        line: keyEnd.line + 1,
-        column: keyEnd.column,
-      },
-    };
-  } else {
-    return {
-      start: {
-        line: pos.value.line + 1,
-        column: pos.value.column + 1,
-      },
-      end: {
-        line: pos.valueEnd.line + 1,
-        column: pos.valueEnd.column,
-      },
-    };
-  }
-}
-function getJSONSourceLocation(pos, type) {
-  let v = getJSONHighlightLocation(pos, type);
-  return {
-    start: v.start,
-    end: {
-      line: v.end.line,
-      column: v.end.column + 1,
-    },
-  };
-}
-function convertSourceLocationToHighlight({start, end}, message) {
-  return {
-    message,
-    start,
-    end: {
-      line: end.line,
-      column: end.column - 1,
-    },
-  };
-}
-function encodeJSONKeyComponent(component) {
-  return component.replace(/~/g, '~0').replace(/\//g, '~1');
-}
-const escapeCharacters = ['\\', '*', '_', '~'];
-function escapeMarkdown(s) {
-  let result = s;
-  for (const char of escapeCharacters) {
-    result = result.replace(new RegExp(`\\${char}`, 'g'), `\\${char}`);
-  }
-  return result;
-}
-const mdVerbatim = Symbol();
-const md = function (strings, ...params) {
-  let result = [];
-  for (let i = 0; i < params.length; i++) {
-    result.push(strings[i]);
-    let param = params[i];
-    if (Array.isArray(param)) {
-      for (let j = 0; j < param.length; j++) {
-        result.push(param[j]?.[mdVerbatim] ?? escapeMarkdown(`${param[j]}`));
-        if (j < param.length - 1) {
-          result.push(', ');
-        }
-      }
-    } else {
-      result.push(param?.[mdVerbatim] ?? escapeMarkdown(`${param}`));
-    }
-  }
-  return result.join('') + strings[strings.length - 1];
-};
-md.bold = function (s) {
-  // $FlowFixMe[invalid-computed-prop]
-  return {
-    [mdVerbatim]: '**' + escapeMarkdown(`${s}`) + '**',
-  };
-};
-md.italic = function (s) {
-  // $FlowFixMe[invalid-computed-prop]
-  return {
-    [mdVerbatim]: '_' + escapeMarkdown(`${s}`) + '_',
-  };
-};
-md.underline = function (s) {
-  // $FlowFixMe[invalid-computed-prop]
-  return {
-    [mdVerbatim]: '__' + escapeMarkdown(`${s}`) + '__',
-  };
-};
-md.strikethrough = function (s) {
-  // $FlowFixMe[invalid-computed-prop]
-  return {
-    [mdVerbatim]: '~~' + escapeMarkdown(`${s}`) + '~~',
-  };
-};