@gesslar/bedoc 1.2.0 → 1.3.0

package/dist/types/cli.d.ts

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

package/dist/types/cli.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "cli.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../src/cli.js"
+  ],
+  "names": [],
+  "mappings": ""
+}

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

@@ -0,0 +1,27 @@
+import Logger from './Logger';
+import HookManager from './HookManager';
+
+export interface ActionDefinition {
+    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;
+}
+//# sourceMappingURL=ActionManager.d.ts.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ActionManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/ActionManager.js"
+  ],
+  "names": [],
+  "mappings": "AAEA;IAQE,gDAKC;IAsBD,kBAEC;IAMD,kCAQC;IAZD,uBAEC;IAYD,oBAEC;IAED,gBAEC;IAED,eAEC;IA0CD,6BAKC;IAED;;;qBAWC;IAED,+BAMC;IAED,mBAEC;;CACF"
+}

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

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

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Configuration.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Configuration.js"
+  ],
+  "names": [],
+  "mappings": "AAiBA;IACE;;;;;;OAqHC;;CAwMF"
+}

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

@@ -0,0 +1,38 @@
+import TypeSpec from './util/TypeSpec';
+
+interface PathConfig {
+    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;
+}
+
+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;
+}
+
+export const ConfigurationParameters: Readonly<ConfigurationParametersType>;
+export const ConfigurationPriorityKeys: readonly ['exclude', 'input'];
+//# sourceMappingURL=ConfigurationParameters.d.ts.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ConfigurationParameters.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/ConfigurationParameters.js"
+  ],
+  "names": [],
+  "mappings": "AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqIE;AAEF,0DAAqE"
+}

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

@@ -0,0 +1,47 @@
+import ActionManager from './ActionManager';
+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;
+}
+
+interface ConveyResult {
+    succeeded: Array<{ input: FileMap; output: FileMap }>;
+    errored: Array<{ input: FileMap; error: Error }>;
+}
+
+export default class Conveyor {
+    constructor(
+        parse: ActionManager,
+        print: ActionManager,
+        logger: Logger,
+        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>;
+
+    #succeeded: Array<{ input: FileMap; output: FileMap }>;
+    #errored: Array<{ input: FileMap; error: Error }>;
+    #processFile(file: FileMap): Promise<ProcessResult>;
+    #writeOutput(destFile: string, content: string): Promise<ProcessResult>;
+}
+//# sourceMappingURL=Conveyor.d.ts.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Conveyor.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Conveyor.js"
+  ],
+  "names": [],
+  "mappings": "AAMA;IAIE,8DAKC;IAJC,WAAkB;IAClB,WAAkB;IAClB,YAAoB;IACpB,YAAoB;IAGtB;;;;;;OAMG;IACH,qCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CA8B3B;;CAgFF"
+}

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

@@ -0,0 +1,53 @@
+import Logger from './Logger';
+import ActionManager from './ActionManager';
+import { FileMap } from './util/FDUtil';
+
+export const Environment: Readonly<{
+    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;
+}
+
+interface CoreConstructorOptions extends CoreOptions {
+    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 }>;
+}
+
+export default class Core {
+    static new({ options, source }: NewParams): Promise<Core>;
+
+    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>;
+
+    processFiles(glob: string | string[], startTime?: [number, number]): Promise<ProcessResult>;
+}

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Core.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Core.js"
+  ],
+  "names": [],
+  "mappings": "AAkBA;;;;;GAKE;AAEF;IASE;;;sBAoFC;IA5FD,0BAMC;IALC,aAAsB;IAEtB,eAAgE;IAChE,iBAAiD;IACjD;;;MAAuC;IAyFzC;;;OAsDC;CACF;mBA3KkB,aAAa"
+}

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

@@ -0,0 +1,73 @@
+import Core from './Core';
+import { FileMap } from './util/FDUtil';
+import ActionManager from './ActionManager';
+
+interface DiscoveryOptions {
+    print?: FileMap;
+    parse?: FileMap;
+}
+
+interface ActionDefinition {
+    file: FileMap;
+    action: {
+        meta: {
+            action: string;
+            [key: string]: unknown;
+        };
+    };
+    contract: Record<string, unknown>;
+}
+
+interface ActionMap {
+    print: ActionDefinition[];
+    parse: ActionDefinition[];
+    [key: string]: ActionDefinition[];
+}
+
+interface ValidCriteria {
+    parse: ActionDefinition[];
+    print: ActionDefinition[];
+}
+
+export default class Discovery {
+    constructor(core: Core);
+    readonly core: Core;
+
+    /**
+     * Discover actions from local or global node_modules
+     *
+     * @param specific Configuration options for action discovery
+     * @returns A map of discovered modules
+     */
+    discoverActions(specific?: DiscoveryOptions): Promise<ActionMap>;
+
+    /**
+     * Check which actions satisfy the configuration criteria
+     */
+    satisfyCriteria(actions: ActionMap, validatedConfig: Record<string, unknown>): ValidCriteria;
+
+    #loadModule(module: FileMap): Promise<{
+        file: FileMap;
+        actions: ActionManager[];
+        contracts: string[];
+    }>;
+
+    #getModuleExports(dirMap: FileMap): FileMap[];
+
+    #loadActionsAndContracts(
+        moduleFiles: FileMap[],
+        specific: {
+            print?: FileMap;
+            parse?: FileMap;
+        }
+    ): Promise<ActionMap>;
+
+    #validMeta(
+        actionType: string,
+        toValidate: {
+            action: ActionDefinition['action'];
+            contract: ActionDefinition['contract'];
+        }
+    ): boolean;
+}
+//# sourceMappingURL=Discovery.d.ts.map

package/dist/types/core/Discovery.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Discovery.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Discovery.js"
+  ],
+  "names": [],
+  "mappings": "AAYA;IAIE,uBAIC;IAHC,UAAgB;IAKlB;;;;;;;OAOG;IACH,0BAJG;QAAyB,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;KACd,GAAU,OAAO,CAAC,MAAM,CAAC,CAsE3B;IA6JD;;;MAiDC;;CA4DF"
+}

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

@@ -0,0 +1,60 @@
+import Logger from './Logger';
+import { FileMap } from './util/FDUtil';
+
+type HookEvent = 'start' | 'section_load' | 'enter' | 'exit' | 'end';
+
+interface HookResult {
+    status?: 'success' | 'error';
+    error?: Error;
+    [key: string]: unknown;
+}
+
+interface HooksDefinition {
+    setup?: () => Promise<void>;
+    cleanup?: () => Promise<void>;
+    start?: (...args: unknown[]) => Promise<HookResult>;
+    section_load?: (...args: unknown[]) => Promise<HookResult>;
+    enter?: (...args: unknown[]) => Promise<HookResult>;
+    exit?: (...args: unknown[]) => Promise<HookResult>;
+    end?: (...args: unknown[]) => Promise<HookResult>;
+    log?: Logger;
+}
+
+interface HookManagerConstructorParams {
+    action: string;
+    hooksFile: FileMap;
+    logger: Logger;
+    timeOut: number;
+}
+
+export const hookPoints: Readonly<Record<Uppercase<HookEvent>, HookEvent>>;
+
+export default class HookManager {
+    static new(arg: HookManagerConstructorParams): Promise<HookManager | null>;
+
+    constructor({ action, hooksFile, logger, timeOut: timeout }: HookManagerConstructorParams);
+
+    get action(): string;
+    get hooksFile(): FileMap;
+    get hooks(): HooksDefinition | null;
+    get log(): Logger;
+    get timeout(): number;
+    get setup(): (() => Promise<void>) | null;
+    get cleanup(): (() => Promise<void>) | null;
+
+    /**
+     * Trigger a hook
+     *
+     * @param event - The type of hook to trigger
+     * @param args - The hook arguments
+     * @returns The result of the hook
+     */
+    on(event: HookEvent, ...args: unknown[]): Promise<HookResult | undefined>;
+
+    #hooksFile: FileMap | null;
+    #log: Logger | null;
+    #hooks: HooksDefinition | null;
+    #action: string | null;
+    #timeout: number;
+}
+//# sourceMappingURL=HookManager.d.ts.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "HookManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/HookManager.js"
+  ],
+  "names": [],
+  "mappings": "AAUA,sCAKC;AAED;IA0CE,6CAsCC;IAzED;;;;;OAKC;IAED,kBAEC;IAED,qBAEC;IAED,iBAEC;IAED,eAEC;IAED,sBAEC;IAED,iBAEC;IAED,mBAEC;IA0CD;;;;;;OAMG;IACH,UAJW,MAAM,WACH,GAAG,EAAA,GACJ,OAAO,CAAC,GAAG,CAAC,CAsCxB;;CACF"
+}

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

@@ -0,0 +1,55 @@
+import ErrorStackParser from 'error-stack-parser';
+import * as vscode from 'vscode';
+
+interface LoggerOptions {
+    name?: string;
+    debugLevel?: number;
+    env?: string;
+}
+
+type LogLevel = 'debug' | 'warn' | 'info' | 'error';
+type DebugLevel = 0 | 1 | 2 | 3 | 4;
+
+/**
+ * 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
+ *     - 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 {
+    constructor(options?: LoggerOptions);
+
+    readonly vscodeError?: typeof vscode.window.showErrorMessage;
+    readonly vscodeWarn?: typeof vscode.window.showWarningMessage;
+    readonly vscodeInfo?: typeof vscode.window.showInformationMessage;
+
+    get name(): string;
+    get debugLevel(): number;
+    get options(): Required<Pick<LoggerOptions, 'name' | 'debugLevel'>>;
+
+    setOptions(options: LoggerOptions): void;
+
+    lastStackLine(error?: Error, stepsRemoved?: number): ErrorStackParser.StackFrame;
+    extractFileFunction(level?: DebugLevel): string;
+
+    newDebug(tag?: string): (message: string, level?: DebugLevel, ...args: unknown[]) => void;
+
+    debug(message: string, level?: DebugLevel, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+
+    #name: string | null;
+    #debugLevel: number;
+    #compose(level: LogLevel, message: string, debugLevel?: DebugLevel): string;
+}
+//# sourceMappingURL=Logger.d.ts.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Logger.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Logger.js"
+  ],
+  "names": [],
+  "mappings": "AAkDA;;;;;;;;;;;;;;;;GAgBG;AAEH;IAIE,0BAWC;IALK,iBAAiD;IACjD,gBAAkD;IAClD,gBAAsD;IAK5D,gBAEC;IAED,yBAEC;IAED;;;MAKC;IAED,+BAGC;IAWD,iFAGC;IAED,4CAoCC;IAED,wBAKC;IAED,yDAGC;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;;CACF;6BA7J4B,oBAAoB"
+}

package/dist/types/core/action/ParseManager.d.ts

@@ -0,0 +1,8 @@
+import ActionManager from '../ActionManager';
+import Logger from '../Logger';
+import { ActionDefinition } from "../ActionManager";
+
+export default class ParseManager extends ActionManager {
+    constructor(actionDefinition: ActionDefinition, logger: Logger);
+}
+//# sourceMappingURL=ParseManager.d.ts.map

package/dist/types/core/action/ParseManager.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ParseManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/action/ParseManager.js"
+  ],
+  "names": [],
+  "mappings": "AAEA;IACE,gDAEC;CACF;0BANyB,qBAAqB"
+}

package/dist/types/core/action/PrintManager.d.ts

@@ -0,0 +1,8 @@
+import ActionManager from '../ActionManager';
+import Logger from '../Logger';
+import { ActionDefinition } from "../ActionManager";
+
+export default class PrintManager extends ActionManager {
+    constructor(actionDefinition: ActionDefinition, logger: Logger);
+}
+//# sourceMappingURL=PrintManager.d.ts.map

package/dist/types/core/action/PrintManager.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "PrintManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/action/PrintManager.js"
+  ],
+  "names": [],
+  "mappings": "AAEA;IACE,gDAEC;CACF;0BANyB,qBAAqB"
+}

package/dist/types/core/util/ActionUtil.d.ts

@@ -0,0 +1,35 @@
+import { FileMap } from './FDUtil';
+
+type ActionType = 'parse' | 'print';
+
+interface ActionMeta {
+    action: ActionType;
+    language?: string;
+    format?: string;
+}
+
+interface ActionRequirement {
+    action: ActionType;
+}
+
+type ActionMetaRequirement = ActionRequirement | keyof ActionMeta;
+
+export const actionMetaRequirements: Readonly<Record<ActionType, ActionMetaRequirement[]>>;
+export const actionTypes: readonly ActionType[];
+
+/**
+ * Loads a JSON file asynchronously
+ *
+ * @param jsonFileObject - The JSON file to load
+ * @returns The parsed JSON content
+ */
+export function loadJson(jsonFileObject: FileMap): Record<string, unknown>;
+
+/**
+ * Loads the package.json file asynchronously
+ *
+ * @param basePath - The base path to use
+ * @returns The parsed package.json content
+ */
+export function loadPackageJson(basePath?: string | FileMap | null): Record<string, unknown>;
+//# sourceMappingURL=ActionUtil.d.ts.map

package/dist/types/core/util/ActionUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ActionUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/ActionUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAQA;;;;;;;GAGE;AALF,4CAA8C;AAO9C;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,MAAM,CAOlB;AAED;;;;;GAKG;AACH,2CAHW,MAAM,GAAC,MAAM,GACX,MAAM,CAOlB"
+}

package/dist/types/core/util/DataUtil.d.ts

@@ -0,0 +1,52 @@
+import Logger from '../Logger';
+import TypeSpec from './TypeSpec';
+
+type PrimitiveType = 'undefined' | 'boolean' | 'number' | 'bigint' | 'string' | 'symbol' | 'object' | 'function';
+type ConstructorType = 'object' | 'array' | 'function' | 'date' | 'regexp' | 'error' | 'map' | 'set' | 'weakmap' | 'weakset' | 'promise' | 'int8array' | 'uint8array' | 'float32array' | 'float64array';
+type DataType = PrimitiveType | ConstructorType;
+
+export const dataTypes: readonly DataType[];
+export const emptyableTypes: readonly ['string', 'array', 'object'];
+
+interface TypeSpecOptions {
+    allowEmpty?: boolean;
+}
+
+interface SchemaCompareResult {
+    status: 'success' | 'error';
+    errors: Error[];
+}
+
+export function allocateObject<T>(source: string[], spec: T[] | ((source: string[]) => Promise<T[]>)): Promise<Record<string, T>>;
+export function appendString(str: string, append: string): string;
+export function prependString(str: string, prepend: string): string;
+export function arrayIntersection<T>(arr1: T[], arr2: T[]): T[];
+export function arrayPad<T>(arr: T[], length: number, value: T, position?: 0 | -1): T[];
+export function isArrayUniform(arr: unknown[], type?: string): boolean;
+export function isArrayUnique<T>(arr: T[]): T[];
+
+export function cloneObject<T extends Record<string, unknown>>(obj: T, freeze?: boolean): T;
+export function deepFreezeObject<T extends Record<string, unknown>>(obj: T): Readonly<T>;
+export function isObjectEmpty(obj: Record<string, unknown>): boolean;
+
+export function mapObject<T extends Record<string, unknown>>(
+    original: T,
+    transformer: (key: string, value: unknown) => Promise<unknown>,
+    mutate?: boolean
+): Promise<T>;
+
+export function isNothing(value: unknown): value is null | undefined;
+export function isEmpty(value: unknown, checkForNothing?: boolean): boolean;
+export function isType(value: unknown, type: string | TypeSpec, options: TypeSpecOptions): boolean;
+export function isBaseType(value: unknown, type: DataType): boolean;
+export function isValidType(type: string): type is DataType;
+export function typeOf(value: unknown): DataType;
+
+export function newTypeSpec(str: string, options?: TypeSpecOptions): TypeSpec;
+
+export function schemaCompare(
+    schema: Record<string, unknown>,
+    definition: Record<string, unknown>,
+    stack?: string[],
+    logger?: Logger
+): SchemaCompareResult;

package/dist/types/core/util/DataUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "DataUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/DataUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAwCA,iCAA8E;AAE9E,sCAAoD;AAwGpD;;;;;;GAMG;AACH,uCAJW,GAAG,QACH,GAAG,WAAS,GACV,OAAO,CAAC,MAAM,CAAC,CA2C3B;AAtJD;;;;;;GAMG;AACH,qCAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAqCD;;;;;;GAMG;AACH,mEAEC;AAED;;;;;;;;;GASG;AACH,6CALW,MAAM,SACN,GAAG,aACH,MAAM,SAgBhB;AAED;;;;;;GAMG;AACH,iCAJW,MAAM,WACN,OAAO,GACL,MAAM,CAalB;AAqND;;;;;GAKG;AACH,sCAHW,MAAM,GACJ,MAAM,CAmBlB;AA1TD;;;;;;;GAOG;AACH,iDAJW,MAAM,GAEJ,OAAO,CAMnB;AAED;;;;;GAKG;AACH,iDAEC;AAkLD;;;;;;;;GAQG;AACH,kCAJW,GAAG,QACH,MAAM,GACJ,OAAO,CAgCnB;AAsBD;;;;;;;;GAQG;AACH,+BALW,GAAG,oBACH,OAAO,GAEL,OAAO,CAqBnB;AAtCD;;;;;GAKG;AACH,iCAHW,GAAG,GACD,OAAO,CAInB;AA1GD;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,OAAO,CAInB;AAcD;;;;;;;GAOG;AACH,8BALW,GAAG,QACH,MAAM,GAAC,QAAQ,WACf,MAAM,GACJ,OAAO,CAOnB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,GACJ,OAAO,CAInB;AApED;;;;;;;GAOG;AACH,oCALW,MAAM,kCAEN,OAAO,GACL,OAAO,CAAC,MAAM,CAAC,CAe3B;AAYD;;;;;;;GAOG;AACH,oCAJW,MAAM,WACN,MAAM,GACJ,MAAM,EAAE,CAIpB;AAxLD;;;;;;GAMG;AACH,sCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAIlB;AA8TD;;;;;;;;GAQG;AACH,sCANW,MAAM,cACN,MAAM,0BAEN,MAAM,GACJ,OAAO,CA+DnB;AAjJD;;;;;GAKG;AACH,8BAHW,GAAG,GACD,MAAM,CAIlB;qBA1ToB,eAAe"
+}

package/dist/types/core/util/FDUtil.d.ts

@@ -0,0 +1,146 @@
+export type FDType = 'file' | 'directory';
+
+export interface FileMap {
+    path: string;
+    uri: string;
+    absolutePath: string;
+    absoluteUri: string;
+    name: string;
+    module: string;
+    extension: string;
+    isFile: true;
+    isDirectory: false;
+    directory?: DirMap;
+}
+
+export interface DirMap {
+    path: string;
+    uri: string;
+    absolutePath: string;
+    absoluteUri: string;
+    name: string;
+    separator: string;
+    isFile: false;
+    isDirectory: true;
+}
+
+export interface FilenameParts {
+    basename: string;
+    dirname: string;
+    extname: string;
+}
+
+export const fdType: Readonly<Record<Uppercase<FDType>, FDType>>;
+export const fdTypes: readonly FDType[];
+
+/**
+ * Compose a directory map from a path
+ *
+ * @param {string} directory - The directory
+ * @returns {DirMap} A directory object
+ */
+export function composeDirectory(directory: string): DirMap;
+/**
+ * Compose a file path from a directory and a file
+ *
+ * @param {string|DirMap} directoryNameorObject - The directory
+ * @param {string} fileName - The file
+ * @returns {FileMap} A file object
+ */
+export function composeFilename(directoryNameorObject: string | DirMap, fileName: string): FileMap;
+/**
+ * Deconstruct a filename into parts
+ *
+ * @param {string} fileName - The filename to deconstruct
+ * @returns {FilenameParts} The filename parts
+ */
+export function deconstructFilenameToParts(fileName: string): FilenameParts;
+/**
+ * Fix slashes in a path
+ *
+ * @param {string} pathName - The path to fix
+ * @returns {string} The fixed path
+ */
+export function fixSlashes(pathName: string): string;
+/**
+ * Retrieve all files matching a specific glob pattern.
+ *
+ * @param {string|string[]} globPattern - The glob pattern(s) to search.
+ * @returns {Promise<FileMap[]>} An array of file objects
+ * @throws {Error} Throws an error for invalid input or search failure.
+ */
+export function getFiles(globPattern: string | string[]): Promise<FileMap[]>;
+/**
+ * Lists the contents of a directory.
+ *
+ * @param {string} directory - The directory to list.
+ * @returns {Promise<{files: FileMap[], directories: DirMap[]}>} The files and
+ * directories in the directory.
+ */
+export function ls(directory: string): Promise<{
+    files: FileMap[];
+    directories: DirMap[];
+}>;
+/**
+ * Map a directory to a DirMap
+ *
+ * @param {string} directoryName - The directory to map
+ * @returns {DirMap} A directory object
+ */
+export function mapDirectory(directoryName: string): DirMap;
+/**
+ * Map a file to a FileMap
+ *
+ * @param {string} fileName - The file to map
+ * @returns {FileMap} A file object
+ */
+export function mapFilename(fileName: string): FileMap;
+/**
+ * Convert a path to a URI
+ *
+ * @param {string} pathName - The path to convert
+ * @returns {string} The URI
+ * @throws {Error} If the path is not a valid file path
+ */
+export function pathToUri(pathName: string): string;
+/**
+ * Reads the content of a file synchronously.
+ *
+ * @param {FileMap} fileObject - The file map containing the file path
+ * @returns {string} The file contents
+ */
+export function readFile(fileObject: FileMap): string;
+/**
+ * Resolves a path to an absolute path
+ *
+ * @param {string} directoryName - The path to resolve
+ * @returns {DirMap} The directory object
+ * @throws {Error}
+ */
+export function resolveDirectory(directoryName: string): DirMap;
+/**
+ * Resolves a file to an absolute path
+ *
+ * @param {string} fileName - The file to resolve
+ * @param {DirMap} [directoryObject] - The directory object to resolve the
+ *                                     file in
+ * @returns {FileMap} A file object (validated)
+ * @throws {Error}
+ */
+export function resolveFilename(fileName: string, directoryObject?: DirMap | null): FileMap;
+/**
+ * Convert a URI to a path
+ *
+ * @param {string} pathName - The URI to convert
+ * @returns {string} The path
+ * @throws {Error} If the URI is not a valid file URL
+ */
+export function uriToPath(pathName: string): string;
+/**
+ * Writes content to a file synchronously.
+ *
+ * @param {FileMap} fileObject - The file map containing the file path
+ * @param {string} content - The content to write
+ */
+export function writeFile(fileObject: FileMap, content: string): void;
+//# sourceMappingURL=FDUtil.d.ts.map

package/dist/types/core/util/FDUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "FDUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/FDUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAgBA,yBAAkE;AAFlE,0BAA6C;AA0N7C;;;;;GAKG;AACH,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAjJD;;;;;;GAMG;AACH,uDAJW,MAAM,GAAC,MAAM,YACb,MAAM,GACJ,MAAM,CAiBlB;AAyCD;;;;;GAKG;AACH,qDAHW,MAAM,GACJ,MAAM,CAMlB;AAtJD;;;;;GAKG;AACH,qCAHW,MAAM,GACJ,MAAM,CAIlB;AAgJD;;;;;;GAMG;AACH,sCAJW,MAAM,GAAC,MAAM,EAAE,GACb,OAAO,CAAC,MAAM,EAAE,CAAC,CA+B7B;AAqCD;;;;;;GAMG;AACH,8BAJW,MAAM,GACJ,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC,CAsB7D;AAjID;;;;;GAKG;AACH,4CAHW,MAAM,GACJ,MAAM,CAalB;AArCD;;;;;GAKG;AACH,sCAHW,MAAM,GACJ,MAAM,CAclB;AA7GD;;;;;;GAMG;AACH,oCAJW,MAAM,GACJ,MAAM,CAUlB;AAoOD;;;;;GAKG;AACH,qCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAW3B;AA9ED;;;;;;GAMG;AACH,gDAJW,MAAM,GACJ,MAAM,CAmBlB;AA1KD;;;;;;;;GAQG;AACH,0CANW,MAAM,oBACN,MAAM,GAEJ,MAAM,CA2BlB;AAjDD;;;;;;GAMG;AACH,oCAJW,MAAM,GACJ,MAAM,CAUlB;AAqOD;;;;;GAKG;AACH,sCAHW,MAAM,WACN,MAAM,QAShB"
+}

package/dist/types/core/util/ModuleUtil.d.ts

@@ -0,0 +1,27 @@
+import { FileMap } from './FDUtil';
+
+export default class ModuleUtil {
+    /**
+     * Requires a module synchronously
+     *
+     * @param {FileMap} fileObject - The file to require
+     * @returns {unknown} The required module
+     */
+    static require(fileObject: FileMap): unknown;
+
+    /**
+     * Loads a JSON file asynchronously
+     *
+     * @param {FileMap} jsonFileObject - The JSON file to load
+     * @returns {Promise<Record<string, unknown>>} The parsed JSON content
+     */
+    static loadJson(jsonFileObject: FileMap): Promise<Record<string, unknown>>;
+
+    /**
+     * Loads the package.json file asynchronously
+     *
+     * @returns {Promise<Record<string, unknown>>} The parsed package.json content
+     */
+    static loadPackageJson(): Promise<Record<string, unknown>>;
+}
+//# sourceMappingURL=ModuleUtil.d.ts.map

package/dist/types/core/util/ModuleUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ModuleUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/ModuleUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAGA;IACE;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,gCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAO3B;IAED;;;;OAIG;IACH,0BAFa,OAAO,CAAC,MAAM,CAAC,CAO3B;CACF"
+}

package/dist/types/core/util/StringUtil.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Capitalizes the first letter of a string
+ */
+export function capitalize(str: string): string;
+//# sourceMappingURL=StringUtil.d.ts.map

package/dist/types/core/util/StringUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "StringUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/StringUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAAA;;;;;GAKG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB"
+}

package/dist/types/core/util/TypeSpec.d.ts

@@ -0,0 +1,42 @@
+import { DataType } from './DataUtil';
+
+interface TypeSpecification {
+    typeName: DataType;
+    array: boolean;
+}
+
+interface TypeSpecOptions {
+    delimiter?: string;
+    allowEmpty?: boolean;
+}
+
+interface TypeSpecJSON {
+    specs: TypeSpecification[];
+    length: number;
+    stringRepresentation: string;
+}
+
+export default class TypeSpec {
+    constructor(typeString: string, options?: TypeSpecOptions);
+
+    readonly specs: readonly TypeSpecification[];
+    readonly length: number;
+    readonly stringRepresentation: string;
+
+    toString(): string;
+    toJSON(): TypeSpecJSON;
+
+    forEach(callback: (spec: TypeSpecification) => void): void;
+    every(callback: (spec: TypeSpecification) => boolean): boolean;
+    some(callback: (spec: TypeSpecification) => boolean): boolean;
+    filter(callback: (spec: TypeSpecification) => boolean): TypeSpecification[];
+    map<T>(callback: (spec: TypeSpecification) => T): T[];
+    reduce<T>(callback: (acc: T, spec: TypeSpecification) => T, initialValue: T): T;
+    find(callback: (spec: TypeSpecification) => boolean): TypeSpecification | undefined;
+
+    match(value: unknown, options?: TypeSpecOptions): boolean;
+
+    #specs: TypeSpecification[];
+    #parse(typeString: string, options?: TypeSpecOptions): void;
+}
+//# sourceMappingURL=TypeSpec.d.ts.map

package/dist/types/core/util/TypeSpec.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "TypeSpec.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/TypeSpec.js"
+  ],
+  "names": [],
+  "mappings": "AAIA;IAGE,uCAQC;IAJC,aAAwB;IACxB,eAAgC;IAChC,6BAA2C;IAI7C,mBAMC;IAED;;;;MAOC;IAED,6BAEC;IACD,8BAEC;IACD,6BAEC;IACD,6BAEC;IACD,0BAEC;IACD,8CAEC;IACD,yBAEC;IAED,yCAqCC;;CAoBF"
+}

package/dist/types/core/util/ValidUtil.d.ts

@@ -0,0 +1,29 @@
+import TypeSpec from './TypeSpec';
+
+interface ValidTypeOptions {
+    allowEmpty?: boolean;
+}
+
+/**
+ * Validates a value against a type
+ *
+ * @throws {Error} If the value does not match the expected type
+ */
+export function validType(
+    value: unknown,
+    type: string | TypeSpec,
+    options?: ValidTypeOptions,
+    depth?: number
+): void;
+
+/**
+ * Asserts a condition
+ *
+ * @throws {Error} If the condition is not met, with optional argument in message
+ */
+export function assert(
+    condition: boolean,
+    message: string,
+    arg?: number | null
+): asserts condition;
+//# sourceMappingURL=ValidUtil.d.ts.map

package/dist/types/core/util/ValidUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ValidUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/ValidUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAsBA;;;;;;;;GAQG;AACH,kCANW,OAAO,WACP,MAAM,QAEN,MAAM,QAmBhB;AAzCD;;;;;;;GAOG;AACH,iCALW,GAAC,QACD,MAAM,YAEN,MAAM,QAQhB"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/bedoc",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Pluggable documentation engine for any language and format",
   "publisher": "gesslar",
   "main": "./src/core/Core.js",
@@ -14,12 +14,20 @@
   "bin": {
     "bedoc": "src/cli.js"
   },
+  "exports": {
+    ".": {
+      "import": "./src/core/Core.js",
+      "types": "./dist/types/core/Core.d.ts"
+    }
+  },
   "type": "module",
+  "types": "dist/types/index.d.ts",
   "scripts": {
     "lint:check": "npx eslint .",
     "lint:fix": "npx eslint . --fix"
   },
   "dependencies": {
+    "@gesslar/bedoc": "^1.2.0",
     "commander": "^13.0.0",
     "dotenv": "^16.4.7",
     "error-stack-parser": "^2.1.4",
@@ -30,7 +38,7 @@
     "yaml": "^2.7.0"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin-js": "^2.13.0",
+    "@stylistic/eslint-plugin-js": "^3.0.0",
     "axios": "^1.7.9",
     "chokidar": "^4.0.3",
     "eslint": "^9.18.0",

package/src/core/Conveyor.js

@@ -1,3 +1,5 @@
+import {format} from "node:util"
+
 import * as FDUtil from "./util/FDUtil.js"
 
 const {readFile, writeFile, composeFilename} = FDUtil
@@ -31,10 +33,11 @@ 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")
+        if(result.status === "success" || result.status === "warning")
           this.#succeeded.push({input: file, output: result.file})
-        else
+        else {
           this.#errored.push({input: file, error: result.error})
+        }
       }))
       semaphore.shift() // Remove the oldest promise
     }
@@ -57,6 +60,7 @@ export default class Conveyor {
    */
   async #processFile(file) {
     const debug = this.logger.newDebug()
+    const warn = (...arg) => this.logger.warn(...arg)
     const {parse, print} = this
 
     try {
@@ -87,9 +91,16 @@ export default class Conveyor {
       debug("Printed file successfully: `%s`", 2, file.path)
 
       // Step 4: Write output
-      const {destFile, content} = printResult
-      if(!destFile || !content)
-        return {status: "error", message: "Invalid print result"}
+      const {status: printStatus, destFile, content} = printResult
+      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")}
+      } else if(!destFile || !content) {
+        const mess = format("No content or destination file for %s", file.path)
+        warn(mess)
+        return {status: "warning", file, warning: mess}
+      }
 
       const writeResult = await this.#writeOutput(destFile, content)
 

package/src/core/Discovery.js

@@ -23,10 +23,12 @@ export default class Discovery {
   /**
    * Discover actions from local or global node_modules
    *
-   * @param {object[]} specified The specified actions to discover
+   * @param {object} [specific] Configuration options for action discovery
+   * @param {object} [specific.print] Print-related configuration options
+   * @param {object} [specific.parse] Parse-related configuration options
    * @returns {Promise<object>} A map of discovered modules
    */
-  async discoverActions({print, parse} = {}) {
+  async discoverActions(specific = {}) {
     const debug = this.#debug
 
     debug("Discovering actions", 2)
@@ -90,9 +92,7 @@ export default class Discovery {
 
     debug("Discovered %d actions", 2, bucket.length)
 
-    return await this.#loadActionsAndContracts(
-      bucket, {print: print, parse: parse}
-    )
+    return await this.#loadActionsAndContracts(bucket, specific)
   }
 
   /**

package/src/core/Logger.js

@@ -25,7 +25,6 @@
 
 import console from "node:console"
 import ErrorStackParser from "error-stack-parser"
-
 import {Environment} from "./Core.js"
 
 import * as FDUtil from "./util/FDUtil.js"
@@ -68,7 +67,6 @@ const loggerColours = {
 
 export default class Logger {
   #name = null
-  #debugMode = false
   #debugLevel = 0
 
   constructor(options) {
@@ -88,10 +86,6 @@ export default class Logger {
     return this.#name
   }
 
-  get debugMode() {
-    return this.#debugMode
-  }
-
   get debugLevel() {
     return this.#debugLevel
   }
@@ -99,14 +93,12 @@ export default class Logger {
   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
   }
 
@@ -170,7 +162,7 @@ export default class Logger {
   }
 
   debug(message, level = 0, ...arg) {
-    if(this.debugMode === true && level <= (this.debugLevel ?? 4))
+    if(level <= (this.debugLevel ?? 4))
       console.debug(this.#compose("debug", message, level), ...arg)
   }
 

package/src/core/util/DataUtil.js

@@ -247,7 +247,7 @@ function newTypeSpec(string, options) {
  * @param {object} options Additional options for checking
  * @returns {boolean} Whether the value is of the specified type
  */
-function isType(value, type, options) {
+function isType(value, type, options = {}) {
   const typeSpec = type instanceof TypeSpec ? type : newTypeSpec(type, options)
   // we're comparing a typeSpec object to a File object. this will always
   // return false. do fix.
@@ -453,6 +453,8 @@ function schemaCompare(schema, definition, stack = [], logger = new Logger()) {
 }
 
 export {
+  // Classes
+  TypeSpec,
   // Variables
   dataTypes,
   emptyableTypes,

package/src/core/util/FDUtil.js

@@ -272,7 +272,7 @@ async function ls(directory) {
  * Reads the content of a file synchronously.
  *
  * @param {object} fileObject - The file map containing the file path
- * @returns {Promise<string>} The file contents
+ * @returns {string} The file contents
  */
 function readFile(fileObject) {
   const {absolutePath} = fileObject

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "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
+  }
+}