versioned-d.ts-tools 0.7.4 → 0.8.0

package/dist/dts-utilities.d.ts

@@ -3,6 +3,7 @@ export interface LinkConfig {
     globalFunctionTemplate: string;
     classTemplate: string;
     classMemberTemplate: string;
+    enumTemplate?: string;
 }
 export interface WhatsNewConfig {
     excludedFieldNames?: string[];

package/dist/dts-utilities.js

@@ -45,17 +45,43 @@ const ts = __importStar(require("typescript"));
 // {suffix} - "-member(1)" for methods/functions, "-member" for properties
 // Default link builder using templates
 function buildLinkFromTemplate(template, relativePath, className, field) {
-    const basePath = relativePath.substring(0, relativePath.lastIndexOf("."));
-    const hostName = relativePath.includes("/api/")
-        ? relativePath.substring(relativePath.indexOf("/api/") + 5, relativePath.lastIndexOf("/"))
-        : "";
-    const fileName = relativePath.substring(relativePath.lastIndexOf("/") + 1, relativePath.lastIndexOf("."));
+    // Handle relativePath with or without a dot
+    const lastDotIndex = relativePath.lastIndexOf(".");
+    const basePath = lastDotIndex >= 0
+        ? relativePath.substring(0, lastDotIndex)
+        : relativePath;
+    // Extract hostName - the part after /api/ (e.g., "outlook" from "javascript/api/outlook")
+    let hostName = "";
+    if (relativePath.includes("/api/")) {
+        const afterApi = relativePath.substring(relativePath.indexOf("/api/") + 5);
+        // If there's a slash after /api/, take up to that slash; otherwise take the whole thing or up to the dot
+        const nextSlashIndex = afterApi.indexOf("/");
+        if (nextSlashIndex >= 0) {
+            hostName = afterApi.substring(0, nextSlashIndex);
+        }
+        else if (lastDotIndex >= 0) {
+            hostName = afterApi.substring(0, afterApi.indexOf("."));
+        }
+        else {
+            hostName = afterApi;
+        }
+    }
+    const lastSlashIndex = relativePath.lastIndexOf("/");
+    const fileName = lastDotIndex >= 0
+        ? relativePath.substring(lastSlashIndex + 1, lastDotIndex)
+        : relativePath.substring(lastSlashIndex + 1);
     let result = template
         .replace(/{basePath}/g, basePath)
         .replace(/{hostName}/g, hostName)
         .replace(/{fileName}/g, fileName);
     if (className && className !== "<global>") {
-        result = result.replace(/{className}/g, className.toLowerCase());
+        const lowerClassName = className.toLowerCase();
+        // For classes that already have namespace prefix (e.g., Office.MailboxEnums.ActionType),
+        // remove "office." from template since it's already in the className
+        if (lowerClassName.startsWith("office.")) {
+            result = result.replace(/\/office\.{className}/g, "/{className}");
+        }
+        result = result.replace(/{className}/g, lowerClassName);
     }
     if (field) {
         const suffix = (field.type === FieldType.Method || field.type === FieldType.Function) ? "-member(1)" : "-member";
@@ -85,8 +111,9 @@ exports.DEFAULT_LINK_CONFIGS = [
     {
         pathPattern: ".*", // matches any path as fallback
         globalFunctionTemplate: "/{basePath}#{hostName}-{fileName}-{fieldName}-function(1)",
-        classTemplate: "/{basePath}.{className}",
-        classMemberTemplate: "/{basePath}.{className}#{hostName}-{fileName}-{className}-{fieldName}{suffix}"
+        classTemplate: "/{basePath}/office.{className}",
+        classMemberTemplate: "/{basePath}/office.{className}#{hostName}-office-{className}-{fieldName}{suffix}",
+        enumTemplate: "/{basePath}/office.{className}"
     }
 ];
 // Parsing context to encapsulate state during DTS parsing
@@ -95,11 +122,19 @@ class ParsingContext {
         this.topClass = null;
         this.lastItem = null;
         this.globalFunctionsClass = null;
+        this.namespaceStack = [];
     }
     reset() {
         this.topClass = null;
         this.lastItem = null;
         this.globalFunctionsClass = null;
+        this.namespaceStack = [];
+    }
+    getFullyQualifiedName(name) {
+        if (this.namespaceStack.length === 0) {
+            return name;
+        }
+        return this.namespaceStack.join(".") + "." + name;
     }
     ensureGlobalFunctionsClass(allClasses) {
         if (this.globalFunctionsClass === null) {
@@ -413,8 +448,12 @@ class APISet {
                     output += "|*global*|";
                 }
                 else {
-                    output += "|[" + className + "]("
-                        + buildClassLink(finalOptions.relativePath, className, finalOptions.linkConfigs) + ")|";
+                    // For enums, display only the simple name but use full qualified name in the link
+                    const displayName = isEnum && className.includes(".")
+                        ? className.substring(className.lastIndexOf(".") + 1)
+                        : className;
+                    output += "|[" + displayName + "]("
+                        + buildClassLink(finalOptions.relativePath, className, finalOptions.linkConfigs, isEnum) + ")|";
                 }
                 // Ignore the following:
                 // - Fields matching excluded patterns (configurable, no defaults - all fields included unless explicitly excluded)
@@ -432,7 +471,11 @@ class APISet {
                         }
                         // remove unnecessary parts of the declaration string
                         let newItemText = field.declarationString.replace(/;/g, "");
-                        if (field.type === FieldType.Property) {
+                        if (field.type === FieldType.Enum) {
+                            // For enum members, just use the field name as-is
+                            newItemText = field.name;
+                        }
+                        else if (field.type === FieldType.Property) {
                             // Remove the optional modifier and type.
                             newItemText = newItemText.replace(/\?/g, "");
                             newItemText = newItemText.substring(0, newItemText.indexOf(":"));
@@ -453,8 +496,16 @@ class APISet {
                         newItemText = newItemText.replace(/\|/g, "\\|").replace(/\n|\t/gm, "");
                         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(finalOptions.relativePath, className, field, finalOptions.linkConfigs) + ")|";
+                        newItemText = newItemText.replace(/</g, "\\<").replace(/>/g, "\\>"); // escape angle brackets for markdown
+                        let tableLine;
+                        if (isEnum) {
+                            // Enum fields are plain text (no link)
+                            tableLine = newItemText + "|";
+                        }
+                        else {
+                            tableLine = "[" + newItemText + "]("
+                                + buildFieldLink(finalOptions.relativePath, className, field, finalOptions.linkConfigs) + ")|";
+                        }
                         tableLine += removeAtLink(extractFirstSentenceFromComment(field.comment));
                         output += tableLine + "|\n";
                     });
@@ -523,9 +574,11 @@ function findMatchingLinkConfig(relativePath, linkConfigs = exports.DEFAULT_LINK
     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) {
+function buildClassLink(relativePath, className, linkConfigs = exports.DEFAULT_LINK_CONFIGS, isEnum = false) {
     const config = findMatchingLinkConfig(relativePath, linkConfigs);
-    return buildLinkFromTemplate(config.classTemplate, relativePath, className);
+    // Use enumTemplate for enums if available, otherwise fall back to classTemplate
+    const template = isEnum && config.enumTemplate ? config.enumTemplate : config.classTemplate;
+    return buildLinkFromTemplate(template, relativePath, className);
 }
 function buildFieldLink(relativePath, className, field, linkConfigs = exports.DEFAULT_LINK_CONFIGS) {
     const config = findMatchingLinkConfig(relativePath, linkConfigs);
@@ -577,6 +630,18 @@ function parseDTSInternal(node, allClasses, context) {
             break;
         case ts.SyntaxKind.TypeLiteral:
             return;
+        case ts.SyntaxKind.ModuleDeclaration:
+            // Handle namespace - push to stack, process children, then pop
+            const moduleNode = node;
+            if (moduleNode.name && ts.isIdentifier(moduleNode.name)) {
+                context.namespaceStack.push(moduleNode.name.text);
+                node.getChildren().forEach((element) => {
+                    parseDTSInternal(element, allClasses, context);
+                });
+                context.namespaceStack.pop();
+                return; // Already processed children
+            }
+            break;
         default:
             // the compiler parses comments after the class/field, therefore this connects to the previous item
             if (node.getText().indexOf("/**") >= 0 &&
@@ -596,7 +661,11 @@ function parseDTSInternal(node, allClasses, context) {
     });
 }
 function parseDTSTopLevelItem(node, allClasses, type, context) {
-    context.topClass = new ClassStruct("export " + type.toLowerCase() + " " + node.name.text, "", type);
+    // Use fully qualified name for enums to preserve namespace path (e.g., Office.MailboxEnums.ActionType)
+    const qualifiedName = type === ClassType.Enum
+        ? context.getFullyQualifiedName(node.name.text)
+        : node.name.text;
+    context.topClass = new ClassStruct("export " + type.toLowerCase() + " " + qualifiedName, "", type);
     allClasses.addClass(context.topClass);
     context.lastItem = context.topClass;
 }

package/dist/whats-new.js

@@ -57,7 +57,8 @@ function loadWhatsNewConfig(configFilePath) {
                     pathPattern: item.pathPattern,
                     globalFunctionTemplate: item.globalFunctionTemplate,
                     classTemplate: item.classTemplate,
-                    classMemberTemplate: item.classMemberTemplate
+                    classMemberTemplate: item.classMemberTemplate,
+                    enumTemplate: item.enumTemplate // Optional: defaults to classTemplate if not provided
                 };
             });
         }

package/package.json

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