@maverick-js/compiler/dist/chunks/chunk-SEGPSIF6.js

Maverick toolchain including the analyzer and compiler.

import { isFunction, isObject } from './chunk-3M33KLBM.js';
import { createFromBuffer } from '@dprint/formatter';
import { getPath } from '@dprint/typescript';
import { readFileSync } from 'node:fs';
import kleur from 'kleur';
import { normalize } from 'pathe';

var buffer = readFileSync(getPath());
var formatter = createFromBuffer(buffer);
function format(filename, contents) {
  return formatter.formatText(filename, contents);
}
function createImportDeclaration(defaultSpecifier, namedSpecifiers, moduleId) {
  let _default = defaultSpecifier ? `${defaultSpecifier}, ` : "";
  let _named = namedSpecifiers.length > 0 ? `{ ${namedSpecifiers.join(", ")} }` : "";
  return `import ${_default}${_named} from "${moduleId}";
`;
}
function escapeDoubleQuotes(value) {
  return value.replace(/"/g, '\\"');
}
var escapeQuotes = (str) => str.replace(/^"+|"+$/g, "").replace(/^'+|'+$/g, "");
var normalizeLineBreaks = (str) => str.replace(/\\r/g, "\n");
function splitLineBreaks(str) {
  if (typeof str !== "string")
    return [];
  return normalizeLineBreaks(str).split("\n");
}
function createFunctionCall(id, params = []) {
  return `${id}(${params.length > 0 ? params.filter((v) => v !== null).join(", ") : ""})`;
}
function selfInvokingFunction(block) {
  return `(() => { ${block} })()`;
}
function createStringLiteral(value) {
  return !value.startsWith('"') ? `"${value}"` : value;
}
var trimQuoteStartRE = /^('|"|`)/;
var trimQuoteEndRE = /('|"|`)$/;
function trimQuotes(text) {
  return text.replace(trimQuoteStartRE, "").replace(trimQuoteEndRE, "");
}
var trailingSemicolon = /;\s*$/;
function trimTrailingSemicolon(text) {
  return text.replace(trailingSemicolon, "");
}
function trimWhitespace(text) {
  text = text.replace(/\r/g, "");
  if (/\n/g.test(text)) {
    text = text.split("\n").map((t, i) => i ? t.replace(/^\s*/g, "") : t).filter((s2) => !/^\s*$/.test(s2)).join(" ");
  }
  return text.replace(/\s+/g, " ");
}
var Declarations = class {
  constructor() {
    this.all = /* @__PURE__ */ new Map();
    this._count = {};
  }
  get size() {
    return this.all.size;
  }
  create(id, value = "") {
    const newId = this._count[id] ? `${id}_${this._count[id] = this._count[id] + 1}` : id;
    if (!this._count[id])
      this._count[id] = 1;
    this.all.set(newId, value);
    return newId;
  }
  update(id, value) {
    this.all.set(id, value);
  }
  has(id) {
    return !!this._count[id];
  }
  delete(id) {
    this.all.delete(id);
  }
  serialize(pure = false) {
    if (this.all.size === 0)
      return "";
    let values = [];
    for (const [id, value] of this.all) {
      values.push(`${id} = ${pure ? "/* #__PURE__ */ " : ""}${value}`);
    }
    return `const ${values.join(`,
  `)};
`;
  }
};
function createObjectLiteral(props) {
  return `{ ${Object.keys(props).map((prop) => `'${prop}': ${props[prop]}`).join(", ")} }`;
}

// src/utils/num.ts
function round(num, decimalPlaces = 2) {
  return Number(num.toFixed(decimalPlaces));
}

// src/utils/ms.ts
var s = 1e3;
var m = s * 60;
var h = m * 60;
var d = h * 24;
function ms(val) {
  const msAbs = Math.abs(val);
  if (msAbs >= d) {
    return Math.round(val / d) + "d";
  }
  if (msAbs >= h) {
    return Math.round(val / h) + "h";
  }
  if (msAbs >= m) {
    return Math.round(val / m) + "m";
  }
  if (msAbs >= s) {
    return Math.round(val / s) + "s";
  }
  return round(val, 2) + "ms";
}

// src/utils/logger.ts
var LogLevelColor = Object.freeze({
  [0 /* Silent */]: kleur.bgWhite,
  [1 /* Error */]: kleur.bgRed,
  [2 /* Warn */]: kleur.bgYellow,
  [3 /* Info */]: kleur.bgCyan,
  [4 /* Verbose */]: kleur.bgMagenta
});
var currentLogLevel = 3 /* Info */;
function mapLogLevelStringToNumber(level) {
  switch (level) {
    case "silent":
      return 0 /* Silent */;
    case "error":
      return 1 /* Error */;
    case "warn":
      return 2 /* Warn */;
    case "info":
      return 3 /* Info */;
    case "verbose":
      return 4 /* Verbose */;
    default:
      return 3 /* Info */;
  }
}
function mapLogLevelToString(level) {
  switch (level) {
    case 1 /* Error */:
      return "error";
    case 2 /* Warn */:
      return "warn";
    case 3 /* Info */:
      return "info";
    case 4 /* Verbose */:
      return "verbose";
    case 0 /* Silent */:
      return "silent";
    default:
      return "info";
  }
}
var clearTerminal = () => {
  console.clear();
};
function setGlobalLogLevel(level) {
  currentLogLevel = level;
}
var log = (text, level = 3 /* Info */) => {
  if (currentLogLevel < level)
    return;
  if (isFunction(text)) {
    text = text();
  }
  if (isObject(text)) {
    console.dir(text, { depth: 10 });
  } else {
    const currentColor = LogLevelColor[level];
    console.log(
      kleur.dim(
        `${formatPluginName("maverick")} ${currentColor(
          kleur.bold(kleur.black(` ${mapLogLevelToString(level).toUpperCase()} `))
        )}`
      ),
      `${text}
`
    );
  }
};
var logTime = (message, startTime, level = 3 /* Info */) => {
  const totalTime = process.hrtime(startTime);
  const totalTimeText = kleur.green(ms(totalTime[0] * 1e3 + totalTime[1] / 1e6));
  log(() => `${message} in ${totalTimeText}.`, level);
};
function formatPluginName(name) {
  return `[${name.startsWith("maverick") ? kleur.dim(name) : kleur.yellow(name)}]`;
}
var logStackTrace = (message, stack, level = 1 /* Error */) => {
  log(
    `

${kleur.bold("MESSAGE")}

${message}

${kleur.bold("STACK TRACE")}

${stack}`,
    level
  );
};
var printDiagnostic = (message, sourceFilePath, sourceText, startLineNumber, endLineNumber, level) => {
  log(
    printDiagnosticOutput(message, sourceFilePath, sourceText, startLineNumber, endLineNumber),
    level
  );
};
function printDiagnosticOutput(message, sourceFilePath, sourceText, startLineNumber, endLineNumber) {
  const isMultiLine = endLineNumber - startLineNumber > 0;
  const codeFrame = buildCodeFrame(sourceText, startLineNumber, endLineNumber);
  return [
    `

${kleur.bold("MESSAGE")}`,
    `
${message}`,
    `
${kleur.bold("CODE")}
`,
    `${kleur.dim(sourceFilePath)} ${kleur.dim("L:")}${kleur.dim(
      isMultiLine ? `${startLineNumber}-${endLineNumber}` : startLineNumber
    )}
`,
    prettifyCodeFrame(codeFrame)
  ].join("\n");
}
var reportDiagnosticByNode = (message, node, level = 3 /* Info */) => {
  const sourceFile = node.getSourceFile();
  const sourceFilePath = normalize(sourceFile.fileName);
  const sourceText = sourceFile.text;
  const posStart = sourceFile.getLineAndCharacterOfPosition(node.getStart());
  const posEnd = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
  const startLineNumber = posStart.line + 1;
  const endLineNumber = posEnd.line + 1;
  {
    printDiagnostic(message, sourceFilePath, sourceText, startLineNumber, endLineNumber, level);
  }
};
function prettifyCodeFrame(codeFrame) {
  const { firstLineNumber, linesBefore, relevantLines, linesAfter } = codeFrame;
  const printLines = [];
  const maxNoOfDigits = (firstLineNumber + codeFrame.totalLines).toString().length;
  const formatLineNumber = (lineNumber) => {
    const missingDigits = maxNoOfDigits - lineNumber.toString().length;
    return missingDigits > 0 ? `${" ".repeat(missingDigits)}${lineNumber}` : `${lineNumber}`;
  };
  const printLine = (line, lineNumber, isRelevant = false) => (isRelevant ? kleur.white : kleur.dim)(
    `${isRelevant ? "> " : "  "}${kleur.bold(formatLineNumber(lineNumber))} |  ${line}`
  );
  linesBefore.forEach((line, i) => {
    printLines.push(printLine(line, firstLineNumber + i));
  });
  relevantLines.forEach((line, i) => {
    printLines.push(printLine(line, firstLineNumber + linesBefore.length + i, true));
  });
  linesAfter.forEach((line, i) => {
    printLines.push(
      printLine(line, firstLineNumber + linesBefore.length + relevantLines.length + i)
    );
  });
  return printLines.join("\n");
}
function buildCodeFrame(sourceText, startLineNumber, endLineNumber, frameSize = 5) {
  const startLineNumberMinusOne = startLineNumber - 1;
  const lines = splitLineBreaks(sourceText);
  const startAt = startLineNumberMinusOne - frameSize < 0 ? 0 : startLineNumberMinusOne - frameSize;
  const endAt = endLineNumber + frameSize > lines.length ? lines.length : endLineNumber + frameSize;
  const codeFrame = {
    firstLineNumber: startAt + 1,
    linesBefore: [],
    relevantLines: [],
    linesAfter: [],
    totalLines: 0
  };
  let lineCounter = 0;
  const MAX_LINES = 15;
  function buildLines(start, end) {
    if (lineCounter > MAX_LINES - 1)
      return [];
    const newLines = [];
    for (let i = start; i < end; i++) {
      if (lines[i] != null) {
        newLines.push(lines[i]);
        lineCounter += 1;
      }
      if (lineCounter > MAX_LINES - 1) {
        return newLines;
      }
    }
    return newLines;
  }
  codeFrame.linesBefore = buildLines(startAt, startLineNumberMinusOne);
  codeFrame.relevantLines = buildLines(startLineNumberMinusOne, endLineNumber);
  codeFrame.linesAfter = buildLines(endLineNumber, endAt + 1);
  const linesHidden = endAt - startAt - lineCounter;
  if (linesHidden > 0) {
    codeFrame.linesAfter.push(
      kleur.dim(`${linesHidden} ${linesHidden === 1 ? "line" : "lines"} hidden...`)
    );
  }
  codeFrame.totalLines = lineCounter;
  return codeFrame;
}

export { Declarations, clearTerminal, createFunctionCall, createImportDeclaration, createObjectLiteral, createStringLiteral, escapeDoubleQuotes, escapeQuotes, format, formatPluginName, log, logStackTrace, logTime, mapLogLevelStringToNumber, normalizeLineBreaks, reportDiagnosticByNode, selfInvokingFunction, setGlobalLogLevel, trimQuotes, trimTrailingSemicolon, trimWhitespace };