@gesslar/bedoc 1.3.3 → 1.4.2

package/dist/types/cli.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-export {};
-//# sourceMappingURL=cli.d.ts.map
+export {}
+//# sourceMappingURL=cli.d.ts.map

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

@@ -2,26 +2,26 @@ import Logger from './Logger';
 import HookManager from './HookManager';
 
 export interface ActionDefinition {
-    action: string;
-    contract: Record<string, unknown>;
-    meta: Record<string, unknown>;
+  action: string;
+  contract: Record<string, unknown>;
+  meta: Record<string, unknown>;
 }
 
 export default class ActionManager {
-    constructor(actionDefinition: ActionDefinition, logger: Logger);
-    get action(): ActionDefinition;
-    set hookManager(hookManager: HookManager);
-    get hookManager(): HookManager;
-    get contract(): Record<string, unknown>;
-    get meta(): Record<string, unknown>;
-    get log(): Logger;
-    setupAction(): Promise<void>;
-    runAction({ file, content }: {
-        file: string;
-        content: string;
-    }): Promise<string>;
-    cleanupAction(): Promise<void>;
-    toString(): string;
-    #private;
+  constructor(actionDefinition: ActionDefinition, logger: Logger);
+  get action(): ActionDefinition;
+  set hookManager(hookManager: HookManager);
+  get hookManager(): HookManager;
+  get contract(): Record<string, unknown>;
+  get meta(): Record<string, unknown>;
+  get log(): Logger;
+  setupAction(): Promise<void>;
+  runAction({ file, content }: {
+    file: string;
+    content: string;
+  }): Promise<string>;
+  cleanupAction(): Promise<void>;
+  toString(): string;
+  #private;
 }
 //# sourceMappingURL=ActionManager.d.ts.map

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

@@ -1,27 +1,27 @@
-import { Environment } from './Core';
+import { EnvironmentType } from './Core';
 
 interface ConfigurationOption {
-    value: unknown;
-    source: string;
+  value: unknown;
+  source: string;
 }
 
 interface ConfigurationOptions {
-    [key: string]: ConfigurationOption;
+  [key: string]: ConfigurationOption;
 }
 
 interface ValidateParams {
-    options: ConfigurationOptions;
-    source: typeof Environment;
+  options: ConfigurationOptions;
+  source: EnvironmentType;
 }
 
 interface ValidationResult {
-    status: 'success';
-    validated: boolean;
-    [key: string]: unknown;
+  status: 'success';
+  validated: boolean;
+  [key: string]: unknown;
 }
 
 export default class Configuration {
-    validate({ options, source }: ValidateParams): Promise<ValidationResult>;
-    #private;
+  validate({ options, source }: ValidateParams): Promise<ValidationResult>;
+  #private;
 }
 //# sourceMappingURL=Configuration.d.ts.map

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

@@ -1,36 +1,36 @@
 import TypeSpec from './util/TypeSpec';
 
 interface PathConfig {
-    type: 'file' | 'directory';
-    mustExist: boolean;
+  type: 'file' | 'directory';
+  mustExist: boolean;
 }
 
 interface ConfigurationParameter {
-    short: string;
-    param?: string;
-    description: string;
-    type: TypeSpec;
-    required: boolean;
-    default?: boolean | number | string;
-    path?: PathConfig;
-    exclusiveOf?: string;
+  short: string;
+  param?: string;
+  description: string;
+  type: TypeSpec;
+  required: boolean;
+  default?: boolean | number | string;
+  path?: PathConfig;
+  exclusiveOf?: string;
 }
 
 interface ConfigurationParametersType {
-    input: ConfigurationParameter;
-    exclude: ConfigurationParameter;
-    language: ConfigurationParameter;
-    format: ConfigurationParameter;
-    maxConcurrent: ConfigurationParameter;
-    hooks: ConfigurationParameter;
-    output: ConfigurationParameter;
-    parser: ConfigurationParameter;
-    printer: ConfigurationParameter;
-    hookTimeout: ConfigurationParameter;
-    mock: ConfigurationParameter;
-    config: ConfigurationParameter;
-    debug: ConfigurationParameter;
-    debugLevel: ConfigurationParameter;
+  input: ConfigurationParameter;
+  exclude: ConfigurationParameter;
+  language: ConfigurationParameter;
+  format: ConfigurationParameter;
+  maxConcurrent: ConfigurationParameter;
+  hooks: ConfigurationParameter;
+  output: ConfigurationParameter;
+  parser: ConfigurationParameter;
+  printer: ConfigurationParameter;
+  hookTimeout: ConfigurationParameter;
+  mock: ConfigurationParameter;
+  config: ConfigurationParameter;
+  debug: ConfigurationParameter;
+  debugLevel: ConfigurationParameter;
 }
 
 export const ConfigurationParameters: Readonly<ConfigurationParametersType>;

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

@@ -3,45 +3,47 @@ import Logger from './Logger';
 import { FileMap } from './util/FDUtil';
 
 interface ProcessResult {
-    status: 'success' | 'error' | 'warning';
-    file?: FileMap;
-    error?: Error;
-    warning?: string;
-    result?: string;
-    destFile?: string;
-    content?: string;
+  status: 'success' | 'error' | 'warning';
+  file?: FileMap;
+  error?: Error;
+  warning?: string;
+  result?: string;
+  destFile?: string;
+  content?: string;
 }
 
-interface ConveyResult {
-    succeeded: Array<{ input: FileMap; output: FileMap }>;
-    errored: Array<{ input: FileMap; error: Error }>;
+export interface ConveyResult {
+  succeeded: Array<{ input: FileMap; output: FileMap }>;
+  errored: Array<{ input: FileMap; error: Error }>;
+  warned: Array<{ input: FileMap; warning: string }>;
 }
 
 export default class Conveyor {
-    constructor(
-        parse: ActionManager,
-        print: ActionManager,
-        logger: Logger,
-        output: FileMap
-    );
+  constructor(
+    parse: ActionManager,
+    print: ActionManager,
+    logger: Logger,
+    output: FileMap
+  );
 
-    readonly parse: ActionManager;
-    readonly print: ActionManager;
-    readonly logger: Logger;
-    readonly output: FileMap;
+  readonly parse: ActionManager;
+  readonly print: ActionManager;
+  readonly logger: Logger;
+  readonly output: FileMap;
 
-    /**
-     * Processes files with a concurrency limit.
-     *
-     * @param files - List of files to process.
-     * @param maxConcurrent - Maximum number of concurrent tasks.
-     * @returns Resolves when all files are processed.
-     */
-    convey(files: FileMap[], maxConcurrent?: number): Promise<ConveyResult>;
+  /**
+   * Processes files with a concurrency limit.
+   *
+   * @param files - List of files to process.
+   * @param maxConcurrent - Maximum number of concurrent tasks.
+   * @returns Resolves when all files are processed.
+   */
+  convey(files: FileMap[], maxConcurrent?: number): Promise<ConveyResult>;
 
-    #succeeded: Array<{ input: FileMap; output: FileMap }>;
-    #errored: Array<{ input: FileMap; error: Error }>;
-    #processFile(file: FileMap): Promise<ProcessResult>;
-    #writeOutput(destFile: string, content: string): Promise<ProcessResult>;
+  #succeeded: Array<{ input: FileMap; output: FileMap }>;
+  #errored: Array<{ input: FileMap; error: Error }>;
+  #warned: Array<{ input: FileMap; warning: string }>;
+  #processFile(file: FileMap): Promise<ProcessResult>;
+  #writeOutput(destFile: string, content: string): Promise<ProcessResult>;
 }
 //# sourceMappingURL=Conveyor.d.ts.map

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

@@ -1,53 +1,48 @@
 import Logger from './Logger';
 import ActionManager from './ActionManager';
-import { FileMap } from './util/FDUtil';
+import { ConveyResult} from './Conveyor';
 
 export const Environment: Readonly<{
-    EXTENSION: 'extension';
-    NPM: 'npm';
-    ACTION: 'action';
-    CLI: 'cli';
+  EXTENSION: 'extension';
+  NPM: 'npm';
+  ACTION: 'action';
+  CLI: 'cli';
 }>;
 
 export type EnvironmentType = typeof Environment[keyof typeof Environment];
 
 interface CoreOptions {
-    debug?: boolean;
-    debugLevel?: number;
-    name?: string;
-    [key: string]: unknown;
+  debug?: boolean;
+  debugLevel?: number;
+  name?: string;
+  [key: string]: unknown;
 }
 
 interface CoreConstructorOptions extends CoreOptions {
-    hooks?: string;
-    hooksTimeout?: number;
-    output?: string;
-    maxConcurrent?: number;
+  hooks?: string;
+  hooksTimeout?: number;
+  output?: string;
+  maxConcurrent?: number;
 }
 
 interface NewParams {
-    options: CoreOptions;
-    source: EnvironmentType;
-}
-
-interface ProcessResult {
-    succeeded: Array<{ input: FileMap; output: FileMap }>;
-    errored: Array<{ input: FileMap; error: Error }>;
+  options: CoreOptions;
+  source: EnvironmentType;
 }
 
 export default class Core {
-    static new({ options, source }: NewParams): Promise<Core>;
+  static new({ options, source }: NewParams): Promise<Core>;
 
-    constructor(options: CoreConstructorOptions);
+  constructor(options: CoreConstructorOptions);
 
-    readonly options: CoreConstructorOptions;
-    readonly logger: Logger;
-    readonly packageJson: Record<string, unknown>;
-    readonly debugOptions: {
-        name: string | null;
-        debugLevel: number;
-    };
-    readonly actions: Record<string, ActionManager>;
+  readonly options: CoreConstructorOptions;
+  readonly logger: Logger;
+  readonly packageJson: Record<string, unknown>;
+  readonly debugOptions: {
+    name: string | null;
+    debugLevel: number;
+  };
+  readonly actions: Record<string, ActionManager>;
 
-    processFiles(glob: string | string[], startTime?: [number, number]): Promise<ProcessResult>;
+  processFiles(glob: string | string[], startTime?: [number, number]): Promise<ConveyResult>;
 }

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

@@ -10,6 +10,14 @@ interface LoggerOptions {
 type LogLevel = 'debug' | 'warn' | 'info' | 'error';
 type DebugLevel = 0 | 1 | 2 | 3 | 4;
 
+export declare const loggerColours: {
+    debug: string[];
+    info: string;
+    warn: string;
+    error: string;
+    reset: string;
+};
+
 /**
  * Logger class
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/bedoc",
-  "version": "1.3.3",
+  "version": "1.4.2",
   "description": "Pluggable documentation engine for any language and format",
   "publisher": "gesslar",
   "main": "./src/core/Core.js",
@@ -18,6 +18,13 @@
     ".": {
       "import": "./src/core/Core.js",
       "types": "./dist/types/core/Core.d.ts"
+    },
+    "./BeDoc": {
+      "import": "./src/core/Core.js",
+      "types": "./dist/types/core/Core.d.ts"
+    },
+    "./*": {
+      "types": "./dist/types/*"
     }
   },
   "type": "module",
@@ -38,6 +45,8 @@
   },
   "devDependencies": {
     "@stylistic/eslint-plugin-js": "^3.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.22.0",
+    "@typescript-eslint/parser": "^8.22.0",
     "axios": "^1.7.9",
     "chokidar": "^4.0.3",
     "eslint": "^9.18.0",

package/src/cli.js

@@ -75,6 +75,11 @@ const {resolveDirectory} = FDUtil
     const filesToProcess = bedoc.options.input.map(f => f.absolutePath)
     const result = await bedoc.processFiles(filesToProcess)
     const errored = result.errored
+    const warned = result.warned
+
+    if(warned.length > 0)
+      warned.forEach(w => bedoc.logger.warn(w.warning))
+
     if(errored.length > 0)
       throw new AggregateError(errored.map(e => e.error), "Error processing files")
   } catch(error) {

package/src/core/Conveyor.js

@@ -6,6 +6,7 @@ const {readFile, writeFile, composeFilename} = FDUtil
 
 export default class Conveyor {
   #succeeded = []
+  #warned  = []
   #errored = []
 
   constructor(parse, print, logger, output) {
@@ -33,8 +34,10 @@ export default class Conveyor {
       const slot = Promise.race(semaphore) // Wait for an available slot
       semaphore.push(slot.then(async() => {
         const result = await this.#processFile(file)
-        if(result.status === "success" || result.status === "warning")
+        if(result.status === "success")
           this.#succeeded.push({input: file, output: result.file})
+        else if(result.status === "warning")
+          this.#warned.push({input: file, warning: result.warning})
         else {
           this.#errored.push({input: file, error: result.error})
         }
@@ -49,7 +52,11 @@ export default class Conveyor {
     await this.parse.cleanupAction()
     await this.print.cleanupAction()
 
-    return {succeeded: this.#succeeded, errored: this.#errored}
+    return {
+      succeeded: this.#succeeded,
+      errored: this.#errored,
+      warned: this.#warned
+    }
   }
 
   /**
@@ -78,7 +85,15 @@ export default class Conveyor {
       if(parseResult.status === "error")
         return parseResult
 
-      debug("Parsed file successfully: `%s`", 2, file.path)
+      if(parseResult.status === "warning")
+        debug("Parsed file successfully, but with warnings: `%s`", 2, file.path)
+      else
+        debug("Parsed file successfully: `%s`", 2, file.path)
+
+      if(!parseResult.result?.functions?.length) {
+        const mess = format("No functions found in `%s`. No file written.", file.path)
+        return {status: "warning", file, warning: mess}
+      }
 
       // Step 3: Print file
       const printResult = await print.runAction({

package/src/core/Core.js

@@ -2,7 +2,7 @@ import process from "node:process"
 
 import Discovery from "./Discovery.js"
 import HookManager from "./HookManager.js"
-import Logger from "./Logger.js"
+import Logger, {loggerColours} from "./Logger.js"
 import ParseManager from "./action/ParseManager.js"
 import PrintManager from "./action/PrintManager.js"
 import Conveyor from "./Conveyor.js"
@@ -149,11 +149,21 @@ export default class Core {
 
     // Grab the results
     const totalFiles = input.length
-    const errored = result.errored
     const succeeded = result.succeeded
+    const warned = result.warned
+    const errored = result.errored
+
+    const {
+      info: succeedColour, warn: warnColour, error: errorColour, reset
+    } = loggerColours
+
+
+    const success = `${succeedColour}${succeeded.length}${reset}`
+    const warn = `${warnColour}${warned.length}${reset}`
+    const error = `${errorColour}${errored.length}${reset}`
 
-    const message = `Processed ${totalFiles} files: ${succeeded.length} succeeded, ${errored.length} errored ` +
-      `in ${processEnd}ms [total: ${endTime}ms]`
+    const message = `Processed ${totalFiles} files: ${success} succeeded, ${error} errored, ` +
+      `${warn} warned in ${processEnd}ms [total: ${endTime}ms]`
 
     this.logger.debug(message, 1)
 

package/src/core/Logger.js

@@ -33,7 +33,7 @@ import * as StringUtil from "./util/StringUtil.js"
 const {resolveFilename} = FDUtil
 const {capitalize} = StringUtil
 
-const loggerColours = {
+export const loggerColours = {
   debug: [
     "\x1b[38;5;19m", // Debug level 0: Dark blue
     "\x1b[38;5;27m", // Debug level 1: Medium blue