@cparra/apexdocs/dist/index.js

Library with CLI capabilities to generate documentation for Salesforce Apex classes.

#!/usr/bin/env node
'use strict';

var errorCollector = require('./error-collector-nqPsWTwH.js');
var E = require('fp-ts/Either');
require('fp-ts/function');
require('fp-ts/TaskEither');
require('js-yaml');
require('path');
require('fp-ts/Task');
require('fp-ts/lib/Array');
require('@cparra/apex-reflection');
require('fp-ts/Option');
require('fast-xml-parser');
require('node:worker_threads');
require('node:path');
require('node:os');
require('node:fs');
require('handlebars');
require('fp-ts/boolean');
require('fp-ts/Array');
require('fs');
require('fp-ts/lib/TaskEither');
require('minimatch');
require('@salesforce/source-deploy-retrieve');
require('chalk');

function _interopNamespaceDefault(e) {
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var E__namespace = /*#__PURE__*/_interopNamespaceDefault(E);

var __defProp$1 = Object.defineProperty;
var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$1 = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp$1.call(b, prop))
      __defNormalProp$1(a, prop, b[prop]);
  if (__getOwnPropSymbols$1)
    for (var prop of __getOwnPropSymbols$1(b)) {
      if (__propIsEnum$1.call(b, prop))
        __defNormalProp$1(a, prop, b[prop]);
    }
  return a;
};
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};
function process(config) {
  return __async(this, null, function* () {
    const logger = new errorCollector.NoLogger();
    const configWithDefaults = __spreadValues$1(__spreadValues$1({}, getDefault(config)), config);
    if (!configWithDefaults.sourceDir) {
      throw new Error("sourceDir is required");
    }
    const errorCollector$1 = new errorCollector.ErrorCollector(configWithDefaults.targetGenerator);
    const reflectionDebugLogger = errorCollector.createReflectionDebugLogger(logger, (filePath, errorMessage) => {
      errorCollector$1.addFailure("other", filePath, errorMessage);
    });
    const result = yield errorCollector.Apexdocs.generate(configWithDefaults, {
      logger,
      reflectionDebugLogger,
      errorCollector: errorCollector$1
    });
    E__namespace.match(
      (errors) => {
        if (errorCollector$1.hasErrors()) {
          const details = errorCollector$1.all().map(errorCollector.ErrorCollector.format).join("\n");
          throw new Error(details);
        }
        throw errors;
      },
      () => {
      }
    )(result);
  });
}
function getDefault(config) {
  switch (config.targetGenerator) {
    case "markdown":
      return errorCollector.markdownDefaults;
    case "openapi":
      return errorCollector.openApiDefaults;
    case "changelog":
      return errorCollector.changeLogDefaults;
    default:
      throw new Error("Unknown target generator");
  }
}

var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
function defineMarkdownConfig(config) {
  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.markdownDefaults), config), {
    targetGenerator: "markdown"
  });
}
function defineOpenApiConfig(config) {
  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.openApiDefaults), config), {
    targetGenerator: "openapi"
  });
}
function defineChangelogConfig(config) {
  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.changeLogDefaults), config), {
    targetGenerator: "changelog"
  });
}

exports.skip = errorCollector.skip;
exports.templateHelpers = errorCollector.templateHelpers;
exports.defineChangelogConfig = defineChangelogConfig;
exports.defineMarkdownConfig = defineMarkdownConfig;
exports.defineOpenApiConfig = defineOpenApiConfig;
exports.process = process;