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

package/lib/{index.d.ts → diagnostic.d.ts}

@@ -1,10 +1,10 @@
-import * as jsonSourcemap from '@mischnic/json-sourcemap';
+import 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;
+    readonly line: number;
+    readonly column: number;
 };
-export type DiagnosticSeverity = 'error' | 'warn' | 'info';
+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
@@ -38,9 +38,7 @@ export type DiagnosticCodeFrame = {
     codeHighlights: Array<DiagnosticCodeHighlight>;
 };
 /** A JSON object (as in "map") */
-export type JSONObject = {
-    [key: string]: any;
-};
+type JSONObject = Record<string, any>;
 /**
  * A style agnostic way of emitting errors, warnings and info.
  * Reporters are responsible for rendering the message, codeframes, hints, ...
@@ -55,7 +53,7 @@ export type Diagnostic = {
     /** Name of the error (optional) */
     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> | null | undefined;
     /** An optional list of strings that suggest ways to resolve this issue */
     hints?: Array<string>;
     /** @private */
@@ -73,7 +71,7 @@ export interface PrintableError extends Error {
     loc?: {
         column: number;
         line: number;
-    };
+    } | null | undefined;
     source?: string;
 }
 export type DiagnosticWithoutOrigin = Diagnostic & {
@@ -85,10 +83,10 @@ export type Diagnostifiable = Diagnostic | Array<Diagnostic> | ThrowableDiagnost
 export declare function anyToDiagnostic(input: Diagnostifiable): Array<Diagnostic>;
 /** Normalize the given error into a diagnostic. */
 export declare function errorToDiagnostic(error: ThrowableDiagnostic | PrintableError | string, defaultValues?: {
-    origin?: string;
-    filePath?: string;
+    origin?: string | null | undefined;
+    filePath?: string | null | undefined;
 }): Array<Diagnostic>;
-export type ThrowableDiagnosticOpts = {
+type ThrowableDiagnosticOpts = {
     diagnostic: Diagnostic | Array<Diagnostic>;
 };
 /**
@@ -108,55 +106,53 @@ export default class ThrowableDiagnostic extends Error {
  * <code>type</code> signifies whether the key of the value in a JSON object should be highlighted.
  */
 export declare function generateJSONCodeHighlights(data: string | {
-    data: any;
-    pointers: {
-        [key: string]: jsonSourcemap.Mapping;
-    };
+    data: unknown;
+    pointers: Record<string, Mapping>;
 }, ids: Array<{
     key: string;
-    type?: 'key' | 'value';
+    type?: ("key" | null | undefined) | "value";
     message?: string;
 }>): Array<DiagnosticCodeHighlight>;
 /**
  * Converts entries in <a href="https://github.com/mischnic/json-sourcemap">@mischnic/json-sourcemap</a>'s
  * <code>result.pointers</code> array.
  */
-export declare function getJSONHighlightLocation(pos: jsonSourcemap.Mapping, type?: 'key' | 'value'): {
+export declare function getJSONHighlightLocation(pos: Mapping, type?: ("key" | null | undefined) | "value"): {
     start: DiagnosticHighlightLocation;
     end: DiagnosticHighlightLocation;
 };
 /** Result is 1-based, but end is exclusive */
-export declare function getJSONSourceLocation(pos: jsonSourcemap.Mapping, type?: 'key' | 'value'): {
+export declare function getJSONSourceLocation(pos: Mapping, type?: ("key" | null | undefined) | "value"): {
     start: {
-        line: number;
-        column: number;
+        readonly line: number;
+        readonly column: number;
     };
     end: {
-        line: number;
-        column: number;
+        readonly line: number;
+        readonly column: number;
     };
 };
 export declare function convertSourceLocationToHighlight<Location extends {
     /** 1-based, inclusive */
-    start: {
-        line: number;
-        column: number;
+    readonly start: {
+        readonly line: number;
+        readonly column: number;
     };
     /** 1-based, exclusive */
-    end: {
-        line: number;
-        column: number;
+    readonly end: {
+        readonly line: number;
+        readonly column: number;
     };
 }>({ start, end }: Location, message?: string): DiagnosticCodeHighlight;
 /** Sanitizes object keys before using them as <code>key</code> in generateJSONCodeHighlights */
 export declare function encodeJSONKeyComponent(component: string): string;
 export declare function escapeMarkdown(s: string): string;
-export type TemplateInput = any;
-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;
+type TemplateInput = any;
+export declare function md(strings: Array<string>, ...params: Array<TemplateInput>): string;
+export declare namespace md {
+    var bold: (s: TemplateInput) => TemplateInput;
+    var italic: (s: TemplateInput) => TemplateInput;
+    var underline: (s: TemplateInput) => TemplateInput;
+    var strikethrough: (s: TemplateInput) => TemplateInput;
 }
-export declare const md: MdFunction;
+export {};

package/lib/diagnostic.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.anyToDiagnostic = anyToDiagnostic;
+exports.convertSourceLocationToHighlight = convertSourceLocationToHighlight;
+exports.default = void 0;
+exports.encodeJSONKeyComponent = encodeJSONKeyComponent;
+exports.errorToDiagnostic = errorToDiagnostic;
+exports.escapeMarkdown = escapeMarkdown;
+exports.generateJSONCodeHighlights = generateJSONCodeHighlights;
+exports.getJSONHighlightLocation = getJSONHighlightLocation;
+exports.getJSONSourceLocation = getJSONSourceLocation;
+exports.md = md;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _jsonSourcemap() {
+  const data = require("@mischnic/json-sourcemap");
+  _jsonSourcemap = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/** These positions are 1-based (so <code>1</code> is the first line/column) */
+/**
+ * Note: A tab character is always counted as a single character
+ * This is to prevent any mismatch of highlighting across machines
+ */
+/**
+ * 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.
+ */
+/** A JSON object (as in "map") */
+/**
+ * A style agnostic way of emitting errors, warnings and info.
+ * Reporters are responsible for rendering the message, codeframes, hints, ...
+ */
+// This type should represent all error formats Atlaspack can encounter...
+/** Something that can be turned into a diagnostic. */
+/** Normalize the given value into a diagnostic. */
+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);
+  }
+}
+
+/** Normalize the given error into a diagnostic. */
+function errorToDiagnostic(error, defaultValues) {
+  let codeFrames = undefined;
+  if (typeof error === 'string') {
+    return [{
+      origin: (defaultValues === null || defaultValues === void 0 ? void 0 : defaultValues.origin) ?? 'Error',
+      message: escapeMarkdown(error)
+    }];
+  }
+  if (error instanceof ThrowableDiagnostic) {
+    return error.diagnostics.map(d => {
+      return {
+        ...d,
+        origin: d.origin ?? (defaultValues === null || defaultValues === void 0 ? void 0 : defaultValues.origin) ?? 'unknown'
+      };
+    });
+  }
+  if (error.loc && error.source != null) {
+    codeFrames = [{
+      filePath: error.filePath ?? error.fileName ?? (defaultValues === null || defaultValues === void 0 ? void 0 : 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 === null || defaultValues === void 0 ? void 0 : defaultValues.origin) ?? 'Error',
+    message: escapeMarkdown(error.message),
+    name: error.name,
+    stack: codeFrames == null ? error.highlightedCodeFrame ?? error.codeFrame ?? error.stack : undefined,
+    codeFrames
+  }];
+}
+/**
+ * An error wrapper around a diagnostic that can be <code>throw</code>n (e.g. to signal a
+ * build error).
+ */
+class ThrowableDiagnostic extends Error {
+  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;
+  }
+}
+
+/**
+ * Turns a list of positions in a JSON5 file with messages into a list of diagnostics.
+ * Uses <a href="https://github.com/mischnic/json-sourcemap">@mischnic/json-sourcemap</a>.
+ *
+ * @param code the JSON code
+ * @param ids A list of JSON keypaths (<code>key: "/some/parent/child"</code>) with corresponding messages, \
+ * <code>type</code> signifies whether the key of the value in a JSON object should be highlighted.
+ */
+exports.default = ThrowableDiagnostic;
+function generateJSONCodeHighlights(data, ids) {
+  let map = typeof data == 'string' ? (0, _jsonSourcemap().parse)(data, undefined, {
+    dialect: 'JSON5',
+    tabWidth: 1
+  }) : data;
+  return ids.map(({
+    key,
+    type,
+    message
+  }) => {
+    let pos = (0, _nullthrows().default)(map.pointers[key]);
+    return {
+      ...getJSONHighlightLocation(pos, type),
+      message
+    };
+  });
+}
+
+/**
+ * Converts entries in <a href="https://github.com/mischnic/json-sourcemap">@mischnic/json-sourcemap</a>'s
+ * <code>result.pointers</code> array.
+ */
+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, _assert().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
+      }
+    };
+  }
+}
+
+/** Result is 1-based, but end is exclusive */
+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
+    }
+  };
+}
+
+/** Sanitizes object keys before using them as <code>key</code> in generateJSONCodeHighlights */
+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();
+function md(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++) {
+        var _param$j;
+        result.push(((_param$j = param[j]) === null || _param$j === void 0 ? void 0 : _param$j[mdVerbatim]) ?? escapeMarkdown(`${param[j]}`));
+        if (j < param.length - 1) {
+          result.push(', ');
+        }
+      }
+    } else {
+      result.push((param === null || param === void 0 ? void 0 : 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}`) + '~~'
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/diagnostic",
-  "version": "2.14.2-typescript-d6e6d169c.0",
+  "version": "2.14.2-typescript-e769947a5.0",
   "description": "Types and utilities for printing source-code located errors, warning and information messages.",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,30 +10,20 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "exports": {
-    ".": {
-      "atlaspack::sources": "./src/index.mts",
-      "types": [
-        "./lib/index.d.ts",
-        "./src/index.mts"
-      ],
-      "import": "./lib/index.mjs",
-      "require": "./lib/index.js",
-      "default": "./lib/index.js"
-    },
-    "./*": "./*"
-  },
+  "main": "lib/diagnostic.js",
+  "source": "src/diagnostic.js",
+  "types": "lib/diagnostic.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
-    "build-tsc": "node ../../../scripts/build-tsc.mjs"
+    "build-ts": "flow-to-ts src/*.js --write && tsc --emitDeclarationOnly --declaration --esModuleInterop src/*.ts && mkdir -p lib && mv src/*.d.ts lib/. && rm src/*.ts",
+    "check-ts": "tsc --noEmit lib/diagnostic.d.ts"
   },
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "d6e6d169cb16a0bbc98d7743646a7097b82c7fe2"
+  "type": "commonjs",
+  "gitHead": "e769947a5b0c22d9477211ac1ce6614e6bf9def3"
 }