fix(types): avoid as any

dang ol' nerd sniped

Author: wjhsf

packages/@lwc/shared/src/aria.ts

@@ -74,21 +74,36 @@ const AriaPropertyNames = [
     'role',
 ] as const;
 
+type AriaProperty = (typeof AriaPropertyNames)[number];
+
 export type AccessibleElementProperties = {
-    [prop in (typeof AriaPropertyNames)[number]]: string | null;
+    [Prop in AriaProperty]: string | null;
+};
+
+type AriaPropToAttrMap = {
+    [Prop in AriaProperty]: Prop extends `aria${infer S}` ? `aria-${Lowercase<S>}` : Prop;
+};
+
+type AriaAttribute = AriaPropToAttrMap[AriaProperty];
+
+type AriaAttrToPropMap = {
+    [Prop in AriaProperty as AriaPropToAttrMap[Prop]]: Prop;
 };
 
 const { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap } = /*@__PURE__*/ (() => {
-    const AriaAttrNameToPropNameMap: Record<string, string> = create(null);
-    const AriaPropNameToAttrNameMap: Record<string, string> = create(null);
+    const AriaAttrNameToPropNameMap: AriaAttrToPropMap = create(null);
+    const AriaPropNameToAttrNameMap: AriaPropToAttrMap = create(null);
 
     // Synthetic creation of all AOM property descriptors for Custom Elements
     forEach.call(AriaPropertyNames, (propName) => {
         const attrName = StringToLowerCase.call(
             StringReplace.call(propName, /^aria/, () => 'aria-')
-        );
-        AriaAttrNameToPropNameMap[attrName] = propName;
-        AriaPropNameToAttrNameMap[propName] = attrName;
+        ) as AriaAttribute;
+        // These type assertions are because the map types are a 1:1 mapping of ariaX to aria-x.
+        // TypeScript knows we have one of ariaX | ariaY and one of aria-x | aria-y, and tries to
+        // prevent us from doing ariaX: aria-y, but we that it's safe.
+        (AriaAttrNameToPropNameMap[attrName] as AriaProperty) = propName;
+        (AriaPropNameToAttrNameMap[propName] as AriaAttribute) = attrName;
     });
 
     return { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap };

packages/@lwc/shared/src/html-attributes.ts

@@ -127,7 +127,8 @@ const CACHED_PROPERTY_ATTRIBUTE_MAPPING = /*@__PURE__@*/ new Map<string, string>
  * @param propName
  */
 export function htmlPropertyToAttribute(propName: string): string {
-    const ariaAttributeName = AriaPropNameToAttrNameMap[propName];
+    const ariaAttributeName =
+        AriaPropNameToAttrNameMap[propName as keyof typeof AriaPropNameToAttrNameMap];
     if (!isUndefined(ariaAttributeName)) {
         return ariaAttributeName;
     }

packages/@lwc/ssr-runtime/src/reflection.ts

@@ -21,18 +21,21 @@ import type { LightningElement } from './lightning-element';
  * Map of global attribute or ARIA attribute to the corresponding property name.
  * Not all global attributes are included, just those from `HTMLElementTheGoodParts`.
  */
-const attrsToProps = assign(create(null), {
-    accesskey: 'accessKey',
-    dir: 'dir',
-    draggable: 'draggable',
-    hidden: 'hidden',
-    id: 'id',
-    lang: 'lang',
-    spellcheck: 'spellcheck',
-    tabindex: 'tabIndex',
-    title: 'title',
-    ...AriaAttrNameToPropNameMap,
-});
+const attrsToProps = assign(
+    create(null) as object,
+    {
+        accesskey: 'accessKey',
+        dir: 'dir',
+        draggable: 'draggable',
+        hidden: 'hidden',
+        id: 'id',
+        lang: 'lang',
+        spellcheck: 'spellcheck',
+        tabindex: 'tabIndex',
+        title: 'title',
+        ...AriaAttrNameToPropNameMap,
+    } as const
+);
 
 /**
  * Descriptor for IDL attribute reflections that merely reflect the string, e.g. `title`.
@@ -127,9 +130,10 @@ export function reflectAttrToProp(
     const reflectedPropName = attrsToProps[attrName as keyof typeof attrsToProps];
     // If it is a reflected property and it was not overridden by the instance
     if (reflectedPropName && !hasOwnProperty.call(instance, reflectedPropName)) {
-        const currentValue = (instance as any)[reflectedPropName];
+        const currentValue = instance[reflectedPropName];
         if (currentValue !== attrValue) {
-            (instance as any)[reflectedPropName] = attrValue;
+            // Type assertion because we're providing a string, but some props accept boolean/number
+            (instance[reflectedPropName] as string | null) = attrValue;
         }
     }
 }