@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.3

package/dist/src/prettier/util/print-utils.js

@@ -0,0 +1,456 @@
+import { doc } from "prettier";
+import { isBreakParent, isFill, isHardline, isIndent, isLabel } from "./types.js";
+import { InternalScannerError } from "../../scanner-error.js";
+const { hardline, ifBreak, label, line, indent } = doc.builders;
+function getCommentString(trivia) {
+    if (!trivia.text.startsWith("//")) {
+        throw new InternalScannerError("Logic Error: Expected comment to start with // : " + JSON.stringify(trivia));
+    }
+    // Remove leading "//" from the comment text
+    return "// " + trivia.text.replace(/^\s*\/\/\s*/, "").trim();
+}
+function addTrivia(doc, trivia) {
+    let commentDoc = [];
+    if (trivia.text === "\n") {
+        commentDoc = "";
+    }
+    else {
+        commentDoc = getCommentString(trivia);
+    }
+    if (Array.isArray(doc)) {
+        doc.push(commentDoc);
+    }
+    else {
+        doc = [doc, commentDoc];
+    }
+    return doc;
+}
+/**
+ * Gets the leading trivia doc for the given node if it has any leading trivia.
+ */
+export function getLeadingTriviaDoc(node) {
+    if (!node || !node.leadingTrivia || node.leadingTrivia.length === 0) {
+        return undefined;
+    }
+    let doc = [];
+    node.leadingTrivia.forEach((trivia) => {
+        doc = addTrivia(doc, trivia);
+        doc.push(hardline);
+    });
+    return label("leadingTrivia", doc);
+}
+/**
+ * Gets the trailing trivia doc for the given node if it has any trailing trivia.
+ */
+export function getTrailingTriviaDoc(node) {
+    if (!node || !node.trailingTrivia || node.trailingTrivia.length === 0) {
+        return undefined;
+    }
+    let doc = [];
+    node.trailingTrivia.forEach((trivia) => {
+        doc = addTrivia(doc, trivia);
+        doc.push(hardline);
+    });
+    return label("trailingTrivia", doc);
+}
+/**
+ * Adds the trailing trivia doc to the given doc.
+ */
+export function addTrailingTriviaDoc(doc, trailingTriviaDoc) {
+    if (Array.isArray(doc)) {
+        if (doc.length === 0) {
+            doc = [trailingTriviaDoc];
+            return doc;
+        }
+        // find last element which is not a break-parent and not a hardline
+        let i = doc.length - 1;
+        while (i >= 0 && (isBreakParent(doc[i]) || isHardline(doc[i]))) {
+            i--;
+        }
+        if (i < 0) {
+            return doc;
+        }
+        const lastNonBreakParentElement = doc[i];
+        if (Array.isArray(lastNonBreakParentElement)) {
+            doc[i] = addTrailingTriviaDoc(lastNonBreakParentElement, trailingTriviaDoc);
+            return doc;
+        }
+        // element might be an indent or label
+        if (isIndent(lastNonBreakParentElement) || isLabel(lastNonBreakParentElement)) {
+            lastNonBreakParentElement.contents = addTrailingTriviaDoc(lastNonBreakParentElement.contents, trailingTriviaDoc);
+        } // element might be a fill
+        else if (isFill(lastNonBreakParentElement)) {
+            lastNonBreakParentElement.parts = addTrailingTriviaDoc(lastNonBreakParentElement.parts, trailingTriviaDoc);
+        } // otherwise we found the last element to add trivia after
+        // behavior is different if the token is a close brace
+        else if (lastNonBreakParentElement === "}") {
+            doc[i] = [lastNonBreakParentElement, ifBreak([line, ""], " "), trailingTriviaDoc];
+        }
+        else {
+            doc[i] = [lastNonBreakParentElement, ifBreak([line, "  "], " "), trailingTriviaDoc];
+        }
+        return doc;
+    }
+    if (isIndent(doc) || isLabel(doc)) {
+        doc.contents = addTrailingTriviaDoc(doc.contents, trailingTriviaDoc);
+    }
+    else if (isFill(doc)) {
+        doc.parts = addTrailingTriviaDoc(doc.parts, trailingTriviaDoc);
+    }
+    return doc;
+}
+/**
+ * Determines whether the given doc ends with a hardline, ignoring trailing break-parents.
+ */
+export function endsWithHardline(doc) {
+    if (Array.isArray(doc)) {
+        // can't end with hardline if empty array
+        if (doc.length === 0) {
+            return false;
+        }
+        // potential hardline as hardline is an array of [HardlineWithoutBreakParent, BreakParent]
+        if (isHardline(doc)) {
+            return true;
+        }
+        // find last element which is not a break-parent as we ignore trailing break-parents
+        let i = doc.length - 1;
+        while (i >= 0 && isBreakParent(doc[i])) {
+            i--;
+        }
+        if (i < 0) {
+            return false;
+        }
+        // recurse
+        return endsWithHardline(doc[i]);
+    }
+    // recurse
+    if (isIndent(doc) || isLabel(doc)) {
+        return endsWithHardline(doc.contents);
+    }
+    // recurse
+    if (isFill(doc)) {
+        return endsWithHardline(doc.parts);
+    }
+    return false;
+}
+/**
+ * Determines whether the given doc starts with a blank line i.e. ["", hardline, ...]
+ */
+export function startsWithBlankLine(doc) {
+    if (Array.isArray(doc)) {
+        // can't contain leading blankline if empty array
+        if (doc.length === 0) {
+            return false;
+        }
+        // check if the array starts with ["", hardline, ...]
+        if (doc.length >= 2) {
+            if (doc[0] === "" && isHardline(doc[1])) {
+                return true;
+            }
+        }
+        // recurse
+        return startsWithBlankLine(doc[0]);
+    }
+    // recurse
+    if (isIndent(doc) || isLabel(doc)) {
+        return startsWithBlankLine(doc.contents);
+    }
+    if (isFill(doc)) {
+        return startsWithBlankLine(doc.parts);
+    }
+    return false;
+}
+function removeLeadingBlankline(doc) {
+    if (Array.isArray(doc)) {
+        // can't contain leading blankline if empty array
+        if (doc.length === 0) {
+            return doc;
+        }
+        // check if the array starts with ["", hardline, ...]
+        if (doc.length >= 2) {
+            if (doc[0] === "" && isHardline(doc[1])) {
+                // remove the first two elements
+                doc.splice(0, 2);
+                // don't return a single item array
+                if (doc.length === 1) {
+                    return doc[0];
+                }
+                return doc;
+            }
+        }
+        // recurse
+        const firstItem = removeLeadingBlankline(doc[0]);
+        // don't leave an empty array at the start
+        if (Array.isArray(firstItem) && firstItem.length === 0) {
+            doc.splice(0, 1);
+        }
+        else {
+            doc[0] = firstItem;
+        }
+        // don't return a single item array
+        if (doc.length === 1) {
+            return doc[0];
+        }
+        return doc;
+    }
+    // recurse
+    if (isIndent(doc) || isLabel(doc)) {
+        doc.contents = removeLeadingBlankline(doc.contents);
+        if (doc.contents === "" || (Array.isArray(doc.contents) && doc.contents.length === 0)) {
+            doc = "";
+        }
+    }
+    else if (isFill(doc)) {
+        doc.parts = removeLeadingBlankline(doc.parts);
+        if (doc.parts.length === 0) {
+            doc = "";
+        }
+    }
+    return doc;
+}
+/**
+ * Removes leading blanklines i.e. ["", hardline, ...] from the given doc if they exist.
+ */
+export function removeLeadingBlanklines(doc) {
+    while (startsWithBlankLine(doc)) {
+        doc = removeLeadingBlankline(doc);
+    }
+    return doc;
+}
+/**
+ * Removes a trailing blankline i.e. [..., "", hardline] from the given doc if it exists.
+ */
+export function removeTrailingBlankline(doc) {
+    if (Array.isArray(doc)) {
+        // can't contain trailing blankline if empty array
+        if (doc.length === 0) {
+            return doc;
+        }
+        // check if the array ends with [..., "", hardline]
+        if (doc.length >= 2) {
+            if (doc[doc.length - 2] === "" && isHardline(doc[doc.length - 1])) {
+                // remove the last two elements
+                doc.splice(doc.length - 2, 2);
+                // don't return a single item array
+                if (doc.length === 1) {
+                    return doc[0];
+                }
+                return doc;
+            }
+        }
+        // recurse
+        let lastItem = doc[doc.length - 1];
+        lastItem = removeTrailingBlankline(lastItem);
+        // don't leave an empty array at the end
+        if (Array.isArray(lastItem) && lastItem.length === 0) {
+            doc.splice(doc.length - 1, 1);
+        }
+        else {
+            doc[doc.length - 1] = lastItem;
+        }
+        // don't return a single item array
+        if (doc.length === 1) {
+            return doc[0];
+        }
+        return doc;
+    }
+    // recurse
+    if (isIndent(doc) || isLabel(doc)) {
+        doc.contents = removeTrailingBlankline(doc.contents);
+        if (doc.contents === "" || (Array.isArray(doc.contents) && doc.contents.length === 0)) {
+            doc = "";
+        }
+    }
+    else if (isFill(doc)) {
+        doc.parts = removeTrailingBlankline(doc.parts);
+        if (doc.parts.length === 0) {
+            doc = "";
+        }
+    }
+    return doc;
+}
+/**
+ * Removes a trailing hardline from the given doc if it exists.
+ */
+export function removeTrailingHardline(doc) {
+    if (Array.isArray(doc)) {
+        if (doc.length === 0) {
+            return doc;
+        }
+        // array might be a hardline itself
+        if (isHardline(doc)) {
+            return "";
+        }
+        let lastElement = doc[doc.length - 1];
+        // recurse
+        lastElement = removeTrailingHardline(lastElement);
+        // don't store empty element
+        if (lastElement !== "") {
+            doc[doc.length - 1] = lastElement;
+        }
+        else {
+            doc.splice(doc.length - 1, 1);
+        }
+        // don't return a single item array
+        if (doc.length === 1) {
+            doc = doc[0];
+        }
+        // don't return an empty array
+        if (doc.length === 0) {
+            doc = "";
+        }
+        return doc;
+    }
+    // recurse
+    if (isIndent(doc) || isLabel(doc)) {
+        doc.contents = removeTrailingHardline(doc.contents);
+        if (doc.contents === "" || (Array.isArray(doc.contents) && doc.contents.length === 0)) {
+            doc = "";
+        }
+    }
+    else if (isFill(doc)) {
+        let parts = removeTrailingHardline(doc.parts);
+        if (!Array.isArray(parts)) {
+            if (parts === "") {
+                return "";
+            }
+            parts = [parts];
+        }
+        doc.parts = parts;
+        if (doc.parts.length === 0) {
+            doc = "";
+        }
+    }
+    return doc;
+}
+/**
+ * Adds a trailing hardline to the given doc if it does not already end with a hardline.
+ */
+export function addTrailingHardline(doc) {
+    if (!endsWithHardline(doc)) {
+        if (Array.isArray(doc)) {
+            doc.push(hardline);
+            return doc;
+        }
+        return [doc, hardline];
+    }
+    return doc;
+}
+/**
+ * Adds indented statement docs to the given doc,
+ * optionally with opening and closing brace punctuator docs.
+ */
+export function addIndentedStatements(doc, statementDocs, openBracePunctuatorDoc, closeBracePunctuatorDoc) {
+    let indentedDoc = [];
+    if (openBracePunctuatorDoc) {
+        // remove blankline before opening brace
+        openBracePunctuatorDoc = removeLeadingBlanklines(openBracePunctuatorDoc);
+        indentedDoc.push(openBracePunctuatorDoc);
+    }
+    // indented block should have a hardline before statements
+    if (statementDocs.length > 0) {
+        indentedDoc = addTrailingHardline(indentedDoc);
+        if (!Array.isArray(indentedDoc)) {
+            indentedDoc = [indentedDoc];
+        }
+    }
+    for (let i = 0; i < statementDocs.length; i++) {
+        let statementDoc = statementDocs[i];
+        // remove blank lines above first statement
+        if (i === 0) {
+            statementDoc = removeLeadingBlanklines(statementDoc);
+        }
+        indentedDoc.push(statementDoc);
+        if (i < statementDocs.length - 1 && !endsWithHardline(indentedDoc)) {
+            indentedDoc.push(hardline);
+        }
+    }
+    if (Array.isArray(closeBracePunctuatorDoc)) {
+        // look for leading trivia element and remove it from closeBracePunctuatorDoc array
+        let firstElement = closeBracePunctuatorDoc[0];
+        if (isLabel(firstElement) && firstElement.label === "leadingTrivia") {
+            // remove leading trivia from closeBracePunctuatorDoc to inside indented block
+            closeBracePunctuatorDoc.splice(0, 1);
+            if (closeBracePunctuatorDoc.length === 1) {
+                closeBracePunctuatorDoc = closeBracePunctuatorDoc[0];
+            }
+            // remove blank line before closing brace i.e. any blank line of trivia above the brace
+            firstElement = removeTrailingBlankline(firstElement);
+            firstElement = removeTrailingHardline(firstElement);
+            // check if anything remains
+            if (firstElement !== "") {
+                if (!endsWithHardline(indentedDoc)) {
+                    indentedDoc.push(hardline);
+                }
+                indentedDoc.push(firstElement);
+            }
+        }
+    }
+    if (indentedDoc.length > 0) {
+        // remove blank line before closing brace
+        indentedDoc = removeTrailingBlankline(indentedDoc);
+        indentedDoc = removeTrailingHardline(indentedDoc);
+        doc.push(indent(indentedDoc));
+        doc.push(hardline);
+    }
+    if (closeBracePunctuatorDoc) {
+        doc.push(closeBracePunctuatorDoc);
+    }
+    return doc;
+}
+function addWhitespace(doc, isBreaking) {
+    let separatorDoc;
+    if (!endsWithHardline(doc)) {
+        separatorDoc = isBreaking ? ifBreak([line, "  "], " ") : " ";
+    }
+    else {
+        separatorDoc = "  ";
+    }
+    if (Array.isArray(doc)) {
+        doc.push(separatorDoc);
+    }
+    else {
+        doc = [doc, separatorDoc];
+    }
+    return doc;
+}
+/**
+ * Adds a breaking whitespace to the given doc or an indent if it ends with a hardline.
+ */
+export function addBreakingWhitespace(doc) {
+    return addWhitespace(doc, true);
+}
+/**
+ * Adds a non-breaking whitespace to the given doc or an indent if it ends with a hardline.
+ */
+export function addNonBreakingWhitespace(doc) {
+    return addWhitespace(doc, false);
+}
+/**
+ * Interleaves the given value docs with the given comma separator docs and adds breaking whitespace after each comma separator.
+ */
+export function interleaveCommaSeparatorDocs(valueDocs, commaSeparatorDocs) {
+    if (commaSeparatorDocs.length === 0) {
+        if (valueDocs.length > 1) {
+            throw new InternalScannerError(`Logic Error: Number of values: ${valueDocs.length} and no comma separators provided`);
+        }
+        return valueDocs;
+    }
+    if (valueDocs.length !== commaSeparatorDocs.length + 1) {
+        throw new InternalScannerError(`Logic Error: Number of values: ${valueDocs.length} and comma separators: ${commaSeparatorDocs.length} are not as expected`);
+    }
+    const doc = [];
+    for (let i = 0; i < valueDocs.length; i++) {
+        if (i < commaSeparatorDocs.length) {
+            let subDoc = [];
+            subDoc.push(valueDocs[i]);
+            subDoc.push(commaSeparatorDocs[i]);
+            subDoc = addBreakingWhitespace(subDoc);
+            doc.push(subDoc);
+        }
+        else {
+            doc.push(valueDocs[i]);
+        }
+    }
+    return doc;
+}

package/dist/src/prettier/util/types.d.ts

@@ -0,0 +1,13 @@
+import { type Doc, doc } from "prettier";
+type Fill = doc.builders.Fill;
+type Label = doc.builders.Label;
+type Indent = doc.builders.Indent;
+type Hardline = doc.builders.Hardline;
+type BreakParent = doc.builders.BreakParent;
+export declare function isIndent(doc: Doc): doc is Indent;
+export declare function isFill(doc: Doc): doc is Fill;
+export declare function isLabel(doc: Doc): doc is Label;
+export declare function isBreakParent(doc: Doc): doc is BreakParent;
+export declare function isHardline(doc: Doc): doc is Hardline;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/prettier/util/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/prettier/util/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEzC,KAAK,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC;AAC9B,KAAK,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC;AAChC,KAAK,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC;AAClC,KAAK,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC;AACtC,KAAK,WAAW,GAAG,GAAG,CAAC,QAAQ,CAAC,WAAW,CAAC;AAE5C,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,MAAM,CAEhD;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,CAE5C;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,KAAK,CAE9C;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,WAAW,CAE1D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,QAAQ,CAQpD"}

package/dist/src/prettier/util/types.js

@@ -0,0 +1,20 @@
+import { doc } from "prettier";
+export function isIndent(doc) {
+    return doc.type === "indent";
+}
+export function isFill(doc) {
+    return doc.type === "fill";
+}
+export function isLabel(doc) {
+    return doc.type === "label";
+}
+export function isBreakParent(doc) {
+    return doc.type === "break-parent";
+}
+export function isHardline(doc) {
+    return (Array.isArray(doc) &&
+        doc.length === 2 &&
+        doc[0].type === "line" &&
+        doc[0].hard === true &&
+        doc[1].type === "break-parent");
+}

package/dist/src/scanner-error.d.ts

@@ -0,0 +1,36 @@
+import type { Location } from "./location.ts";
+/**
+ * Base error class.
+ */
+export declare abstract class ScannerError extends Error {
+    errorMessage: string;
+    location?: Location | undefined;
+    protected constructor(errorMessage: string, location?: Location | undefined);
+}
+/**
+ * Indicates an internal logic error in the scanner implementation.
+ */
+export declare class InternalScannerError extends ScannerError {
+    constructor(errorMessage: string, location?: Location);
+}
+/**
+ * Indicates a syntactic error in the provided source.
+ */
+export declare class SyntaxError extends ScannerError {
+    errorLine?: string | undefined;
+    precedingLines?: string[] | undefined;
+    constructor(errorMessage: string, location?: Location, errorLine?: string | undefined, precedingLines?: string[] | undefined);
+}
+/**
+ * Indicates a semantic error in the provided AST.
+ */
+export declare class SemanticError extends ScannerError {
+    constructor(errorMessage: string, location?: Location);
+}
+/**
+ * Indicates a semantic warning in the provided AST.
+ */
+export declare class SemanticWarning extends ScannerError {
+    constructor(warningMessage: string, location?: Location);
+}
+//# sourceMappingURL=scanner-error.d.ts.map

package/dist/src/scanner-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner-error.d.ts","sourceRoot":"","sources":["../../src/scanner-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;GAEG;AACH,8BAAsB,YAAa,SAAQ,KAAK;IAErC,YAAY,EAAE,MAAM;IACpB,QAAQ,CAAC,EAAE,QAAQ;IAF5B,SAAS,aACA,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,QAAQ,YAAA;CAS7B;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ;CAGtD;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;IAIlC,SAAS,CAAC,EAAE,MAAM;IAClB,cAAc,CAAC,EAAE,MAAM,EAAE;gBAHhC,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,QAAQ,EACZ,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,cAAc,CAAC,EAAE,MAAM,EAAE,YAAA;CAInC;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,YAAY;gBACjC,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ;CAGtD;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,cAAc,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ;CAGxD"}

package/dist/src/scanner-error.js

@@ -0,0 +1,51 @@
+/**
+ * Base error class.
+ */
+export class ScannerError extends Error {
+    errorMessage;
+    location;
+    constructor(errorMessage, location) {
+        super(errorMessage +
+            (location
+                ? ` => { row: ${location.row}, column: ${location.column}, position: ${location.position} }`
+                : ""));
+        this.errorMessage = errorMessage;
+        this.location = location;
+    }
+}
+/**
+ * Indicates an internal logic error in the scanner implementation.
+ */
+export class InternalScannerError extends ScannerError {
+    constructor(errorMessage, location) {
+        super(`INTERNAL SCANNER ERROR: ${errorMessage}`, location);
+    }
+}
+/**
+ * Indicates a syntactic error in the provided source.
+ */
+export class SyntaxError extends ScannerError {
+    errorLine;
+    precedingLines;
+    constructor(errorMessage, location, errorLine, precedingLines) {
+        super(`SYNTAX ERROR: ${errorMessage}`.trim(), location);
+        this.errorLine = errorLine;
+        this.precedingLines = precedingLines;
+    }
+}
+/**
+ * Indicates a semantic error in the provided AST.
+ */
+export class SemanticError extends ScannerError {
+    constructor(errorMessage, location) {
+        super(`SEMANTIC ERROR: ${errorMessage}`.trim(), location);
+    }
+}
+/**
+ * Indicates a semantic warning in the provided AST.
+ */
+export class SemanticWarning extends ScannerError {
+    constructor(warningMessage, location) {
+        super(`SEMANTIC WARNING: ${warningMessage}`.trim(), location);
+    }
+}

package/dist/src/util/location-utils.d.ts

@@ -0,0 +1,4 @@
+import { Text } from "@codemirror/state";
+import type { Location } from "../location.ts";
+export declare function getLocationFromTextPosition(text: Text, position: number): Location;
+//# sourceMappingURL=location-utils.d.ts.map

package/dist/src/util/location-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location-utils.d.ts","sourceRoot":"","sources":["../../../src/util/location-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CASlF"}

package/dist/src/util/location-utils.js

@@ -0,0 +1,11 @@
+import { Text } from "@codemirror/state";
+export function getLocationFromTextPosition(text, position) {
+    const line = text.lineAt(position);
+    const row = line.number;
+    const column = position - line.from + 1;
+    return {
+        row,
+        column,
+        position,
+    };
+}

package/dist/src/util/logger.d.ts

@@ -0,0 +1,22 @@
+declare global {
+    var defaultLogger: Logger | undefined;
+}
+type LoggerFunction = (message: object | (() => string) | string, ...optionalParams: unknown[]) => void;
+export interface Logger {
+    trace: LoggerFunction;
+    debug: LoggerFunction;
+    info: LoggerFunction;
+    warn: LoggerFunction;
+    error: LoggerFunction;
+}
+export declare const debugEnabled: boolean;
+/**
+ * Retrieves a logger instance with the specified name. If the name length exceeds the current maximum logger name length,
+ * it updates the padding for all existing logger names to ensure consistent formatting.
+ *
+ * @param loggerName The name of the logger to retrieve.
+ * @returns A logger instance with the specified name.
+ */
+export default function getLogger(loggerName: string): Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/util/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/util/logger.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,KAAK,cAAc,GAAG,CACpB,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,GAAG,MAAM,EACzC,GAAG,cAAc,EAAE,OAAO,EAAE,KACzB,IAAI,CAAC;AAEV,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,cAAc,CAAC;IACtB,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,cAAc,CAAC;CACvB;AAUD,eAAO,MAAM,YAAY,SAgBrB,CAAC;AAqDL;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAiC5D"}