versioned-d.ts-tools 0.7.2 → 0.7.3

package/dist/dts-utilities.d.ts

@@ -10,6 +10,7 @@ export interface WhatsNewConfig {
     excludedFieldPatterns?: string[];
     includeStaticFields?: boolean;
     includeEnums?: boolean;
+    filterUnionAdditions?: boolean;
     linkConfigs?: LinkConfig[];
     replacements?: any[];
 }
@@ -21,6 +22,7 @@ export interface MarkdownOptions {
     excludedFieldPatterns?: string[];
     includeStaticFields?: boolean;
     includeEnums?: boolean;
+    filterUnionAdditions?: boolean;
 }
 export declare const DEFAULT_LINK_CONFIGS: LinkConfig[];
 declare enum ClassType {
@@ -57,7 +59,23 @@ export declare class APISet {
     constructor();
     addClass(clas: ClassStruct): void;
     containsClass(clas: ClassStruct): boolean;
+    /**
+     * Checks if two field declaration strings are equivalent except for additional union types.
+     * This helps filter out noise from new union options being added to existing parameters.
+     */
+    private isOnlyUnionAddition;
     containsField(clas: ClassStruct, field: FieldStruct): boolean;
+    containsFieldOrUnionAddition(clas: ClassStruct, field: FieldStruct): boolean;
+    /**
+     * Checks if a class name appears only in union type contexts and not as standalone types.
+     * Returns true if the class only appears in union expressions like "Range | RangeAreas"
+     * and doesn't appear as standalone return types or parameters.
+     */
+    /**
+     * Checks if a class with filtered fields should be excluded due to union-only changes.
+     * This is called during markdown generation after field exclusions have been applied.
+     */
+    private shouldExcludeClassForUnionFiltering;
     diff(other: APISet): APISet;
     getAsDTS(): string;
     /**

package/dist/dts-utilities.js

@@ -165,10 +165,125 @@ class APISet {
     containsClass(clas) {
         return this.api.some(element => element.declarationString === clas.declarationString);
     }
+    /**
+     * Checks if two field declaration strings are equivalent except for additional union types.
+     * This helps filter out noise from new union options being added to existing parameters.
+     */
+    isOnlyUnionAddition(newDeclaration, oldDeclaration) {
+        // If they're identical, no difference at all
+        if (newDeclaration === oldDeclaration) {
+            return false;
+        }
+        // More sophisticated approach: extract and compare union types from specific parameters
+        // This handles cases where union additions are in the middle of parameter lists
+        // Normalize whitespace first
+        const oldNormalized = oldDeclaration.replace(/\s+/g, ' ').trim();
+        const newNormalized = newDeclaration.replace(/\s+/g, ' ').trim();
+        // Find all union type patterns in both declarations
+        // Pattern matches: paramName?: Type1 | Type2 | Type3
+        const unionPattern = /(\w+\?\s*:\s*)([^;,)]+)/g;
+        const oldUnions = new Map();
+        const newUnions = new Map();
+        let match;
+        // Extract union types from old declaration
+        unionPattern.lastIndex = 0;
+        while ((match = unionPattern.exec(oldNormalized)) !== null) {
+            const paramName = match[1].trim();
+            const unionString = match[2].trim();
+            const unionTypes = unionString.split('|').map(t => t.trim().replace(/^["']|["']$/g, ''));
+            oldUnions.set(paramName, unionTypes);
+        }
+        // Extract union types from new declaration
+        unionPattern.lastIndex = 0;
+        while ((match = unionPattern.exec(newNormalized)) !== null) {
+            const paramName = match[1].trim();
+            const unionString = match[2].trim();
+            const unionTypes = unionString.split('|').map(t => t.trim().replace(/^["']|["']$/g, ''));
+            newUnions.set(paramName, unionTypes);
+        }
+        // Check if we found any union parameters
+        if (oldUnions.size === 0 || newUnions.size === 0) {
+            return false;
+        }
+        // Check if the parameters are the same except for union additions
+        let hasUnionAddition = false;
+        for (const [paramName, oldTypes] of oldUnions) {
+            const newTypes = newUnions.get(paramName);
+            if (!newTypes) {
+                // Parameter removed, not a union addition
+                return false;
+            }
+            // Check if all old types are present in new types
+            const allOldTypesPresent = oldTypes.every(oldType => newTypes.some(newType => newType === oldType));
+            if (!allOldTypesPresent) {
+                // Types were removed or changed, not just added
+                return false;
+            }
+            // Check if new types were added
+            if (newTypes.length > oldTypes.length) {
+                hasUnionAddition = true;
+            }
+        }
+        // Check for any completely new parameters (not allowed for union addition)
+        for (const paramName of newUnions.keys()) {
+            if (!oldUnions.has(paramName)) {
+                return false;
+            }
+        }
+        return hasUnionAddition;
+    }
     containsField(clas, field) {
         const targetClass = this.api.find(element => element.declarationString === clas.declarationString);
         return targetClass ? targetClass.fields.some(thisField => thisField.declarationString === field.declarationString) : false;
     }
+    containsFieldOrUnionAddition(clas, field) {
+        const targetClass = this.api.find(element => element.declarationString === clas.declarationString);
+        if (!targetClass) {
+            return false;
+        }
+        return targetClass.fields.some(thisField => {
+            // Exact match
+            if (thisField.declarationString === field.declarationString) {
+                return true;
+            }
+            // Check if it's only a union addition
+            return this.isOnlyUnionAddition(field.declarationString, thisField.declarationString);
+        });
+    }
+    /**
+     * Checks if a class name appears only in union type contexts and not as standalone types.
+     * Returns true if the class only appears in union expressions like "Range | RangeAreas"
+     * and doesn't appear as standalone return types or parameters.
+     */
+    /**
+     * Checks if a class with filtered fields should be excluded due to union-only changes.
+     * This is called during markdown generation after field exclusions have been applied.
+     */
+    shouldExcludeClassForUnionFiltering(clas, originalFields, excludedFieldPatterns = [], excludedFieldNames = []) {
+        // If no fields in the class, don't exclude for union reasons
+        if (originalFields.length === 0) {
+            return false;
+        }
+        // First filter out excluded fields to see what would actually be displayed
+        const visibleFields = originalFields.filter(field => {
+            const isExcludedByPattern = excludedFieldPatterns.some(pattern => {
+                try {
+                    return new RegExp(pattern, 'g').test(field.declarationString);
+                }
+                catch (error) {
+                    return false;
+                }
+            });
+            const isExcludedByName = excludedFieldNames.includes(field.name);
+            return !isExcludedByPattern && !isExcludedByName;
+        });
+        // If no fields would be visible after exclusions, and all original fields contain unions,
+        // then this class likely appears only due to union additions in other classes
+        if (visibleFields.length === 0 && originalFields.every(field => field.declarationString.includes('|'))) {
+            return true;
+        }
+        return false;
+    }
     // finds the new fields and classes
     diff(other) {
         const diffAPI = new APISet();
@@ -176,16 +291,21 @@ class APISet {
             if (other.containsClass(element)) {
                 let classShell = null;
                 element.fields.forEach((field) => {
-                    if (!other.containsField(element, field)) {
+                    const fieldExists = other.containsField(element, field);
+                    if (!fieldExists) {
                         if (classShell === null) {
                             classShell = element.copyWithoutFields();
-                            diffAPI.addClass(classShell);
                         }
                         classShell.fields.push(field);
                     }
                 });
+                // Only add the class to diffAPI if it has fields after filtering
+                if (classShell !== null && classShell.fields.length > 0) {
+                    diffAPI.addClass(classShell);
+                }
             }
             else {
+                // Add new classes to the diff
                 diffAPI.addClass(element);
             }
         });
@@ -242,19 +362,15 @@ class APISet {
             const isEnum = clas.type === ClassType.Enum;
             if ((finalOptions.includeEnums || !isEnum) && !isExcludedByPattern) {
                 const className = clas.getClassName();
-                // Special handling for <global> - no link
-                if (className === "<global>") {
-                    output += "|*global*|";
-                }
-                else {
-                    output += "|[" + className + "]("
-                        + buildClassLink(finalOptions.relativePath, className, finalOptions.linkConfigs) + ")|";
+                // Apply union filtering if enabled - check if this class should be filtered out BEFORE field filtering
+                if (finalOptions.filterUnionAdditions) {
+                    if (this.shouldExcludeClassForUnionFiltering(clas, clas.fields, finalOptions.excludedFieldPatterns || [], finalOptions.excludedFieldNames || [])) {
+                        // Skip this class as it only contains union-related changes
+                        return;
+                    }
                 }
-                // Ignore the following:
-                // - 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) => {
+                // Apply field filtering after union filtering check
+                const filteredFields = clas.fields.filter((field) => {
                     // Check if field matches any excluded pattern
                     // Note: Test against field declaration string, just like the original code
                     const isExcludedByPattern = (finalOptions.excludedFieldPatterns || []).some(pattern => {
@@ -272,6 +388,19 @@ class APISet {
                         !(finalOptions.excludedFieldNames || []).includes(field.name) &&
                         (finalOptions.includeStaticFields || !isStaticField));
                 });
+                // Special handling for <global> - no link
+                if (className === "<global>") {
+                    output += "|*global*|";
+                }
+                else {
+                    output += "|[" + className + "]("
+                        + buildClassLink(finalOptions.relativePath, className, finalOptions.linkConfigs) + ")|";
+                }
+                // Ignore the following:
+                // - 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)
+                // (filteredFields already computed above)
                 let first = true;
                 if (filteredFields.length > 0) {
                     filteredFields.forEach((field) => {
@@ -311,7 +440,8 @@ class APISet {
                     });
                 }
                 else {
-                    output += "||\n";
+                    // When all fields are excluded, still show the class description
+                    output += "|" + removeAtLink(extractFirstSentenceFromComment(clas.comment)) + "|\n";
                 }
             }
         });

package/dist/whats-new.d.ts

@@ -12,6 +12,7 @@ export interface WhatsNewOptions {
     excludedFieldPatterns?: string[];
     includeStaticFields?: boolean;
     includeEnums?: boolean;
+    filterUnionAdditions?: boolean;
 }
 /**
  * Generates "what's new" documentation by comparing two TypeScript definition files.

package/dist/whats-new.js

@@ -40,7 +40,7 @@ const dts_utilities_1 = require("./dts-utilities");
 /**
  * Loads configuration from a JSON file
  * @param configFilePath Path to the configuration file
- * @returns Configuration object with linkConfigs, excludedFieldNames, excludedClassPatterns, excludedFieldPatterns, includeStaticFields, and includeEnums
+ * @returns Configuration object with linkConfigs, excludedFieldNames, excludedClassPatterns, excludedFieldPatterns, includeStaticFields, includeEnums, and filterUnionAdditions
  */
 function loadWhatsNewConfig(configFilePath) {
     try {
@@ -67,7 +67,8 @@ function loadWhatsNewConfig(configFilePath) {
             excludedClassPatterns: config.excludedClassPatterns,
             excludedFieldPatterns: config.excludedFieldPatterns,
             includeStaticFields: config.includeStaticFields,
-            includeEnums: config.includeEnums
+            includeEnums: config.includeEnums,
+            filterUnionAdditions: config.filterUnionAdditions
         };
     }
     catch (error) {
@@ -87,7 +88,8 @@ function generateWhatsNew(options) {
     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)) {
+    let effectiveFilterUnionAdditions = options.filterUnionAdditions;
+    if (options.configFilePath && (!options.linkConfigs || !options.excludedFieldNames || !options.excludedClassPatterns || !options.excludedFieldPatterns || options.includeStaticFields === undefined || options.includeEnums === undefined || options.filterUnionAdditions === undefined)) {
         const config = loadWhatsNewConfig(options.configFilePath);
         if (!options.linkConfigs && config.linkConfigs) {
             effectiveLinkConfigs = config.linkConfigs;
@@ -108,6 +110,9 @@ function generateWhatsNew(options) {
             // Default to true when loading from config (inclusive by default)
             effectiveIncludeEnums = config.includeEnums !== undefined ? config.includeEnums : true;
         }
+        if (options.filterUnionAdditions === undefined && config.filterUnionAdditions !== undefined) {
+            effectiveFilterUnionAdditions = config.filterUnionAdditions;
+        }
     }
     // read whole files
     let wholeRelease = fsx.readFileSync(options.oldDtsPath).toString();
@@ -125,7 +130,8 @@ function generateWhatsNew(options) {
         excludedClassPatterns: effectiveExcludedClassPatterns,
         excludedFieldPatterns: effectiveExcludedFieldPatterns,
         includeStaticFields: effectiveIncludeStaticFields,
-        includeEnums: effectiveIncludeEnums
+        includeEnums: effectiveIncludeEnums,
+        filterUnionAdditions: effectiveFilterUnionAdditions
     }));
 }
 // CLI entry point

package/package.json

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