@gesslar/bedoc 1.11.0 → 2.0.0

package/src/cli.js

@@ -1,31 +1,34 @@
 #!/usr/bin/env node
 
+import {Schemer} from "@gesslar/negotiator"
+import {Data, DirectoryObject, FileObject, Glog, Sass, Tantrum, Term} from "@gesslar/toolkit"
 import {program} from "commander"
-import console from "node:console"
 import process from "node:process"
-import {fileURLToPath,URL} from "node:url"
+import url from "node:url"
 
-import BeDoc, {Environment} from "./core/Core.js"
-import {ConfigurationParameters} from "./core/ConfigurationParameters.js"
-
-import * as ActionUtil from "./core/util/ActionUtil.js"
-import * as FDUtil from "./core/util/FDUtil.js"
-
-const {loadDataFile} = ActionUtil
-const {resolveFilename,resolveDirectory} = FDUtil
+import BeDoc from "./BeDoc.js"
+import {ConfigurationParameters} from "./ConfigurationParameters.js"
+import Environment from "./Environment.js"
+import Schema from "./Schema.js"
+import CLIOutput from "./CLIOutput.js"
 
 // Main entry point
-;(async() => {
+void (async() => {
   try {
+    const glog = new Glog()
+      .withName("BeDoc")
+      .withStackTrace()
+      .noDisplayName()
+
     // Get package info
-    const basePath = resolveDirectory(process.cwd())
-    const thisPath = resolveDirectory(fileURLToPath(new URL("..", import.meta.url)))
-    const bedocPackageJson = loadDataFile(resolveFilename("package.json", thisPath))
+    const thisPath = new DirectoryObject(url.fileURLToPath(new url.URL("..", import.meta.url)))
+    const pkgJsonFile = new FileObject("package.json", thisPath)
+    const pkgJson = await pkgJsonFile.loadData()
 
     // Setup program
     program
-      .name(bedocPackageJson.name)
-      .description(bedocPackageJson.description)
+      .name(pkgJson.name)
+      .description(pkgJson.description)
 
     // Build CLI
     for(const [name, parameter] of Object.entries(ConfigurationParameters)) {
@@ -46,7 +49,7 @@ const {resolveFilename,resolveDirectory} = FDUtil
 
     // Add version option last
     program.version(
-      bedocPackageJson.version,
+      pkgJson.version,
       "-v, --version",
       "Output the version number",
     )
@@ -58,45 +61,85 @@ const {resolveFilename,resolveDirectory} = FDUtil
 
     const sources = program._optionValueSources
     const optionsWithSources = {}
+
     for(const [key, value] of Object.entries(options)) {
       const element = {
         value,
         source: sources[key],
       }
+
       optionsWithSources[key] = element
     }
 
     // Create core instance with validated config
+    const prjPath = new DirectoryObject()
+    const cliOutput = new CLIOutput({
+      basePath: prjPath,
+      terse: Boolean(options.terse),
+    })
+    const prjPkJsonFile = new FileObject("package.json", prjPath)
+    const prjPkjJson = await prjPkJsonFile.loadData()
+    const pkjBedoc = prjPkjJson?.bedoc ?? {}
+    const validateBeDocSchema = await loadSchemaValidator(thisPath)
+
     const bedoc = await BeDoc
       .new({
         options: {
           ...optionsWithSources,
-          basePath: {value: basePath, source: "cli"},
+          basePath: prjPath,
+          project: pkjBedoc,
         },
-        source: Environment.CLI
+        source: Environment.CLI,
+        glog,
+        validateBeDocSchema,
+        cliOutput
       })
 
-    const filesToProcess = bedoc.options.input.map(f => f.absolutePath)
-    const result = await bedoc.processFiles(filesToProcess)
+    if(!(bedoc instanceof BeDoc)) {
+      if(Data.isPlainObject(bedoc)) {
+        Term.info(bedoc.message)
+        process.exit(0)
+      }
+    }
+
+    Term.altScreen()
+
+    const result = await bedoc.processFiles()
+
+    Term.mainScreen()
+
+    cliOutput.render(false)
+
     const errored = result.errored
     const warned = result.warned
 
-    if(warned.length > 0)
-      warned.forEach(w => bedoc.logger.warn(w.warning))
+    if(warned?.length > 0)
+      warned.forEach(w => glog.warn(w.warning))
 
-    if(errored.length > 0)
-      throw new AggregateError(errored.map(e => e.error), "Error processing files")
-  } catch(error) {
-    if(error instanceof Error) {
-      if(error instanceof AggregateError) {
-        error.errors.forEach(e => console.error(e))
-      } else {
-        console.error(error.message, error.stack)
-      }
-    } else {
-      console.error("Error: %o", error)
+    if(errored?.length > 0) {
+      const errors = errored.map(e => e.error)
+      Tantrum.new("Error processing files", errors).report(true)
     }
 
+    process.exit(0)
+  } catch(error) {
+    Term.mainScreen()
+
+    Sass.new("Starting BeDoc", error).report(true)
+
     process.exit(1)
   }
+
+  /**
+   * Load the BeDoc action schema and return a validator function.
+   *
+   * @returns {Promise<Function>} AJV validator function
+   */
+  async function loadSchemaValidator(pkgPath) {
+    const schemaFile = new FileObject(Schema.local, pkgPath)
+    if(!(await schemaFile.exists))
+      throw Sass.new(`Missing schema at ${schemaFile.path}`)
+
+    return await Schemer.fromFile(schemaFile)
+  }
 })()

package/tsconfig.types.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    // Enable JavaScript support
+    "allowJs": true,
+    "checkJs": false,
+    "maxNodeModuleJsDepth": 0,
+    // Type declaration generation
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    // Output configuration
+    "outDir": "./dist/types",
+    "rootDir": "./src",
+    // Module system
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "target": "ES2022",
+    // Strict type checking (helps generate better types)
+    "strict": false,
+    "noImplicitAny": false,
+    "strictNullChecks": false,
+    // Additional checks
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    // Emit settings
+    "stripInternal": false,
+    "removeComments": false,
+    "preserveConstEnums": true
+  },
+  "include": [
+    "src/**/*.js"
+  ],
+  "exclude": [
+    "node_modules",
+    "tests",
+    "work",
+    "src/types",
+    "examples/"
+  ]
+}

package/LICENSE

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <https://unlicense.org>

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

@@ -1,58 +0,0 @@
-import Logger from './Logger'
-import HookManager, {HookPoints} from './HookManager'
-
-export type MetaActionType = "print" | "parse"
-
-export interface MetaDefinition {
-  action: MetaActionType
-}
-
-export interface ParseMetaDefinition extends MetaDefinition {
-  action: "parse"
-  language: string
-}
-
-export interface PrintMetaDefinition extends MetaDefinition {
-  action: "print"
-  format: string
-}
-
-export type MetaType = ParseMetaDefinition | PrintMetaDefinition
-
-export interface ActionDefinition {
-  meta: MetaType
-  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 {
-  meta: PrintMetaDefinition
-}
-
-export interface ParseActionDefinition extends ActionDefinition {
-  meta: ParseMetaDefinition
-}
-
-export default class ActionManager {
-  constructor(actionDefinition: ActionDefinition, logger: Logger)
-  get action(): ActionDefinition
-  set hookManager(hookManager: HookManager)
-  get hookManager(): HookManager
-  get contract(): string
-  get meta(): MetaType
-  get log(): Logger
-  setupAction(): Promise<void>
-  runAction({ file, content }: {
-    file: string
-    content: string
-  }): Promise<string>
-  cleanupAction(): Promise<void>
-  toString(): string
-  #private
-}
-
-export type ActionContract = string
-//# sourceMappingURL=ActionManager.d.ts.map

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

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

@@ -1,27 +0,0 @@
-import { EnvironmentType } from './Core';
-
-interface ConfigurationOption {
-  value: unknown;
-  source: string;
-}
-
-interface ConfigurationOptions {
-  [key: string]: ConfigurationOption;
-}
-
-interface ValidateParams {
-  options: ConfigurationOptions;
-  source: EnvironmentType;
-}
-
-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

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

@@ -1,38 +0,0 @@
-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

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

@@ -1,49 +0,0 @@
-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;
-}
-
-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
-  );
-
-  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 }>;
-  #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/Conveyor.d.ts.map

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

@@ -1,48 +0,0 @@
-import Logger from './Logger';
-import ActionManager from './ActionManager';
-import { ConveyResult} from './Conveyor';
-
-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;
-}
-
-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<ConveyResult>;
-}

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

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

@@ -1,73 +0,0 @@
-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

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

@@ -1,60 +0,0 @@
-import Logger from './Logger';
-import { FileMap } from './util/FDUtil';
-
-export type HookEventType = '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<HookEventType>, HookEventType>>;
-
-export default class HookManager {
-    static new(arg: HookManagerConstructorParams): Promise<HookManager | null>;
-
-    constructor({ action, hooksFile, logger, timeOut: timeout }: HookManagerConstructorParams);
-
-    get action(): string;
-    get hooksFile(): FileMap | null;
-    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: HookEventType, ...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

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