@gesslar/bedoc 1.4.7 → 1.4.10

package/dist/types/core/ActionManager.d.ts

@@ -1,5 +1,5 @@
 import Logger from './Logger'
-import HookManager from './HookManager'
+import HookManager, {HookPoints} from './HookManager'
 
 export type MetaActionType = "print" | "parse"
 
@@ -24,6 +24,8 @@ export interface ActionDefinition {
   setup?: (params: { parent: ActionManager; log: Logger }) => void
   run({ module, content }: { module: string; content: object }): Promise<string>
   hook?: (event: string, ...args: unknown[]) => Promise<unknown>
+
+  HOOKS?: HookPoints
 }
 
 export interface PrintActionDefinition extends ActionDefinition {

package/dist/types/core/HookManager.d.ts

@@ -27,7 +27,7 @@ interface HookManagerConstructorParams {
     timeOut: number;
 }
 
-export const hookPoints: Readonly<Record<Uppercase<HookEventType>, HookEventType>>;
+export const HookPoints: Readonly<Record<Uppercase<HookEventType>, HookEventType>>;
 
 export default class HookManager {
     static new(arg: HookManagerConstructorParams): Promise<HookManager | null>;
@@ -51,7 +51,6 @@ export default class HookManager {
      */
     on(event: HookEventType, ...args: unknown[]): Promise<HookResult | undefined>;
 
-    HOOKS?: HookPoints
     #hooksFile: FileMap | null;
     #log: Logger | null;
     #hooks: HooksDefinition | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/bedoc",
-  "version": "1.4.7",
+  "version": "1.4.10",
   "description": "Pluggable documentation engine for any language and format",
   "publisher": "gesslar",
   "main": "./src/core/Core.js",

package/src/core/Configuration.js

@@ -49,7 +49,7 @@ export default class Configuration {
     // Find them and add them to an array; the rest will be in pushed to the
     // end of the priority array.
     const orderedSections = []
-    ConfigurationPriorityKeys.forEach((key) => {
+    ConfigurationPriorityKeys.forEach(key => {
       if(!ConfigurationParameters[key])
         throw new Error(`Invalid priority key: ${key}`)
 
@@ -58,10 +58,10 @@ export default class Configuration {
     })
 
     const remainingSections = Object.keys(ConfigurationParameters).filter(
-      (key) => !ConfigurationPriorityKeys.includes(key),
+      key => !ConfigurationPriorityKeys.includes(key),
     )
     orderedSections.push(
-      ...remainingSections.map((key) => {
+      ...remainingSections.map(key => {
         return {key, value: finalOptions[key]}
       }),
     )
@@ -106,7 +106,7 @@ export default class Configuration {
         if(key === "input" || key === "exclude") {
           if(isType(value, "array"))
             value = await Promise.all(
-              value.map((pattern) => getFiles(pattern)),
+              value.map(pattern => getFiles(pattern)),
             )
           else if(isType(value, "string"))
             value = await getFiles(value)
@@ -251,7 +251,7 @@ export default class Configuration {
    */
   #getEnvironmentVariables() {
     const environmentVariables = {}
-    const params = Object.keys(ConfigurationParameters).map((param) => {
+    const params = Object.keys(ConfigurationParameters).map(param => {
       return {
         param,
         env: `bedoc_${param}`.toUpperCase(),
@@ -280,7 +280,7 @@ export default class Configuration {
     const nonEntryOptions = allOptions.filter(
       option => option.source && option.source !== "entry",
     )
-    const optionsOnly = nonEntryOptions.map((option) => option.options)
+    const optionsOnly = nonEntryOptions.map(option => option.options)
     const mergedOptions = optionsOnly.reduce((acc, options) => {
       for(const [key, value] of Object.entries(options)) acc[key] = value
 

package/src/core/Conveyor.js

@@ -107,7 +107,7 @@ export default class Conveyor {
 
       // Step 4: Write output
       const {status: printStatus, destFile, content} = printResult
-      const isNullish = (value) => value == null // Checks null or undefined
+      const isNullish = value => value == null // Checks null or undefined
 
       if(printStatus !== "success" || isNullish(destFile) || isNullish(content)) {
         return {status: "error", file, error: new Error("Invalid print result")}

package/src/core/Discovery.js

@@ -5,8 +5,9 @@ import {execSync} from "child_process"
 import * as FDUtil from "./util/FDUtil.js"
 import * as ActionUtil from "./util/ActionUtil.js"
 import * as DataUtil from "./util/DataUtil.js"
+import {composeDirectory,directoryExists} from "./util/FDUtil.js"
 
-const {ls, resolveDirectory, resolveFilename, getFiles} = FDUtil
+const {ls,resolveFilename,getFiles} = FDUtil
 const {actionTypes, actionMetaRequirements, loadJson} = ActionUtil
 const {isType} = DataUtil
 
@@ -72,7 +73,9 @@ export default class Discovery {
       debug("Found %d directories to search for actions", 2, directories.length)
       debug("Directories to search for actions: %o", 3, directories)
 
-      const moduleDirectories = directories.map(resolveDirectory)
+      const moduleDirectories = directories
+        .map(composeDirectory)
+        .filter(directoryExists)
       for(const moduleDirectory of moduleDirectories) {
         const {directories: dirs} = await ls(moduleDirectory.absolutePath)
 
@@ -310,9 +313,9 @@ export default class Discovery {
   async #loadModule(module) {
     const debug = this.#debug
 
-    debug("Loading module `%j`", 2, module)
+    debug("2 Loading module `%j`", 2, module)
 
-    const {absoluteUri} = module
+    const {absolutePath: absoluteUri} = module
     const moduleExports = await import(absoluteUri)
 
     return {file: module, ...moduleExports}

package/src/core/HookManager.js

@@ -10,7 +10,7 @@ const freeze = Object.freeze
 const hookEvents = freeze(["start", "section_load", "enter", "exit", "end"])
 export const HookPoints = freeze(
   await allocateObject(
-    hookEvents.map((event) => event.toUpperCase()),
+    hookEvents.map(event => event.toUpperCase()),
     hookEvents,
   ),
 )

package/src/core/util/DataUtil.js

@@ -38,7 +38,7 @@ const constructors = [
   "Float64Array",
 ]
 
-const dataTypes = [...primitives, ...constructors.map((c) => c.toLowerCase())]
+const dataTypes = [...primitives, ...constructors.map(c => c.toLowerCase())]
 
 const emptyableTypes = ["string", "array", "object"]
 
@@ -96,7 +96,7 @@ function isArrayUnique(arr) {
  * @returns {Array} The intersection of the two arrays.
  */
 function arrayIntersection(arr1, arr2) {
-  return arr1.filter((value) => arr2.includes(value))
+  return arr1.filter(value => arr2.includes(value))
 }
 
 /**
@@ -390,7 +390,7 @@ function deepFreezeObject(obj) {
  * @returns {boolean} - True if valid, throws an error otherwise.
  */
 function schemaCompare(schema, definition, stack = [], logger = new Logger()) {
-  const breadcrumb = (key) => (stack.length ? `@${stack.join(".")}` : key)
+  const breadcrumb = key => (stack.length ? `@${stack.join(".")}` : key)
   const tag = "[DataUtil.schemaCompare]"
   const pad = `${" ".repeat(stack.length * 2)}${stack.length ? "└─ " : ""}`
   const debug = (message, key) =>

package/src/core/util/FDUtil.js

@@ -10,10 +10,10 @@ import * as ValidUtil from "./ValidUtil.js"
 const {isArrayUniform, isType, allocateObject} = DataUtil
 const {validType} = ValidUtil
 
-const freeze = (ob) => Object.freeze(ob)
+const freeze = ob => Object.freeze(ob)
 
 const fdTypes = freeze(["file", "directory"])
-const upperFdTypes = freeze(fdTypes.map((type) => type.toUpperCase()))
+const upperFdTypes = freeze(fdTypes.map(type => type.toUpperCase()))
 const fdType = freeze(await allocateObject(upperFdTypes, fdTypes))
 
 /**
@@ -67,7 +67,7 @@ function canWriteFile(FileMap) {
   try {
     fs.accessSync(FileMap.absolutePath, fs.constants.W_OK)
     return true
-  } catch(error) {
+  } catch(_error) {
     return false
   }
 }
@@ -82,7 +82,22 @@ function fileExists(FileMap) {
   try {
     fs.accessSync(FileMap.absolutePath)
     return true
-  } catch(error) {
+  } catch(_error) {
+    return false
+  }
+}
+
+/**
+ * Check if a directory exists
+ *
+ * @param {object} DirectoryMap - The directory map to check
+ * @returns {boolean} Whether the directory exists
+ */
+function directoryExists(DirectoryMap) {
+  try {
+    fs.accessSync(DirectoryMap.absolutePath)
+    return true
+  } catch(_error) {
     return false
   }
 }
@@ -231,9 +246,9 @@ async function getFiles(globPattern) {
       ? globPattern
       : globPattern
         .split("|")
-        .map((g) => g.trim())
+        .map(g => g.trim())
         .filter(Boolean)
-  ).map((g) => fixSlashes(g))
+  ).map(g => fixSlashes(g))
 
   if(
     Array.isArray(globbyArray) &&
@@ -246,7 +261,7 @@ async function getFiles(globPattern) {
 
   // Use Globby to fetch matching files
   const filesArray = await globby(globbyArray)
-  const files = filesArray.map((file) => mapFilename(file))
+  const files = filesArray.map(file => mapFilename(file))
 
   // Flatten the result and remove duplicates
   return files
@@ -297,7 +312,7 @@ function composeDirectory(directory) {
 async function ls(directory) {
   const found = await fs.promises.readdir(directory, {withFileTypes: true})
   const results = await Promise.all(
-    found.map(async(dirent) => {
+    found.map(async dirent => {
       const fullPath = path.join(directory, dirent.name)
       const stat = await fs.promises.stat(fullPath)
       return {dirent, stat, fullPath}
@@ -357,6 +372,7 @@ export {
   composeDirectory,
   composeFilename,
   deconstructFilenameToParts,
+  directoryExists,
   fileExists,
   fixSlashes,
   getFiles,

package/src/core/util/TypeSpec.js

@@ -17,7 +17,7 @@ export default class TypeSpec {
 
   toString() {
     return this.#specs
-      .map((spec) => {
+      .map(spec => {
         return `${spec.typeName}${spec.array ? "[]" : ""}`
       })
       .join("|")
@@ -61,7 +61,7 @@ export default class TypeSpec {
     // If we have a list of types, because the string was validly parsed,
     // we need to ensure that all of the types that were parsed are valid types
     // in JavaScript.
-    if(this.length && !this.every((t) => isValidType(t.typeName)))
+    if(this.length && !this.every(t => isValidType(t.typeName)))
       return false
 
     // Now, let's do some checking with the types, respecting the array flag
@@ -71,7 +71,7 @@ export default class TypeSpec {
 
     // We need to ensure that we match the type and the consistency of the types
     // in an array, if it is an array and an array is allowed.
-    const matchingTypeSpec = this.filter((spec) => {
+    const matchingTypeSpec = this.filter(spec => {
       const {typeName: allowedType, array: allowedArray} = spec
 
       if(valueType === allowedType && !isArray && !allowedArray)
@@ -97,7 +97,7 @@ export default class TypeSpec {
     const delimiter = options?.delimiter ?? "|"
     const parts = string.split(delimiter)
 
-    this.#specs = parts.map((part) => {
+    this.#specs = parts.map(part => {
       const typeMatches = /(\w+)(\[\])?/.exec(part)
       if(!typeMatches || typeMatches.length !== 3)
         throw new TypeError(`Invalid type: ${part}`)

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "include": ["src/**/*.js"], // Match all .js files in the src/ directory
-  "exclude": ["node_modules"], // Ignore node_modules/ (but NOT src/)
-  "compilerOptions": {
-    "target": "ES2022", // Modern JavaScript output
-    "allowJs": true, // Process .js files
-    "declaration": true, // Generate .d.ts files
-    "emitDeclarationOnly": true, // Only output .d.ts files
-    "declarationMap": true, // Generate .d.ts.map for IDE support
-    "module": "NodeNext", // Use ESM-compatible Node.js modules
-    "moduleResolution": "nodenext", // Resolve ESM imports properly
-    "rootDir": "src", // Base input directory
-    "outDir": "dist/types", // Emit .d.ts files to a separate directory
-    "strict": true, // Enable strict type-checking
-    "esModuleInterop": true, // Interoperability for CommonJS modules
-    "forceConsistentCasingInFileNames": true, // Avoid case-sensitive issues
-    "skipLibCheck": true, // Skip checking .d.ts files in node_modules/
-    "noEmitOnError": true // Prevent output if there are errors
-  }
-}