Azure · MaryGao · Mar 5, 2025 · Sep 25, 2024 · Sep 25, 2024 · Oct 23, 2024
@@ -35,7 +35,7 @@
         "prefix": "package-version"
       },
       {
-        "path": "src/dPGCustomizationClient.ts",
+        "path": "src/dpgCustomizationClient.ts",
         "prefix": "userAgentInfo"
       }
     ]

@@ -1,9 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import DPGCustomizationClient from "./dPGCustomizationClient";
+import DPGCustomizationClient from "./dpgCustomizationClient";
 
-export * from "./dPGCustomizationClient";
+export * from "./dpgCustomizationClient";
 export * from "./parameters";
 export * from "./responses";
 export * from "./clientDefinitions";

@@ -1,9 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import LRORestClient from "./lRORestClient";
+import LRORestClient from "./lroRestClient";
 
-export * from "./lRORestClient";
+export * from "./lroRestClient";
 export * from "./parameters";
 export * from "./responses";
 export * from "./clientDefinitions";

@@ -1,9 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import DPGClient from "./dPGClient";
+import DPGClient from "./dpgClient";
 
-export * from "./dPGClient";
+export * from "./dpgClient";
 export * from "./parameters";
 export * from "./responses";
 export * from "./clientDefinitions";

@@ -1,9 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import DPGClient from "./dPGClient";
+import DPGClient from "./dpgClient";
 
-export * from "./dPGClient";
+export * from "./dpgClient";
 export * from "./parameters";
 export * from "./responses";
 export * from "./clientDefinitions";

@@ -1,6 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+export interface NormalizeNameOption {
+  shouldGuard?: boolean;
+  customReservedNames?: ReservedName[];
+  casingOverride?: CasingConvention;
+  numberPrefixOverride?: string;
+}
+
 export interface ReservedName {
   name: string;
   reservedFor: NameType[];
@@ -14,7 +21,8 @@ export enum NameType {
   Parameter,
   Operation,
   OperationGroup,
-  Method
+  Method,
+  EnumMemberName
 }
 
 const Newable = [NameType.Class, NameType.Interface, NameType.OperationGroup];
@@ -135,39 +143,103 @@ export function normalizeName(
   name: string,
   nameType: NameType,
   shouldGuard?: boolean,
-  customReservedNames: ReservedName[] = [],
+  customReservedNames?: ReservedName[],
   casingOverride?: CasingConvention
+): string;
+export function normalizeName(
+  name: string,
+  nameType: NameType,
+  options?: NormalizeNameOption
+): string;
+export function normalizeName(
+  name: string,
+  nameType: NameType,
+  optionsOrShouldGuard?: NormalizeNameOption | boolean,
+  optionalCustomReservedNames?: ReservedName[],
+  optionalCasingOverride?: CasingConvention
 ): string {
+  let shouldGuard: boolean | undefined,
+    customReservedNames: ReservedName[],
+    casingOverride: CasingConvention | undefined,
+    numberPrefixOverride: string | undefined;
+  if (typeof optionsOrShouldGuard === "boolean") {
+    shouldGuard = optionsOrShouldGuard;
+    customReservedNames = optionalCustomReservedNames ?? [];
+    casingOverride = optionalCasingOverride;
+  } else {
+    shouldGuard = optionsOrShouldGuard?.shouldGuard;
+    customReservedNames = optionsOrShouldGuard?.customReservedNames ?? [];
+    casingOverride = optionsOrShouldGuard?.casingOverride;
+    numberPrefixOverride = optionsOrShouldGuard?.numberPrefixOverride;
+  }
   if (name.startsWith("$DO_NOT_NORMALIZE$")) {
     return name.replace("$DO_NOT_NORMALIZE$", "");
   }
   const casingConvention = casingOverride ?? getCasingConvention(nameType);
-  const sanitizedName = sanitizeName(name);
-  const parts = getNameParts(sanitizedName);
+  const parts = deconstruct(name);
+  if (parts.length === 0) {
+    return name;
+  }
   const [firstPart, ...otherParts] = parts;
-  const normalizedFirstPart = toCasing(firstPart, casingConvention);
+  const normalizedFirstPart = toCasing(firstPart, casingConvention, true);
   const normalizedParts = (otherParts || [])
-    .map((part) =>
-      part === "null" ? part : toCasing(part, CasingConvention.Pascal)
-    )
+    .map((part) => toCasing(part, CasingConvention.Pascal))
     .join("");
 
-  const normalized = checkBeginning(`${normalizedFirstPart}${normalizedParts}`);
-  return shouldGuard
+  const normalized = `${normalizedFirstPart}${normalizedParts}`;
+  const result = shouldGuard
     ? guardReservedNames(normalized, nameType, customReservedNames)
     : normalized;
+  return fixLeadingNumber(result, nameType, numberPrefixOverride);
 }
 
-function checkBeginning(name: string): string {
-  if (name.startsWith("@")) {
-    return name.substring(1);
+export function fixLeadingNumber(
+  name: string,
+  nameType: NameType,
+  prefix: string = "_"
+): string {
+  const casingConvention = getCasingConvention(nameType);
+  if (!name || !name.match(/^[-.]?\d/)) {
+    return name;
   }
-  return name;
+  return `${toCasing(prefix, casingConvention)}${name}`;
 }
 
-function sanitizeName(name: string): string {
-  // Remove [, ], \, " and ' from name string
-  return name.replace(/["'\\[\]]+/g, "");
+function isFullyUpperCase(
+  identifier: string,
+  maxUppercasePreserve: number = 3
+) {
+  const len = identifier.length;
+  if (len > 1) {
+    if (
+      len <= maxUppercasePreserve &&
+      identifier === identifier.toUpperCase()
+    ) {
+      return true;
+    }
+
+    if (len <= maxUppercasePreserve + 1 && identifier.endsWith("s")) {
+      const i = identifier.substring(0, len - 1);
+      if (i.toUpperCase() === i) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function deconstruct(identifier: string): Array<string> {
+  return `${identifier}`
+    .replace(/([a-z]+)([A-Z])/g, "$1 $2") // Add a space in between camelCase words(e.g. fooBar => foo Bar)
+    .replace(/(\d+)/g, " $1 ") // Adds a space after numbers(e.g. foo123Bar => foo123 bar)
+    .replace(/_/g, " ") // Replace underscores with spaces
+    .replace(/\b([A-Z]+)([A-Z])s([^a-z])(.*)/g, "$1$2« $3$4") // Add a space after a plural upper cased word(e.g. MBsFoo => MBs Foo)
+    .replace(/\b([A-Z]+)([A-Z])([a-z]+)/g, "$1 $2$3") // Add a space between an upper case word(2 char+) and the last captial case.(e.g. SQLConnection -> SQL Connection)
+    .replace(/«/g, "s")
+    .trim()
+    .split(/[\W|_]+/)
+    .map((each) => (isFullyUpperCase(each) ? each : each.toLowerCase()))
+    .filter((part) => !!part);
 }
 
 export function getModelsName(title: string): string {
@@ -185,6 +257,7 @@ function getCasingConvention(nameType: NameType) {
     case NameType.Class:
     case NameType.Interface:
     case NameType.OperationGroup:
+    case NameType.EnumMemberName:
       return CasingConvention.Pascal;
     case NameType.File:
     case NameType.Property:
@@ -195,28 +268,20 @@ function getCasingConvention(nameType: NameType) {
   }
 }
 
-/**
- * TODO: Improve this function to handle cases such as TEST -> test. Current basic implementation
- * results in TEST -> test or Test (depending on the CasingConvention). We should switch to relay
- * on Modeler four namer for this once it is stable
- */
-function toCasing(str: string, casing: CasingConvention): string {
-  let value = str;
-  if (value === value.toUpperCase()) {
-    value = str.toLowerCase();
-  }
-
+function toCasing(
+  str: string,
+  casing: CasingConvention,
+  keepConsistent = false
+): string {
   const firstChar =
     casing === CasingConvention.Pascal
-      ? value.charAt(0).toUpperCase()
-      : value.charAt(0).toLowerCase();
-  return `${firstChar}${value.substring(1)}`;
-}
-
-function getNameParts(name: string) {
-  const parts = name.split(/[-._ ]+/).filter((part) => part.trim().length > 0);
-
-  return parts.length > 0 ? parts : [name];
+      ? str.charAt(0).toUpperCase()
+      : str.charAt(0).toLowerCase();
+  const allLowerCases =
+    casing !== CasingConvention.Pascal &&
+    keepConsistent &&
+    str.toUpperCase() === str;
+  return allLowerCases ? str.toLowerCase() : `${firstChar}${str.substring(1)}`;
 }
 
 export function pascalCase(str: string) {

@@ -250,6 +250,7 @@ export interface RLCOptions {
   experimentalExtensibleEnums?: boolean;
   clearOutputFolder?: boolean;
   ignorePropertyNameNormalize?: boolean;
+  ignoreEnumMemberNameNormalize?: boolean;
   compatibilityQueryMultiFormat?: boolean;
   typespecTitleMap?: Record<string, string>;
 }

@@ -3,6 +3,93 @@ import "mocha";
 import { NameType, normalizeName } from "../../src/helpers/nameUtils.js";
 
 describe("#normalizeName", () => {
+  describe("general cases", () => {
+    describe("Step 1 - split words", () => {
+      it("should use uppercase words", () => {
+        expect(normalizeName("someSQLConnection", NameType.EnumMemberName)).to.equal(
+          "SomeSQLConnection"
+        );
+      });
+      it("should use special chars to help split", () => {
+        expect(normalizeName("pascal_case", NameType.EnumMemberName)).to.equal(
+          "PascalCase"
+        );
+        expect(normalizeName("pascal case", NameType.EnumMemberName)).to.equal(
+          "PascalCase"
+        );
+        expect(normalizeName("pascal/case", NameType.EnumMemberName)).to.equal(
+          "PascalCase"
+        );
+      });
+      it("should split a plural upper cased word correctly", () => {
+        expect(normalizeName("diskMBpsReadWrite", NameType.EnumMemberName)).to.equal(
+          "DiskMBpsReadWrite"
+        );
+        expect(
+          normalizeName("LRORetrysPost", NameType.OperationGroup,)
+        ).to.equal("LRORetrysPost");
+        expect(
+          normalizeName("_LRORetrysPost", NameType.OperationGroup,)
+        ).to.equal("LRORetrysPost");
+      });
+
+      it("should limit the charset to alphanumeric characters", () => {
+        expect(normalizeName("R-10Min", NameType.EnumMemberName)).to.equal("R10Min");
+        expect(normalizeName("___pascal____case6666", NameType.EnumMemberName)).to.equal("PascalCase6666");
+        expect(normalizeName("system,user", NameType.EnumMemberName)).to.equal("SystemUser");
+        expect(normalizeName("x86_64_mac", NameType.EnumMemberName)).to.equal("X8664Mac");
+        expect(normalizeName("size256x256", NameType.EnumMemberName)).to.equal("Size256X256");
+      });
+    });
+    describe("Step 2 - convert words", () => {
+      it("should convert to lowercases if lex > 3 for full upper-case words", () => {
+        expect(normalizeName("V", NameType.EnumMemberName)).to.equal("V");
+        expect(normalizeName("VA", NameType.EnumMemberName)).to.equal("VA");
+        expect(normalizeName("VAL", NameType.EnumMemberName)).to.equal("VAL");
+        expect(normalizeName("VALI", NameType.EnumMemberName)).to.equal("Vali");
+        expect(normalizeName("VALID", NameType.EnumMemberName)).to.equal("Valid");
+      });
+      it("should add underscore _ for the first leading number", () => {
+        expect(normalizeName("10Min", NameType.EnumMemberName)).to.equal("_10Min");
+        expect(normalizeName("-1.0Min", NameType.EnumMemberName)).to.equal("_10Min");
+      });
+    });
+
+    describe("Step 3 - to target casing", () => {
+      it("should keep whole upper case for enum member", () => {
+        expect(normalizeName("SAS_AUTHENTICATION_IP", NameType.EnumMemberName)).to.equal("SASAuthenticationIP");
+      });
+      it("should keep whole lower case for property", () => {
+        expect(normalizeName("SAS_AUTHENTICATION_IP", NameType.Property)).to.equal("sasAuthenticationIP");
+      });
+    });
+
+    describe("$DO_NOT_NORMALIZE", () => {
+      it("should keep the whole name if it starts with $DO_NOT_NORMALIZE$", () => {
+        expect(normalizeName("$DO_NOT_NORMALIZE$VALIDATION_NOT_REQUIRED", NameType.EnumMemberName)).to.equal("VALIDATION_NOT_REQUIRED");
+      });
+
+    });
+  });
+  describe("for enum member name", () => {
+    it("should handle pure numeric", () => {
+      expect(normalizeName("10", NameType.EnumMemberName)).to.equal("_10");
+    });
+    it("should handle api-version enums as normal enum", () => {
+      expect(normalizeName("V1.1", NameType.EnumMemberName)).to.equal("V11");
+      expect(normalizeName("2024-07-01-preview ", NameType.EnumMemberName)).to.equal("_20240701Preview");
+    });
+  });
+  describe("for property", () => {
+    it("should remove $ char", () => {
+      expect(normalizeName("$select", NameType.Property)).to.equal(
+        "select"
+      );
+      expect(normalizeName("hate/threatening", NameType.Property)).to.equal(
+        "hateThreatening"
+      );
+    });
+  });
   describe("for parameter", () => {
     it("should return the name with the suffix 'Param' if the name is a reserved name", () => {
       expect(normalizeName("static", NameType.Parameter, true)).to.equal(
@@ -11,34 +98,21 @@ describe("#normalizeName", () => {
       expect(normalizeName("any", NameType.Parameter, true)).to.equal(
         "anyParam"
       );
-    });
-
-    it("should normalize the name with camel case", () => {
-      expect(normalizeName("API_KEY", NameType.Parameter, true)).to.equal(
-        "apiKey"
-      );
+      expect(normalizeName("SAS", NameType.Parameter)).to.equal("sas");
     });
   });
 
   describe("for operation", () => {
     it("should return the name with the suffix 'Operation' if the name is a reserved name", () => {
-      expect(normalizeName("export", NameType.Operation, true)).to.equal(
+      expect(normalizeName("export", NameType.Operation,)).to.equal(
         "export"
       );
     });
 
-    it("should normalize the name with camel case", () => {
-      expect(
-        normalizeName("create_ wideget", NameType.Parameter, true)
-      ).to.equal("createWideget");
-    });
-  });
-
-  describe("for operation group", () => {
-    it("should normalize the name with pasel case", () => {
+    it("should normalize the name", () => {
       expect(
-        normalizeName("LoadTest_Administration ", NameType.OperationGroup, true)
-      ).to.equal("LoadTestAdministration");
+        normalizeName("create_ widget", NameType.Parameter,)
+      ).to.equal("createWidget");
     });
   });
 });