<!-- AI可能生成的Vue单文件组件结构 -->
<template>
  <div class="user-card" @mouseover="isHovered = true" @mouseleave="isHovered = false">
    <img :src="avatarUrl" :alt="userName + '的头像'" class="avatar">
    <div class="content">
      <h3 class="username">{{ userName }}</h3>
      <h4 class="title">{{ title }}</h4>
      <p class="description">{{ description }}</p>
    </div>
  </div>
</template>

<script>
export default {
  name: 'UserCard',
  props: {
    avatarUrl: String,
    userName: String,
    title: String,
    description: String
  },
  data() {
    return {
      isHovered: false
    };
  },
  computed: {
    cardShadow() {
      return this.isHovered ? '0 10px 25px rgba(0,0,0,0.15)' : '0 4px 12px rgba(0,0,0,0.08)';
    }
  }
};
</script>

<style scoped>
.user-card {
  display: flex;
  align-items: flex-start;
  padding: 1.5rem;
  border-radius: 12px;
  background-color: #fff;
  transition: box-shadow 0.3s ease;
  box-shadow: v-bind(cardShadow); /* 使用Vue3的v-bind CSS，或直接绑定内联样式 */
}
.avatar {
  width: 60px;
  height: 60px;
  border-radius: 50%;
  margin-right: 1rem;
  object-fit: cover;
}
.content {
  display: flex;
  flex-direction: column;
}
.username {
  margin: 0 0 0.25rem 0;
  font-size: 1.2rem;
  color: #333;
}
.title {
  margin: 0 0 0.5rem 0;
  font-size: 1rem;
  color: #666;
  font-weight: normal;
}
.description {
  margin: 0;
  color: #777;
  line-height: 1.5;
}
</style>

// AI生成的通用工具函数
/**
 * 将对象数组转换为以指定键值为索引的对象。
 * @param {Array} array - 要转换的对象数组。
 * @param {string} key - 用作索引的对象键名。
 * @returns {Object} 索引化后的对象。
 */
function indexBy(array, key) {
  if (!Array.isArray(array)) {
    throw new TypeError('第一个参数必须是一个数组');
  }
  if (typeof key !== 'string') {
    throw new TypeError('第二个参数必须是一个字符串');
  }

  return array.reduce((acc, currentItem) => {
    // 确保当前对象存在指定的键
    if (currentItem && key in currentItem) {
      const indexKey = currentItem[key];
      acc[indexKey] = { ...acc[indexKey], ...currentItem }; // 使用展开运算符实现覆盖合并
    } else {
      // 可以选择静默跳过、抛出错误或记录警告，这里选择静默跳过
      console.warn(`对象中缺少键 "${key}":`, currentItem);
    }
    return acc;
  }, {});
}

// 使用示例
const users = [
  { id: 1, name: 'Alice', role: 'Admin' },
  { id: 2, name: 'Bob', role: 'User' },
  { id: 3, name: 'Charlie', role: 'User' },
  { id: 2, name: 'Bob Updated', department: 'Engineering' } // 重复的id，用于覆盖
];

const usersById = indexBy(users, 'id');
console.log(usersById);
// 输出: {
//   '1': { id: 1, name: 'Alice', role: 'Admin' },
//   '2': { id: 2, name: 'Bob Updated', role: 'User', department: 'Engineering' }, // 注意被覆盖了
//   '3': { id: 3, name: 'Charlie', role: 'User' }
// }

// AI生成的Jest测试文件
import { indexBy } from './indexBy';

describe('indexBy', () => {
  const mockArray = [
    { id: 'a', value: 1 },
    { id: 'b', value: 2 },
    { id: 'c', value: 3 },
  ];

  test('应该根据指定的键正确索引数组', () => {
    const result = indexBy(mockArray, 'id');
    expect(result).toEqual({
      a: { id: 'a', value: 1 },
      b: { id: 'b', value: 2 },
      c: { id: 'c', value: 3 },
    });
  });

  test('应该使用后面的对象覆盖重复键的值', () => {
    const arrayWithDuplicates = [
      { id: 'a', value: 1 },
      { id: 'a', value: 99, extra: 'test' }, // 重复id，应覆盖
    ];
    const result = indexBy(arrayWithDuplicates, 'id');
    expect(result).toEqual({
      a: { id: 'a', value: 99, extra: 'test' }, // 注意value是99，并且合并了extra
    });
  });

  test('当数组中某个对象缺少指定键时应跳过并警告', () => {
    const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
    const arrayWithMissingKey = [
      { id: 'a', value: 1 },
      { value: 2 }, // 缺少id键
    ];
    const result = indexBy(arrayWithMissingKey, 'id');
    expect(result).toEqual({
      a: { id: 'a', value: 1 },
    });
    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('缺少键 "id"'), { value: 2 });
    consoleSpy.mockRestore();
  });

  test('当第一个参数不是数组时应抛出TypeError', () => {
    expect(() => indexBy({}, 'id')).toThrow(TypeError);
    expect(() => indexBy(null, 'id')).toThrow(TypeError);
    expect(() => indexBy('not an array', 'id')).toThrow(TypeError);
  });

  test('当第二个参数不是字符串时应抛出TypeError', () => {
    expect(() => indexBy(mockArray, 123)).toThrow(TypeError);
    expect(() => indexBy(mockArray, {})).toThrow(TypeError);
  });
});