@atlaspack/diagnostic 2.14.2-typescript-e769947a5.0 → 2.14.2-typescript-6de04fbae.0

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

@@ -1,10 +1,10 @@
-import type { Mapping } from "@mischnic/json-sourcemap";
+import * as jsonSourcemap from '@mischnic/json-sourcemap';
 /** These positions are 1-based (so <code>1</code> is the first line/column) */
 export type DiagnosticHighlightLocation = {
-    readonly line: number;
-    readonly column: number;
+    line: number;
+    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,7 +38,9 @@ export type DiagnosticCodeFrame = {
     codeHighlights: Array<DiagnosticCodeHighlight>;
 };
 /** A JSON object (as in "map") */
-type JSONObject = Record<string, any>;
+type JSONObject = {
+    [key: string]: any;
+};
 /**
  * A style agnostic way of emitting errors, warnings and info.
  * Reporters are responsible for rendering the message, codeframes, hints, ...
@@ -53,7 +55,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> | null | undefined;
+    codeFrames?: Array<DiagnosticCodeFrame>;
     /** An optional list of strings that suggest ways to resolve this issue */
     hints?: Array<string>;
     /** @private */
@@ -71,7 +73,7 @@ export interface PrintableError extends Error {
     loc?: {
         column: number;
         line: number;
-    } | null | undefined;
+    };
     source?: string;
 }
 export type DiagnosticWithoutOrigin = Diagnostic & {
@@ -83,10 +85,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 | null | undefined;
-    filePath?: string | null | undefined;
+    origin?: string;
+    filePath?: string;
 }): Array<Diagnostic>;
-type ThrowableDiagnosticOpts = {
+export type ThrowableDiagnosticOpts = {
     diagnostic: Diagnostic | Array<Diagnostic>;
 };
 /**
@@ -106,53 +108,56 @@ 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: unknown;
-    pointers: Record<string, Mapping>;
+    data: any;
+    pointers: {
+        [key: string]: jsonSourcemap.Mapping;
+    };
 }, ids: Array<{
     key: string;
-    type?: ("key" | null | undefined) | "value";
+    type?: 'key' | '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: Mapping, type?: ("key" | null | undefined) | "value"): {
+export declare function getJSONHighlightLocation(pos: jsonSourcemap.Mapping, type?: 'key' | 'value'): {
     start: DiagnosticHighlightLocation;
     end: DiagnosticHighlightLocation;
 };
 /** Result is 1-based, but end is exclusive */
-export declare function getJSONSourceLocation(pos: Mapping, type?: ("key" | null | undefined) | "value"): {
+export declare function getJSONSourceLocation(pos: jsonSourcemap.Mapping, type?: 'key' | 'value'): {
     start: {
-        readonly line: number;
-        readonly column: number;
+        line: number;
+        column: number;
     };
     end: {
-        readonly line: number;
-        readonly column: number;
+        line: number;
+        column: number;
     };
 };
 export declare function convertSourceLocationToHighlight<Location extends {
     /** 1-based, inclusive */
-    readonly start: {
-        readonly line: number;
-        readonly column: number;
+    start: {
+        line: number;
+        column: number;
     };
     /** 1-based, exclusive */
-    readonly end: {
-        readonly line: number;
-        readonly column: number;
+    end: {
+        line: number;
+        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;
-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 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;
 }
+export declare const md: MdFunction;
 export {};

package/lib/index.js

@@ -0,0 +1,310 @@
+"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}`) + '~~'
+    };
+};