@gesslar/bedoc 1.0.0

package/src/core/Logger.js

@@ -0,0 +1,191 @@
+/*
+  For formatting console info, see:
+  https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args
+
+  * %s: String will be used to convert all values except BigInt, Object and -0.
+        BigInt values will be represented with an n and Objects that have no
+        user defined toString function are inspected using util.inspect() with
+        options { depth: 0, colors: false, compact: 3 }.
+  * %d: Number will be used to convert all values except BigInt and Symbol.
+  * %i: parseInt(value, 10) is used for all values except BigInt and Symbol.
+  * %f: parseFloat(value) is used for all values expect Symbol.
+  * %j: JSON. Replaced with the string '[Circular]' if the argument contains
+        circular references.
+  * %o: Object. A string representation of an object with generic JavaScript
+        object formatting. Similar to util.inspect() with options { showHidden:
+        true, showProxy: true }. This will show the full object including non-
+        enumerable properties and proxies.
+  * %O: Object. A string representation of an object with generic JavaScript
+        object formatting. Similar to util.inspect() without options. This will
+        show the full object not including non-enumerable properties and
+        proxies.
+  * %%: single percent sign ('%'). This does not consume an argument.
+
+*/
+
+import console from "node:console"
+import ErrorStackParser from "error-stack-parser"
+
+import {Environment} from "./Core.js"
+
+import * as FDUtil from "./util/FDUtil.js"
+import * as StringUtil from "./util/StringUtil.js"
+
+const {resolveFilename} = FDUtil
+const {capitalize} = StringUtil
+
+const loggerColours = {
+  debug: [
+    "\x1b[38;5;19m", // Debug level 0: Dark blue
+    "\x1b[38;5;27m", // Debug level 1: Medium blue
+    "\x1b[38;5;33m", // Debug level 2: Light blue
+    "\x1b[38;5;39m", // Debug level 3: Teal
+    "\x1b[38;5;44m", // Debug level 4: Blue-tinted cyan
+  ],
+  info: "\x1b[38;5;36m",    // Medium Spring Green
+  warn: "\x1b[38;5;214m",   // Orange1
+  error: "\x1b[38;5;196m",  // Red1
+  reset: "\x1b[0m", // Reset
+}
+
+/**
+ * Logger class
+ *
+ * Log levels:
+ * - debug: Debugging information
+ *   - Debug levels
+ *     - 0: No/critical debug information, not error level, but, should be
+ *          logged
+ *     - 1: Basic debug information, startup, shutdown, etc
+ *     - 2: Intermediate debug information, discovery, starting to get more
+ *         detailed
+ *     - 3: Detailed debug information, parsing, processing, etc
+ *     - 4: Very detailed debug information, nerd mode!
+ * - warn: Warning information
+ * - info: Informational information
+ * - error: Error information
+ */
+
+export default class Logger {
+  #name = null
+  #debugMode = false
+  #debugLevel = 0
+
+  constructor(options) {
+    this.#name = "BeDoc"
+    if(options) {
+      this.setOptions(options)
+      if(options.env === Environment.EXTENSION) {
+        const vscode = import("vscode")
+        this.vscodeError = vscode.window.showErrorMessage
+        this.vscodeWarn = vscode.window.showWarningMessage
+        this.vscodeInfo = vscode.window.showInformationMessage
+      }
+    }
+  }
+
+  get name() {
+    return this.#name
+  }
+
+  get debugMode() {
+    return this.#debugMode
+  }
+
+  get debugLevel() {
+    return this.#debugLevel
+  }
+
+  get options() {
+    return {
+      name: this.#name,
+      debugMode: this.#debugMode,
+      debugLevel: this.#debugLevel,
+    }
+  }
+
+  setOptions(options) {
+    this.#name = options.name ?? this.#name
+    this.#debugMode = options.debugMode
+    this.#debugLevel = options.debugLevel
+  }
+
+  #compose(level, message, debugLevel = 0) {
+    const tag = capitalize(level)
+
+    if(level === "debug")
+      return `[${this.#name}] ${loggerColours[level][debugLevel]}${tag}${loggerColours.reset}: ${message}`
+
+    return `[${this.#name}] ${loggerColours[level]}${tag}${loggerColours.reset}: ${message}`
+  }
+
+  lastStackLine(stepsRemoved = 3) {
+    const stack = ErrorStackParser.parse(new Error())
+    return stack[stepsRemoved]
+  }
+
+  extractFileFunction(level = 0) {
+    const frame = this.lastStackLine()
+    const {
+      functionName: func,
+      fileName: file,
+      lineNumber: line,
+      columnNumber: col,
+    } = frame
+
+    const {module, absoluteUri} = resolveFilename(file)
+
+    let functionName = func ?? "anonymous"
+    if(functionName.startsWith("#"))
+      functionName = `${module}.${functionName}`
+
+    const methodName = /\[as \w+\]$/.test(functionName)
+      ? /\[as (\w+)\]/.exec(functionName)[1]
+      : null
+
+    if(methodName) {
+      functionName = functionName.replace(/\[as \w+\]$/, "")
+      functionName = `${functionName}{${methodName}}`
+    }
+
+    if(/^async /.test(functionName))
+      functionName = functionName.replace(/^async /, "(async)")
+
+    let result = functionName
+
+    if(level >= 2)
+      result = `${result}:${line}:${col}`
+
+    if(level >= 3)
+      result = `${absoluteUri} ${result}`
+
+    return result
+  }
+
+  newDebug(tag) {
+    return function(message, level, ...arg) {
+      tag = this.extractFileFunction(this.#debugLevel)
+      this.debug(`[${tag}] ${message}`, level, ...arg)
+    }.bind(this)
+  }
+
+  debug(message, level = 0, ...arg) {
+    if(this.debugMode === true && level <= (this.debugLevel ?? 4))
+      console.debug(this.#compose("debug", message, level), ...arg)
+  }
+
+  warn(message, ...arg) {
+    console.warn(this.#compose("warn", message), ...arg)
+    this.vscodeWarn?.(JSON.stringify(message))
+  }
+
+  info(message, ...arg) {
+    console.info(this.#compose("info", message), ...arg)
+    this.vscodeInfo?.(JSON.stringify(message))
+  }
+
+  error(message, ...arg) {
+    console.error(this.#compose("error", message), ...arg)
+    this.vscodeError?.(JSON.stringify(message))
+  }
+}

package/src/core/action/ParseManager.js

@@ -0,0 +1,26 @@
+import ActionManager from "../ActionManager.js"
+
+export default class ParseManager extends ActionManager {
+  constructor(actionDefinition, logger) {
+    super(actionDefinition, logger)
+  }
+
+  async parse(fileMap, content) {
+    const log = this.log
+    const debug = log.newDebug()
+
+    debug("Parsing file `%j`", 3, fileMap)
+
+    if(this.action.init)
+      this.action.init({parent: this, log})
+
+    if(!this.action.parse)
+      throw new Error(`No parse function found for action: ${this.module}`)
+
+    const result = await this.action.parse(fileMap.path, content)
+
+    debug("Parse complete of file `%j`", 3, fileMap)
+
+    return result
+  }
+}

package/src/core/action/PrintManager.js

@@ -0,0 +1,26 @@
+import ActionManager from "../ActionManager.js"
+
+export default class PrintManager extends ActionManager {
+  constructor(actionDefinition, logger) {
+    super(actionDefinition, logger)
+  }
+
+  async print(fileMap, content) {
+    const log = this.log
+    const debug = log.newDebug()
+
+    debug("Printing data for `%s`", 3, fileMap.module)
+
+    if(this.action.init)
+      this.action.init({parent: this, log})
+
+    if(!this.action.print)
+      throw new Error(`No print function found for action: ${this.module}`)
+
+    const result = await this.action.print(fileMap.module, content)
+
+    debug("Print complete for `%s`", 3, fileMap.module)
+
+    return result
+  }
+}

package/src/core/util/ActionUtil.js

@@ -0,0 +1,47 @@
+import * as FDUtil from "./FDUtil.js"
+
+const {readFile, resolveFilename} = FDUtil
+
+const freeze = Object.freeze
+
+const actionTypes = freeze(["parse", "print"])
+
+const actionMetaRequirements = freeze({
+  parse: [{action: "parse"}, "language"],
+  print: [{action: "print"}, "format"],
+})
+
+/**
+ * Loads a JSON file asynchronously
+ *
+ * @param {object} jsonFileObject - The JSON file to load
+ * @returns {object} The parsed JSON content
+ */
+function loadJson(jsonFileObject) {
+  // Read the file
+  const jsonContent = readFile(jsonFileObject)
+  const json = JSON.parse(jsonContent)
+  return json
+}
+
+/**
+ * Loads the package.json file asynchronously
+ *
+ * @param {string|object} basePath - The base path to use
+ * @returns {object} The parsed package.json content
+ */
+function loadPackageJson(basePath = null) {
+  const packageJsonFileObject = resolveFilename("./package.json", basePath)
+  const jsonContent = readFile(packageJsonFileObject)
+  const json = JSON.parse(jsonContent)
+  return json
+}
+
+export {
+  // Constants
+  actionMetaRequirements,
+  actionTypes,
+  // Functions
+  loadJson,
+  loadPackageJson,
+}