versioned-d.ts-tools 0.6.0 → 0.7.1

package/README.md

@@ -105,44 +105,71 @@ whats-new office-scripts.d.ts office-scripts-old.d.ts office-scripts-whats-new j
 
 This generates a markdown file (e.g., `excel_whats_new.md`) containing a table showing what's new between the two versions.
 
-#### Link Configuration File
+#### Configuration File
 
-You can provide an optional JSON configuration file to customize how URLs are generated for different API types using flexible templates with placeholders.
+You can provide an optional JSON configuration file to customize the output by excluding specific fields, classes, and controlling what types of declarations are included.
 
 **Configuration file format:**
 
 ```json
 {
+  "excludedFieldNames": [
+    "load", "set", "toJSON", "context", "track", "untrack"
+  ],
+  "excludedClassPatterns": [
+    "LoadOptions$", "Data$"
+  ],
+  "excludedFieldPatterns": [
+    "\\w+\\??:\\s*\".*\""
+  ],
+  "includeStaticFields": false,
+  "includeEnums": false,
   "linkConfigs": [
     {
-      "name": "Office Scripts",
       "pathPattern": "office-scripts",
-      "description": "Special URL pattern for Office Scripts",
       "globalFunctionTemplate": "/{basePath}#officescript-officescript-{fieldName}-function(1)",
       "classTemplate": "/{basePath}/officescript.{className}",
       "classMemberTemplate": "/{basePath}/officescript.{className}#officescript-officescript-{className}-{fieldName}{suffix}"
-    },
-    {
-      "name": "Standard Office Applications", 
-      "pathPattern": ".*",
-      "description": "Standard URL pattern for Excel, Word, PowerPoint, Outlook",
-      "globalFunctionTemplate": "/{basePath}#{hostName}-{fileName}-{fieldName}-function(1)",
-      "classTemplate": "/{basePath}.{className}",
-      "classMemberTemplate": "/{basePath}.{className}#{hostName}-{fileName}-{className}-{fieldName}{suffix}"
     }
   ]
 }
 ```
 
+**Configuration Options:**
+
+- **`excludedFieldNames`** - Array of exact field names to exclude from output
+- **`excludedClassPatterns`** - Array of regex patterns for class names to exclude
+- **`excludedFieldPatterns`** - Array of regex patterns for field declarations to exclude
+- **`includeStaticFields`** - Boolean to include/exclude static fields (default: true)
+- **`includeEnums`** - Boolean to include/exclude enum declarations (default: true when loading from config, false for backward compatibility when called directly)
+- **`linkConfigs`** - Array of custom URL generation templates (see Link Configuration section below)
+
+**Enum Configurability:**
+
+The `includeEnums` option provides fine-grained control over enum inclusion:
+
+- **Default behavior**: When calling the API directly, enums are excluded by default (`includeEnums: false`) for backward compatibility
+- **Config file behavior**: When loading from a config file, enums are included by default (`includeEnums: true`) unless explicitly set to false
+- **Explicit control**: Set `"includeEnums": true` to include enums, or `"includeEnums": false` to exclude them
+
+This dual-default approach ensures existing integrations continue working while enabling new functionality when explicitly configured.
+
+#### Link Configuration
+
+The `linkConfigs` section allows you to customize how URLs are generated for different API types using flexible templates with placeholders.
+```
+
 **Available Template Placeholders:**
+
 - `{basePath}` - relativePath without the trailing dot (e.g., 'javascript/api/excel/excel')
-- `{hostName}` - extracted host name (e.g., 'excel', 'office-scripts') 
+- `{hostName}` - extracted host name (e.g., 'excel', 'office-scripts')
 - `{fileName}` - extracted file name (e.g., 'excel', 'officescript')
 - `{className}` - class name in lowercase
 - `{fieldName}` - field/method name in lowercase
 - `{suffix}` - '-member(1)' for methods/functions, '-member' for properties
 
 **Template Types:**
+
 - `globalFunctionTemplate` - For namespace-level functions (global functions)
 - `classTemplate` - For class/interface URLs in the first column
 - `classMemberTemplate` - For class members (methods, properties, events)

package/dist/dts-utilities.d.ts

@@ -4,6 +4,24 @@ export interface LinkConfig {
     classTemplate: string;
     classMemberTemplate: string;
 }
+export interface WhatsNewConfig {
+    excludedFieldNames?: string[];
+    excludedClassPatterns?: string[];
+    excludedFieldPatterns?: string[];
+    includeStaticFields?: boolean;
+    includeEnums?: boolean;
+    linkConfigs?: LinkConfig[];
+    replacements?: any[];
+}
+export interface MarkdownOptions {
+    relativePath: string;
+    linkConfigs?: LinkConfig[];
+    excludedFieldNames?: string[];
+    excludedClassPatterns?: string[];
+    excludedFieldPatterns?: string[];
+    includeStaticFields?: boolean;
+    includeEnums?: boolean;
+}
 export declare const DEFAULT_LINK_CONFIGS: LinkConfig[];
 declare enum ClassType {
     Class = "Class",
@@ -42,7 +60,15 @@ export declare class APISet {
     containsField(clas: ClassStruct, field: FieldStruct): boolean;
     diff(other: APISet): APISet;
     getAsDTS(): string;
-    getAsMarkdown(relativePath: string, linkConfigs?: LinkConfig[]): string;
+    /**
+     * Generates markdown documentation for API differences.
+     * By default, all classes and fields are included in the output.
+     * Exclusions must be explicitly configured via the options.
+     *
+     * @param options - Configuration options for markdown generation
+     * @returns Markdown table string
+     */
+    getAsMarkdown(options: MarkdownOptions): string;
     sort(): void;
 }
 export declare function parseDTS(fileName: string, fileContents: string): APISet;

package/dist/dts-utilities.js

@@ -65,6 +65,21 @@ function buildLinkFromTemplate(template, relativePath, className, field) {
     }
     return result;
 }
+// Helper functions for pattern matching optimization
+function compilePatterns(patterns) {
+    if (!patterns || patterns.length === 0) {
+        return [];
+    }
+    return patterns.map(pattern => {
+        try {
+            return new RegExp(pattern);
+        }
+        catch (error) {
+            console.warn(`Invalid regex pattern "${pattern}": ${error.message}`);
+            return null;
+        }
+    }).filter(Boolean);
+}
 // Default configurations for known Office applications
 exports.DEFAULT_LINK_CONFIGS = [
     {
@@ -80,10 +95,26 @@ exports.DEFAULT_LINK_CONFIGS = [
         classMemberTemplate: "/{basePath}.{className}#{hostName}-{fileName}-{className}-{fieldName}{suffix}"
     }
 ];
-// capturing these because of eccentricities with the compiler ordering
-let topClass = null;
-let lastItem = null;
-let globalFunctionsClass = null;
+// Parsing context to encapsulate state during DTS parsing
+class ParsingContext {
+    constructor() {
+        this.topClass = null;
+        this.lastItem = null;
+        this.globalFunctionsClass = null;
+    }
+    reset() {
+        this.topClass = null;
+        this.lastItem = null;
+        this.globalFunctionsClass = null;
+    }
+    ensureGlobalFunctionsClass(allClasses) {
+        if (this.globalFunctionsClass === null) {
+            this.globalFunctionsClass = new ClassStruct("<global>", "", ClassType.Interface);
+            allClasses.addClass(this.globalFunctionsClass);
+        }
+        return this.globalFunctionsClass;
+    }
+}
 var ClassType;
 (function (ClassType) {
     ClassType["Class"] = "Class";
@@ -138,26 +169,11 @@ class APISet {
         this.api.push(clas);
     }
     containsClass(clas) {
-        let found = false;
-        this.api.forEach((element) => {
-            if (element.declarationString === clas.declarationString) {
-                found = true;
-            }
-        });
-        return found;
+        return this.api.some(element => element.declarationString === clas.declarationString);
     }
     containsField(clas, field) {
-        let found = false;
-        this.api.forEach((element) => {
-            if (element.declarationString === clas.declarationString) {
-                element.fields.forEach((thisField) => {
-                    if (thisField.declarationString === field.declarationString) {
-                        found = true;
-                    }
-                });
-            }
-        });
-        return found;
+        const targetClass = this.api.find(element => element.declarationString === clas.declarationString);
+        return targetClass ? targetClass.fields.some(thisField => thisField.declarationString === field.declarationString) : false;
     }
     // finds the new fields and classes
     diff(other) {
@@ -200,18 +216,37 @@ class APISet {
         });
         return output.join("\n");
     }
-    getAsMarkdown(relativePath, linkConfigs = exports.DEFAULT_LINK_CONFIGS) {
+    /**
+     * Generates markdown documentation for API differences.
+     * By default, all classes and fields are included in the output.
+     * Exclusions must be explicitly configured via the options.
+     *
+     * @param options - Configuration options for markdown generation
+     * @returns Markdown table string
+     */
+    getAsMarkdown(options) {
+        const finalOptions = {
+            linkConfigs: exports.DEFAULT_LINK_CONFIGS,
+            excludedFieldNames: [],
+            excludedClassPatterns: [],
+            excludedFieldPatterns: [],
+            includeStaticFields: true,
+            includeEnums: false,
+            ...options // Spread user options to override defaults
+        };
         this.sort();
+        // Pre-compile regex patterns for better performance (class patterns only)
+        const compiledClassPatterns = compilePatterns(finalOptions.excludedClassPatterns);
         // table header
         let output = "| Class | Fields | Description |\n|:---|:---|:---|\n";
         this.api.forEach((clas) => {
             // Ignore the following:
-            // - Enums.
-            // - LoadOptions interfaces
-            // - *Data classes for set/load methods
-            if (clas.type !== ClassType.Enum &&
-                !clas.getClassName().endsWith("LoadOptions") &&
-                !clas.getClassName().endsWith("Data")) {
+            // - Enums (configurable via includeEnums, default: true - enums included by default).
+            // - Classes matching excluded patterns (configurable, no defaults - all classes included unless explicitly excluded)
+            const className = clas.getClassName();
+            const isExcludedByPattern = compiledClassPatterns.some(regex => regex.test(className));
+            const isEnum = clas.type === ClassType.Enum;
+            if ((finalOptions.includeEnums || !isEnum) && !isExcludedByPattern) {
                 const className = clas.getClassName();
                 // Special handling for <global> - no link
                 if (className === "<global>") {
@@ -219,23 +254,29 @@ class APISet {
                 }
                 else {
                     output += "|[" + className + "]("
-                        + buildClassLink(relativePath, className, linkConfigs) + ")|";
+                        + buildClassLink(finalOptions.relativePath, className, finalOptions.linkConfigs) + ")|";
                 }
                 // Ignore the following:
-                // - String literal overloads.
-                // - `load`, `set`, `track`, `untrack`, and `toJSON` methods
-                // - The `context` property.
-                // - Static fields.
+                // - Fields matching excluded patterns (configurable, no defaults - all fields included unless explicitly excluded)
+                // - Excluded field names (configurable, no defaults - all field names included unless explicitly excluded)
+                // - Static fields (configurable via includeStaticFields, default: true - static fields included by default)
                 let filteredFields = clas.fields.filter((field) => {
-                    let isLiteral = field.declarationString.search(/([a-zA-Z]+)(\??:)([\n]?([ |]*\"[\w]*\"[|,\n]*)+?)([ ]*[\),])/g) >= 0;
-                    return (!isLiteral &&
-                        field.name !== "load" &&
-                        field.name !== "set" &&
-                        field.name !== "toJSON" &&
-                        field.name !== "context" &&
-                        field.name !== "track" &&
-                        field.name !== "untrack" &&
-                        !field.declarationString.includes("static "));
+                    // Check if field matches any excluded pattern
+                    // Note: Test against field declaration string, just like the original code
+                    const isExcludedByPattern = (finalOptions.excludedFieldPatterns || []).some(pattern => {
+                        try {
+                            return new RegExp(pattern, 'g').test(field.declarationString);
+                        }
+                        catch (error) {
+                            console.warn(`Invalid field regex pattern "${pattern}": ${error.message}`);
+                            return false;
+                        }
+                    });
+                    // Check if field is static and should be excluded
+                    const isStaticField = field.declarationString.includes("static ");
+                    return (!isExcludedByPattern &&
+                        !(finalOptions.excludedFieldNames || []).includes(field.name) &&
+                        (finalOptions.includeStaticFields || !isStaticField));
                 });
                 let first = true;
                 if (filteredFields.length > 0) {
@@ -270,7 +311,7 @@ class APISet {
                         newItemText = newItemText.replace(/[\s][\s]+/g, " ").replace(/\( /g, "(").replace(/ \)/g, ")").replace(/,\)/g, ")").replace(/([\w]\??: )\\\| /g, "$1"); // dprint formatting quirks
                         newItemText = newItemText.replace(/\<any\>/g, "");
                         let tableLine = "[" + newItemText + "]("
-                            + buildFieldLink(relativePath, className, field, linkConfigs) + ")|";
+                            + buildFieldLink(finalOptions.relativePath, className, field, finalOptions.linkConfigs) + ")|";
                         tableLine += removeAtLink(extractFirstSentenceFromComment(field.comment));
                         output += tableLine + "|\n";
                     });
@@ -317,18 +358,33 @@ function extractFirstSentenceFromComment(commentText) {
 function removeAtLink(commentText) {
     // Replace links with the format "{@link Foo}" with "Foo".
     commentText = commentText.replace(/{@link ([^|]*?)}/gm, "$1");
-    // Replace links with the format "{@link Foo | URL}" with "[Foo](URL)".
-    commentText = commentText.replace(/{@link ([^}]*?) \| (http.*?)}/gm, "[$1]($2)");
+    // Replace links with the format "{@link URL | text}" with just the text part.
+    commentText = commentText.replace(/{@link ([^}]*?) \| ([^}]*?)}/gm, "$2");
     return commentText;
 }
+// Cache for compiled link config patterns to avoid recompilation
+const linkConfigCache = new Map();
+function getCompiledLinkConfigs(linkConfigs) {
+    if (!linkConfigCache.has(linkConfigs)) {
+        const compiled = linkConfigs.map(config => ({
+            config,
+            regex: new RegExp(config.pathPattern)
+        }));
+        linkConfigCache.set(linkConfigs, compiled);
+    }
+    return linkConfigCache.get(linkConfigs);
+}
+function findMatchingLinkConfig(relativePath, linkConfigs = exports.DEFAULT_LINK_CONFIGS) {
+    const compiledConfigs = getCompiledLinkConfigs(linkConfigs);
+    const matchingConfig = compiledConfigs.find(({ regex }) => regex.test(relativePath));
+    return matchingConfig ? matchingConfig.config : exports.DEFAULT_LINK_CONFIGS[exports.DEFAULT_LINK_CONFIGS.length - 1];
+}
 function buildClassLink(relativePath, className, linkConfigs = exports.DEFAULT_LINK_CONFIGS) {
-    // Find the first matching configuration
-    const config = linkConfigs.find(config => new RegExp(config.pathPattern).test(relativePath)) || exports.DEFAULT_LINK_CONFIGS[exports.DEFAULT_LINK_CONFIGS.length - 1]; // fallback to last config
+    const config = findMatchingLinkConfig(relativePath, linkConfigs);
     return buildLinkFromTemplate(config.classTemplate, relativePath, className);
 }
 function buildFieldLink(relativePath, className, field, linkConfigs = exports.DEFAULT_LINK_CONFIGS) {
-    // Find the first matching configuration
-    const config = linkConfigs.find(config => new RegExp(config.pathPattern).test(relativePath)) || exports.DEFAULT_LINK_CONFIGS[exports.DEFAULT_LINK_CONFIGS.length - 1]; // fallback to last config
+    const config = findMatchingLinkConfig(relativePath, linkConfigs);
     // Use appropriate template based on whether it's a global function or class member
     if (className.trim() === "<global>") {
         return buildLinkFromTemplate(config.globalFunctionTemplate, relativePath, className, field);
@@ -338,43 +394,42 @@ function buildFieldLink(relativePath, className, field, linkConfigs = exports.DE
     }
 }
 function parseDTS(fileName, fileContents) {
-    // Reset global state for new parse
-    topClass = null;
-    lastItem = null;
-    globalFunctionsClass = null;
+    // Create parsing context to encapsulate state
+    const context = new ParsingContext();
+    context.reset();
     const node = ts.createSourceFile(fileName, fileContents, ts.ScriptTarget.ES2015, true);
     const allClasses = new APISet();
-    parseDTSInternal(node, allClasses);
+    parseDTSInternal(node, allClasses, context);
     return allClasses;
 }
-function parseDTSInternal(node, allClasses) {
+function parseDTSInternal(node, allClasses, context) {
     switch (node.kind) {
         case ts.SyntaxKind.InterfaceDeclaration:
-            parseDTSTopLevelItem(node, allClasses, ClassType.Interface);
+            parseDTSTopLevelItem(node, allClasses, ClassType.Interface, context);
             break;
         case ts.SyntaxKind.ClassDeclaration:
-            parseDTSTopLevelItem(node, allClasses, ClassType.Class);
+            parseDTSTopLevelItem(node, allClasses, ClassType.Class, context);
             break;
         case ts.SyntaxKind.EnumDeclaration:
-            parseDTSTopLevelItem(node, allClasses, ClassType.Enum);
+            parseDTSTopLevelItem(node, allClasses, ClassType.Enum, context);
             break;
         case ts.SyntaxKind.FunctionDeclaration:
-            parseDTSGlobalFunctionItem(node, allClasses);
+            parseDTSGlobalFunctionItem(node, allClasses, context);
             break;
         case ts.SyntaxKind.PropertySignature:
-            parseDTSFieldItem(node, FieldType.Property);
+            parseDTSFieldItem(node, FieldType.Property, context);
             break;
         case ts.SyntaxKind.PropertyDeclaration:
-            parseDTSFieldItem(node, FieldType.Property);
+            parseDTSFieldItem(node, FieldType.Property, context);
             break;
         case ts.SyntaxKind.EnumMember:
-            parseDTSFieldItem(node, FieldType.Enum);
+            parseDTSFieldItem(node, FieldType.Enum, context);
             break;
         case ts.SyntaxKind.MethodSignature:
-            parseDTSFieldItem(node, FieldType.Method);
+            parseDTSFieldItem(node, FieldType.Method, context);
             break;
         case ts.SyntaxKind.MethodDeclaration:
-            parseDTSFieldItem(node, FieldType.Method);
+            parseDTSFieldItem(node, FieldType.Method, context);
             break;
         case ts.SyntaxKind.TypeLiteral:
             return;
@@ -382,39 +437,36 @@ function parseDTSInternal(node, allClasses) {
             // the compiler parses comments after the class/field, therefore this connects to the previous item
             if (node.getText().indexOf("/**") >= 0 &&
                 node.getText().indexOf("*/") >= 0 &&
-                lastItem !== null &&
-                lastItem.comment === "") {
+                context.lastItem !== null &&
+                context.lastItem.comment === "") {
                 // clean up spacing as best we can for the diffed d.ts
-                lastItem.comment = node.getText().replace(/    \*/g, "*");
-                if (lastItem.comment.indexOf("@eventproperty") >= 0) {
+                context.lastItem.comment = node.getText().replace(/    \*/g, "*");
+                if (context.lastItem.comment.indexOf("@eventproperty") >= 0) {
                     // events are indistinguishable from properties aside from this tag
-                    lastItem.type = FieldType.Event;
+                    context.lastItem.type = FieldType.Event;
                 }
             }
     }
     node.getChildren().forEach((element) => {
-        parseDTSInternal(element, allClasses);
+        parseDTSInternal(element, allClasses, context);
     });
 }
-function parseDTSTopLevelItem(node, allClasses, type) {
-    topClass = new ClassStruct("export " + type.toLowerCase() + " " + node.name.text, "", type);
-    allClasses.addClass(topClass);
-    lastItem = topClass;
+function parseDTSTopLevelItem(node, allClasses, type, context) {
+    context.topClass = new ClassStruct("export " + type.toLowerCase() + " " + node.name.text, "", type);
+    allClasses.addClass(context.topClass);
+    context.lastItem = context.topClass;
 }
-function parseDTSFieldItem(node, type) {
+function parseDTSFieldItem(node, type, context) {
     const newField = new FieldStruct(node.getText(), "", type, node.name.getText());
-    topClass.fields.push(newField);
-    lastItem = newField;
+    context.topClass.fields.push(newField);
+    context.lastItem = newField;
 }
-function parseDTSGlobalFunctionItem(node, allClasses) {
+function parseDTSGlobalFunctionItem(node, allClasses, context) {
     // Create a "<global>" class to hold top-level functions if it doesn't exist
-    if (globalFunctionsClass === null) {
-        globalFunctionsClass = new ClassStruct("<global>", "", ClassType.Interface);
-        allClasses.addClass(globalFunctionsClass);
-    }
+    const globalClass = context.ensureGlobalFunctionsClass(allClasses);
     const functionName = node.name ? node.name.getText() : "anonymous";
     const newFunction = new FieldStruct(node.getText(), "", FieldType.Function, functionName);
-    globalFunctionsClass.fields.push(newFunction);
-    lastItem = newFunction;
+    globalClass.fields.push(newFunction);
+    context.lastItem = newFunction;
 }
 //# sourceMappingURL=dts-utilities.js.map

package/dist/whats-new.d.ts

@@ -1,3 +1,20 @@
 #!/usr/bin/env node
 import { LinkConfig } from './dts-utilities';
-export declare function generateWhatsNew(newDtsPath: string, oldDtsPath: string, outputPath: string, relativePath: string, linkConfigs?: LinkConfig[], configFilePath?: string): void;
+export interface WhatsNewOptions {
+    newDtsPath: string;
+    oldDtsPath: string;
+    outputPath: string;
+    relativePath: string;
+    linkConfigs?: LinkConfig[];
+    configFilePath?: string;
+    excludedFieldNames?: string[];
+    excludedClassPatterns?: string[];
+    excludedFieldPatterns?: string[];
+    includeStaticFields?: boolean;
+    includeEnums?: boolean;
+}
+/**
+ * Generates "what's new" documentation by comparing two TypeScript definition files.
+ * @param options - Configuration options for the generation
+ */
+export declare function generateWhatsNew(options: WhatsNewOptions): void;

package/dist/whats-new.js

@@ -38,48 +38,95 @@ exports.generateWhatsNew = generateWhatsNew;
 const fsx = __importStar(require("fs-extra"));
 const dts_utilities_1 = require("./dts-utilities");
 /**
- * Loads link configuration from a JSON file
+ * Loads configuration from a JSON file
  * @param configFilePath Path to the configuration file
- * @returns Array of LinkConfig objects
+ * @returns Configuration object with linkConfigs, excludedFieldNames, excludedClassPatterns, excludedFieldPatterns, includeStaticFields, and includeEnums
  */
-function loadLinkConfig(configFilePath) {
+function loadWhatsNewConfig(configFilePath) {
     try {
         const configContent = fsx.readFileSync(configFilePath, 'utf8');
         const config = JSON.parse(configContent);
-        // Validate that the config has the required template properties
-        return config.linkConfigs.map((item) => {
-            if (!item.globalFunctionTemplate || !item.classTemplate || !item.classMemberTemplate) {
-                throw new Error(`Configuration item missing required template properties: ${JSON.stringify(item)}`);
-            }
-            return {
-                pathPattern: item.pathPattern,
-                globalFunctionTemplate: item.globalFunctionTemplate,
-                classTemplate: item.classTemplate,
-                classMemberTemplate: item.classMemberTemplate
-            };
-        });
+        let linkConfigs = undefined;
+        // Handle linkConfigs if present
+        if (config.linkConfigs) {
+            linkConfigs = config.linkConfigs.map((item) => {
+                if (!item.globalFunctionTemplate || !item.classTemplate || !item.classMemberTemplate) {
+                    throw new Error(`Configuration item missing required template properties: ${JSON.stringify(item)}`);
+                }
+                return {
+                    pathPattern: item.pathPattern,
+                    globalFunctionTemplate: item.globalFunctionTemplate,
+                    classTemplate: item.classTemplate,
+                    classMemberTemplate: item.classMemberTemplate
+                };
+            });
+        }
+        return {
+            linkConfigs,
+            excludedFieldNames: config.excludedFieldNames,
+            excludedClassPatterns: config.excludedClassPatterns,
+            excludedFieldPatterns: config.excludedFieldPatterns,
+            includeStaticFields: config.includeStaticFields,
+            includeEnums: config.includeEnums
+        };
     }
     catch (error) {
         console.warn(`Could not load config file ${configFilePath}: ${error}. Using default configuration.`);
-        return [];
+        return {};
     }
 }
-function generateWhatsNew(newDtsPath, oldDtsPath, outputPath, relativePath, linkConfigs, configFilePath) {
+/**
+ * Generates "what's new" documentation by comparing two TypeScript definition files.
+ * @param options - Configuration options for the generation
+ */
+function generateWhatsNew(options) {
     // Load configuration from file if provided
-    let effectiveLinkConfigs = linkConfigs;
-    if (configFilePath && !linkConfigs) {
-        effectiveLinkConfigs = loadLinkConfig(configFilePath);
+    let effectiveLinkConfigs = options.linkConfigs;
+    let effectiveExcludedFieldNames = options.excludedFieldNames;
+    let effectiveExcludedClassPatterns = options.excludedClassPatterns;
+    let effectiveExcludedFieldPatterns = options.excludedFieldPatterns;
+    let effectiveIncludeStaticFields = options.includeStaticFields;
+    let effectiveIncludeEnums = options.includeEnums;
+    if (options.configFilePath && (!options.linkConfigs || !options.excludedFieldNames || !options.excludedClassPatterns || !options.excludedFieldPatterns || options.includeStaticFields === undefined || options.includeEnums === undefined)) {
+        const config = loadWhatsNewConfig(options.configFilePath);
+        if (!options.linkConfigs && config.linkConfigs) {
+            effectiveLinkConfigs = config.linkConfigs;
+        }
+        if (!options.excludedFieldNames && config.excludedFieldNames) {
+            effectiveExcludedFieldNames = config.excludedFieldNames;
+        }
+        if (!options.excludedClassPatterns && config.excludedClassPatterns) {
+            effectiveExcludedClassPatterns = config.excludedClassPatterns;
+        }
+        if (!options.excludedFieldPatterns && config.excludedFieldPatterns) {
+            effectiveExcludedFieldPatterns = config.excludedFieldPatterns;
+        }
+        if (options.includeStaticFields === undefined && config.includeStaticFields !== undefined) {
+            effectiveIncludeStaticFields = config.includeStaticFields;
+        }
+        if (options.includeEnums === undefined) {
+            // Default to true when loading from config (inclusive by default)
+            effectiveIncludeEnums = config.includeEnums !== undefined ? config.includeEnums : true;
+        }
     }
     // read whole files
-    let wholeRelease = fsx.readFileSync(oldDtsPath).toString();
-    let wholePreview = fsx.readFileSync(newDtsPath).toString();
+    let wholeRelease = fsx.readFileSync(options.oldDtsPath).toString();
+    let wholePreview = fsx.readFileSync(options.newDtsPath).toString();
     const releaseAPI = (0, dts_utilities_1.parseDTS)("release", wholeRelease);
     const previewAPI = (0, dts_utilities_1.parseDTS)("preview", wholePreview);
     const diffAPI = previewAPI.diff(releaseAPI);
-    if (!fsx.existsSync(outputPath + ".md")) {
-        fsx.createFileSync(outputPath + ".md");
+    if (!fsx.existsSync(options.outputPath + ".md")) {
+        fsx.createFileSync(options.outputPath + ".md");
     }
-    fsx.writeFileSync(outputPath + ".md", diffAPI.getAsMarkdown(relativePath, effectiveLinkConfigs));
+    fsx.writeFileSync(options.outputPath + ".md", diffAPI.getAsMarkdown({
+        relativePath: options.relativePath,
+        linkConfigs: effectiveLinkConfigs,
+        excludedFieldNames: effectiveExcludedFieldNames,
+        excludedClassPatterns: effectiveExcludedClassPatterns,
+        excludedFieldPatterns: effectiveExcludedFieldPatterns,
+        includeStaticFields: effectiveIncludeStaticFields,
+        includeEnums: effectiveIncludeEnums
+    }));
 }
 // CLI entry point
 if (require.main === module) {
@@ -99,7 +146,13 @@ if (require.main === module) {
         console.log(`Using configuration file: ${configFilePath}`);
     }
     tryCatch(async () => {
-        generateWhatsNew(newDtsPath, oldDtsPath, outputPath, relativePath, undefined, configFilePath);
+        generateWhatsNew({
+            newDtsPath,
+            oldDtsPath,
+            outputPath,
+            relativePath,
+            configFilePath
+        });
     });
 }
 async function tryCatch(call) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versioned-d.ts-tools",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Tools for managing versioned TypeScript definition files",
   "main": "dist/index.js",
   "bin": {