fix(compiler-sfc): handle keyof operator usage w/ Record utility type

Author: jh-leong

packages/compiler-sfc/__tests__/compileScript/resolveType.spec.ts

@@ -455,13 +455,13 @@ describe('resolveType', () => {
     const { props } = resolve(
       `
       import { IMP } from './foo'
-      interface Foo { foo: 1, ${1}: 1 } 
+      interface Foo { foo: 1, ${1}: 1 }
       type Bar = { bar: 1 }
       declare const obj: Bar
       declare const set: Set<any>
       declare const arr: Array<any>
 
-      defineProps<{ 
+      defineProps<{
         imp: keyof IMP,
         foo: keyof Foo,
         bar: keyof Bar,
@@ -483,6 +483,25 @@ describe('resolveType', () => {
     })
   })
 
+  test('keyof: Record utility type', () => {
+    const { props } = resolve(
+      `
+      type Foo = Record<symbol | string, any>
+      type AnyRecord = Record<keyof any, any>
+
+      defineProps<{
+        foo: keyof Foo,
+        anyRecord: keyof AnyRecord 
+      }>()
+      `,
+    )
+
+    expect(props).toStrictEqual({
+      foo: ['Symbol', 'String'],
+      anyRecord: ['Unknown'],
+    })
+  })
+
   test('ExtractPropTypes (element-plus)', () => {
     const { props, raw } = resolve(
       `

packages/compiler-sfc/src/script/resolveType.ts

@@ -1535,6 +1535,12 @@ export function inferRuntimeType(
               case 'ArrayLike':
               case 'ReadonlyArray':
                 return ['String', 'Number']
+              case 'Record':
+                return inferRuntimeType(
+                  ctx,
+                  node.typeParameters!.params[0],
+                  scope,
+                )
               default:
                 return ['String']
             }