Fixed the typo from NonAdult to NotAdult in LegalAgeGroupClassification Interface (#2858)

* Fixed the typo from NonAdult to NotAdult in LegalAgeGroupClassification

* adding chnagefile

* adding a backcompt fix

* adding unit tests

* Fix for the enum in runtime

* add the runtime

* increase package size

---------

Co-authored-by: Jeff Klouda <[email protected]>

Author: ndangudubiyyam

change/@microsoft-teams-js-d26394d9-5998-4add-af88-fa1403a92723.json

@@ -0,0 +1,7 @@
+{
+  "type": "patch",
+  "comment": "Fixed the typo from `NonAdult` to `NotAdult` in `LegalAgeGroupClassification` Enum.",
+  "packageName": "@microsoft/teams-js",
+  "email": "[email protected]",
+  "dependentChangeType": "patch"
+}

package.json

@@ -162,7 +162,7 @@
       "brotli": false,
       "path": "./packages/teams-js/dist/esm/packages/teams-js/src/index.js",
       "import": "{ app, authentication, pages }",
-      "limit": "57.69 KB"
+      "limit": "58.32 KB"
     },
     {
       "brotli": false,

packages/teams-js/src/internal/appHelpers.ts

@@ -14,7 +14,12 @@ import * as Handlers from '../internal/handlers'; // Conflict with some names
 import { ensureInitializeCalled, ensureInitialized, processAdditionalValidOrigins } from '../internal/internalAPIs';
 import { getLogger } from '../internal/telemetry';
 import { isNullOrUndefined } from '../internal/typeCheckUtilities';
-import { compareSDKVersions, inServerSideRenderingEnvironment, runWithTimeout } from '../internal/utils';
+import {
+  compareSDKVersions,
+  inServerSideRenderingEnvironment,
+  normalizeAgeGroupValue,
+  runWithTimeout,
+} from '../internal/utils';
 import * as app from '../public/app/app';
 import { FrameContexts } from '../public/constants';
 import * as dialog from '../public/dialog/dialog';
@@ -149,12 +154,14 @@ function initializeHelper(apiVersionTag: string, validMessageOrigins?: string[])
           // After Teams updates its client code, we can remove this default code.
           try {
             initializeHelperLogger('Parsing %s', runtimeConfig);
-            const givenRuntimeConfig: IBaseRuntime | null = JSON.parse(runtimeConfig);
+            let givenRuntimeConfig: IBaseRuntime | null = JSON.parse(runtimeConfig);
             initializeHelperLogger('Checking if %o is a valid runtime object', givenRuntimeConfig ?? 'null');
             // Check that givenRuntimeConfig is a valid instance of IBaseRuntime
             if (!givenRuntimeConfig || !givenRuntimeConfig.apiVersion) {
               throw new Error('Received runtime config is invalid');
             }
+            // Normalize ageGroup value for backward compatibility
+            givenRuntimeConfig = normalizeAgeGroupValue(givenRuntimeConfig);
             runtimeConfig && applyRuntimeConfig(givenRuntimeConfig);
           } catch (e) {
             if (e instanceof SyntaxError) {
@@ -167,14 +174,15 @@ function initializeHelper(apiVersionTag: string, validMessageOrigins?: string[])
                 if (!isNaN(compareSDKVersions(runtimeConfig, defaultSDKVersionForCompatCheck))) {
                   GlobalVars.clientSupportedSDKVersion = runtimeConfig;
                 }
-                const givenRuntimeConfig: IBaseRuntime | null = JSON.parse(clientSupportedSDKVersion);
+                let givenRuntimeConfig: IBaseRuntime | null = JSON.parse(clientSupportedSDKVersion);
                 initializeHelperLogger('givenRuntimeConfig parsed to %o', givenRuntimeConfig ?? 'null');
 
                 if (!givenRuntimeConfig) {
                   throw new Error(
                     'givenRuntimeConfig string was successfully parsed. However, it parsed to value of null',
                   );
                 } else {
+                  givenRuntimeConfig = normalizeAgeGroupValue(givenRuntimeConfig);
                   applyRuntimeConfig(givenRuntimeConfig);
                 }
               } catch (e) {

packages/teams-js/src/internal/utils.ts

@@ -4,8 +4,9 @@ import { Buffer } from 'buffer';
 import * as uuid from 'uuid';
 
 import { minAdaptiveCardVersion } from '../public/constants';
-import { AdaptiveCardVersion, SdkError } from '../public/interfaces';
+import { AdaptiveCardVersion, LegalAgeGroupClassification, SdkError } from '../public/interfaces';
 import * as pages from '../public/pages/pages';
+import { IBaseRuntime } from '../public/runtime';
 
 /**
  * @internal
@@ -566,3 +567,34 @@ export function isPrimitiveOrPlainObject(value: unknown, depth: number = 0): boo
   // Check all properties of the object recursively
   return Object.keys(value).every((key) => isPrimitiveOrPlainObject(value[key], depth + 1));
 }
+
+/**
+ * Normalizes legacy ageGroup values for backward compatibility
+ * @param runtimeConfig - The runtime configuration object to normalize
+ * @returns A new IBaseRuntime object with normalized ageGroup values
+ */
+export function normalizeAgeGroupValue(runtimeConfig: IBaseRuntime): IBaseRuntime {
+  // If no ageGroup exists, return the original config
+  if (!runtimeConfig.hostVersionsInfo?.appEligibilityInformation?.ageGroup) {
+    return runtimeConfig;
+  }
+
+  const ageGroup = runtimeConfig.hostVersionsInfo.appEligibilityInformation.ageGroup as unknown as string;
+
+  // If the ageGroup doesn't need normalization, return the original config
+  if (ageGroup?.toLowerCase() !== 'nonadult') {
+    return runtimeConfig;
+  }
+
+  // Create a new config with the normalized ageGroup value
+  return {
+    ...runtimeConfig,
+    hostVersionsInfo: {
+      ...runtimeConfig.hostVersionsInfo,
+      appEligibilityInformation: {
+        ...runtimeConfig.hostVersionsInfo.appEligibilityInformation,
+        ageGroup: LegalAgeGroupClassification.NotAdult,
+      },
+    },
+  };
+}

packages/teams-js/src/private/copilot/eligibility.ts

@@ -11,7 +11,7 @@ import { sendAndUnwrap } from '../../internal/communication';
 import { ensureInitialized } from '../../internal/internalAPIs';
 import { ApiName, ApiVersionNumber, getApiVersionTag, getLogger } from '../../internal/telemetry';
 import { errorNotSupportedOnPlatform } from '../../public/constants';
-import { AppEligibilityInformation, isSdkError, SdkError } from '../../public/interfaces';
+import { AppEligibilityInformation, isSdkError, LegalAgeGroupClassification, SdkError } from '../../public/interfaces';
 import { runtime } from '../../public/runtime';
 
 const copilotTelemetryVersionNumber: ApiVersionNumber = ApiVersionNumber.V_2;
@@ -73,6 +73,10 @@ export async function getEligibilityInfo(forceRefresh?: boolean): Promise<AppEli
   if (!isEligibilityInfoValid(response)) {
     throw new Error('Error deserializing eligibility information');
   }
+  // convert nonAdult age group to NotAdult
+  if ((response.ageGroup as unknown as string)?.toLowerCase() === 'nonadult') {
+    response.ageGroup = LegalAgeGroupClassification.NotAdult;
+  }
   return response;
 }
 

packages/teams-js/src/public/interfaces.ts

@@ -1304,7 +1304,12 @@ export enum LegalAgeGroupClassification {
    * United Kingdom, European Union, or South Korea, and the user's age is between a minor and an adult age
    * (as stipulated based on country or region). Generally, this means that teenagers are considered as notAdult in regulated countries.
    */
-  NonAdult = 'nonAdult',
+  NotAdult = 'notAdult',
+  /**
+   * @deprecated To provide back compatibility for the NonAdult enum value coming from the hubs
+   */
+  //  eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+  NonAdult = 'notAdult',
 }
 
 /**

packages/teams-js/test/internal/utils.spec.ts

@@ -5,12 +5,14 @@ import {
   getBase64StringFromBlob,
   hasScriptTags,
   isPrimitiveOrPlainObject,
+  normalizeAgeGroupValue,
   validateId,
   validateUrl,
   validateUuid,
 } from '../../src/internal/utils';
 import { AppId, pages } from '../../src/public';
-import { ClipboardSupportedMimeType } from '../../src/public/interfaces';
+import { ClipboardSupportedMimeType, LegalAgeGroupClassification } from '../../src/public/interfaces';
+import { IBaseRuntime } from '../../src/public/runtime';
 import { UUID } from '../../src/public/uuidObject';
 
 describe('utils', () => {
@@ -610,4 +612,51 @@ describe('utils', () => {
       expect(isPrimitiveOrPlainObject(createNestedObject(1000))).toBe(true);
     });
   });
+  describe('normalizeAgeGroupValue', () => {
+    const createMockRuntimeConfig = (ageGroup?: string | LegalAgeGroupClassification): IBaseRuntime => ({
+      apiVersion: 4,
+      supports: {},
+      hostVersionsInfo: {
+        appEligibilityInformation: {
+          ageGroup: ageGroup as LegalAgeGroupClassification,
+          cohort: null,
+          isCopilotEligible: false,
+          isCopilotEnabledRegion: true,
+          isOptedOutByAdmin: false,
+          userClassification: null,
+        },
+      },
+    });
+
+    describe('when ageGroup needs normalization', () => {
+      it('should normalize "nonAdult" to NotAdult', () => {
+        const input = createMockRuntimeConfig('nonAdult');
+        const result = normalizeAgeGroupValue(input);
+
+        expect(result.hostVersionsInfo?.appEligibilityInformation?.ageGroup).toBe(LegalAgeGroupClassification.NotAdult);
+        expect(result).not.toBe(input); // Should return a new object
+      });
+
+      it('should normalize "NonAdult" to NotAdult (case insensitive)', () => {
+        const input = createMockRuntimeConfig('NonAdult');
+        const result = normalizeAgeGroupValue(input);
+
+        expect(result.hostVersionsInfo?.appEligibilityInformation?.ageGroup).toBe(LegalAgeGroupClassification.NotAdult);
+      });
+
+      it('should normalize "NONADULT" to NotAdult (case insensitive)', () => {
+        const input = createMockRuntimeConfig('NONADULT');
+        const result = normalizeAgeGroupValue(input);
+
+        expect(result.hostVersionsInfo?.appEligibilityInformation?.ageGroup).toBe(LegalAgeGroupClassification.NotAdult);
+      });
+
+      it('should normalize "noNaDuLt" to NotAdult (mixed case)', () => {
+        const input = createMockRuntimeConfig('noNaDuLt');
+        const result = normalizeAgeGroupValue(input);
+
+        expect(result.hostVersionsInfo?.appEligibilityInformation?.ageGroup).toBe(LegalAgeGroupClassification.NotAdult);
+      });
+    });
+  });
 });

packages/teams-js/test/private/copilot.spec.ts

@@ -57,6 +57,24 @@ const copilotInHostVersionsInfoRuntimeConfig: Runtime = {
   },
 };
 
+const copilotInHostVersionsInfoRuntimeConfigWithNonAdult: Runtime = {
+  apiVersion: 4,
+  hostVersionsInfo: {
+    appEligibilityInformation: { ...mockedAppEligibilityInformation, ageGroup: LegalAgeGroupClassification.NonAdult },
+  },
+  supports: {
+    pages: {
+      appButton: {},
+      tabs: {},
+      config: {},
+      backStack: {},
+      fullTrust: {},
+    },
+    teamsCore: {},
+    logs: {},
+  },
+};
+
 const copilotRuntimeConfig: Runtime = {
   apiVersion: 4,
   supports: {
@@ -140,6 +158,12 @@ describe('copilot', () => {
         expect(copilot.eligibility.isSupported()).toBeTruthy();
       });
 
+      it('isSupported should return true if eligibility information is on the runtimeConfig with nonAdult enum', async () => {
+        await utils.initializeWithContext(FrameContexts.content);
+        utils.setRuntimeConfig(copilotInHostVersionsInfoRuntimeConfigWithNonAdult);
+        expect(copilot.eligibility.isSupported()).toBeTruthy();
+      });
+
       it('isSupported should return true if copilot.eligibility is supported', async () => {
         await utils.initializeWithContext(FrameContexts.content);
         utils.setRuntimeConfig(copilotRuntimeConfig);
@@ -201,6 +225,28 @@ describe('copilot', () => {
           return expect(promise).resolves.toEqual(mockedAppEligibilityInformation);
         });
 
+        it('correct the ageGroup from nonAdult to notAdult', async () => {
+          await utils.initializeWithContext(frameContext);
+          utils.setRuntimeConfig(copilotRuntimeConfig);
+
+          const promise = copilot.eligibility.getEligibilityInfo();
+          const message = utils.findMessageByFunc('copilot.eligibility.getEligibilityInfo');
+          expect(message).not.toBeNull();
+          const mockedAppEligibilityInformationWithInCorrectedAgeGroup = {
+            ...mockedAppEligibilityInformation,
+            ageGroup: LegalAgeGroupClassification.NonAdult,
+          };
+          if (message) {
+            utils.respondToMessage(message, mockedAppEligibilityInformationWithInCorrectedAgeGroup);
+          }
+          const mockedAppEligibilityInformationWithCorrectedAgeGroup = {
+            ...mockedAppEligibilityInformation,
+            ageGroup: LegalAgeGroupClassification.NotAdult,
+          };
+
+          return expect(promise).resolves.toEqual(mockedAppEligibilityInformationWithCorrectedAgeGroup);
+        });
+
         it(`should pass forceRefresh parameter if it exists - with context ${frameContext}`, async () => {
           expect.assertions(1);
           await utils.initializeWithContext(frameContext);