@getollie/cli 0.0.1

package/library/web_applications-web_visuals/display-videos-from-local-folder-on-web-page.json

@@ -0,0 +1,68 @@
+{
+  "index": 1398,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Display all videos from a video folder on a web page without using a server.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the local file access implementation correctly designed?",
+      "description": "Check if the code properly implements file access using the HTML5 File API or other client-side techniques. Score 0 if no solution for local file access is provided, 5 if a basic implementation with limitations is present, and 10 if a robust solution with proper error handling is implemented that works across modern browsers.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are appropriate video formats and codecs supported?",
+      "description": "Evaluate whether the code handles multiple video formats (MP4, WebM, OGG) and provides fallbacks for browser compatibility. Deduct 3 points if only one format is supported without fallbacks, 5 points if common formats are missing. Check if the implementation detects and handles unsupported formats gracefully. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is a functional video playback interface implemented?",
+      "description": "Review whether the implementation includes essential playback controls (play/pause, volume, seek bar, fullscreen toggle). Deduct 2 points for each missing core control. Also check if the player includes nice-to-have features like playback speed controls or picture-in-picture support. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there an effective video gallery navigation system?",
+      "description": "Assess whether the implementation provides a gallery-style interface for browsing and selecting videos (thumbnails, filtering, sorting options). Score 3 points for basic listing, 7 points for intermediate features like thumbnails and sorting, and 10 points for advanced gallery features with responsive design and good organization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as unsupported file formats, large video files, corrupted videos, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Automatic thumbnail generation 2. Video metadata extraction and display 3. Playlist creation functionality). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple video player instances) 2. Function modules unrelated to video playback (e.g., unnecessary data processing) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/video processing/file handling), maintainability, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/dotnet-6-website-baidu-map-location-markers.json

@@ -0,0 +1,68 @@
+{
+  "index": 1632,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code in your demonstrations whenever possible. How do I create a .NET 6.0 website that can browse maps and set location markers using the Baidu API?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the .NET 6.0 project structure properly set up?",
+      "description": "Check whether the code correctly implements a .NET 6.0 web application structure with proper MVC/Razor Pages patterns, appropriate project organization, and dependency injection configuration. Score 0 if using outdated .NET Framework, 5 if using .NET Core 3.1 or .NET 5, and 10 if correctly implemented with .NET 6.0 specific features (minimal APIs or traditional controllers).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is Baidu Maps API integration properly implemented?",
+      "description": "Review if the code includes proper Baidu Maps API key configuration, correct script loading with appropriate API version, and proper JavaScript initialization. Verify error handling for API loading failures and API key validation. Deduct 5 points if API key is hardcoded in client-side code, 3 points if no error handling for map initialization failures. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the map browsing functionality complete?",
+      "description": "Evaluate whether the implementation includes essential map browsing capabilities: pan, zoom controls, map type switching, and geolocation. Check if the code handles responsive design for different screen sizes. Deduct 3 points if zoom controls are missing, 5 points if geolocation functionality isn't implemented, and 2 points if map type switching is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the marker management system fully functional?",
+      "description": "Check whether the marker system includes adding, editing, removing, and persisting markers. Verify if marker data includes appropriate properties (coordinates, title, description, custom icons). Deduct 5 points if marker persistence to database is missing, 3 points if marker customization is limited, and 5 points if CRUD operations are incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, network interruptions, invalid coordinates, and concurrent marker operations) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Marker clustering for handling large datasets 2. Custom polygon/polyline drawing 3. Heatmap visualization 4. Route planning between markers). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple map initialization routines) 2. Function modules unrelated to mapping (e.g., unnecessary social media integrations) 3. Fancy effects that affect performance (e.g., excessive animations or autoplay videos). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating map services/controllers/view models), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Map interaction response delay ≤ 100ms 2) Marker animation duration controlled between 200-400ms 3) Clear visual feedback when placing markers. Deduct 5 points for each operation without feedback, 3 points for laggy map rendering during pan/zoom operations, and 5 points for confusing marker placement UI. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/draggable-nodes-to-forms-using-vue-flow.json

@@ -0,0 +1,68 @@
+{
+  "index": 932,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Create an example of draggable nodes to forms using Vue Flow.\n\n(1) The left side of the page is a node placement area, displaying the node types I can drag in small icon format.\n(2) The right side of the page is a canvas area. When nodes are dragged onto it and released, they become input forms.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue Flow draggable node system fully implemented?",
+      "description": "Review whether the code correctly implements Vue Flow's node dragging mechanism, including drag source configuration, drop target handling, and node type registration. Check if custom node components are properly defined with Vue Flow's node interface. Score 0 if core dragging functionality is missing, 5 if only basic drag-drop works without proper Vue Flow integration, and 10 if all Vue Flow dragging features are correctly implemented with proper event handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the node-to-form transformation mechanism properly implemented?",
+      "description": "Evaluate whether dragged nodes correctly transform into functional input forms on the canvas. Check if form field types (text, number, select, etc.) are properly mapped to node types, form validation is implemented, and form data binding works correctly. Deduct 5 points if forms lack proper validation, 3 points if data binding is incomplete. Full score requires complete form functionality with proper Vue reactivity.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the dual-panel layout (sidebar + canvas) properly structured?",
+      "description": "Check whether the left sidebar displays node types in an organized, visually appealing icon format and the right canvas area provides adequate space for form building. Evaluate if the layout is responsive and maintains proper proportions. Deduct 5 points if layout breaks on different screen sizes, 3 points if sidebar icons are poorly organized. Requires proper CSS Grid/Flexbox implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the canvas state management and node persistence implemented?",
+      "description": "Evaluate whether the canvas properly manages node positions, form configurations, and maintains state consistency. Check if nodes can be repositioned after being dropped, form data is preserved during interactions, and the overall canvas state can be serialized/deserialized. Deduct 5 points if node positions aren't persistent, 3 points if form data is lost during operations. Full score requires complete state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid drag operations, browser compatibility issues, Vue component lifecycle errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like dragging outside canvas bounds, invalid node types, and component mounting failures. Give 10 points if fully robust, 5 points if average robustness, and 0 points if no exception handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time form preview with sample data 2. Node connection system for form logic 3. Form template saving/loading 4. Drag-to-connect form validation rules). Add 3 points for each practical innovative feature implemented (maximum 10 points). Features must be functional, not just visual enhancements.",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple drag handlers for same functionality) 2. Function modules unrelated to form building (e.g., built-in calendar widget unrelated to forms) 3. Fancy effects that affect drag performance (e.g., heavy animations during drag operations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core drag-drop functionality is interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review Vue component architecture (proper separation of concerns, composables usage, component reusability), TypeScript integration if applicable, and proper Vue Flow plugin configuration. Deduct 5 points if components are tightly coupled or Vue best practices aren't followed; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if Vue Flow isn't properly configured. Full score requires clean Vue architecture.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching for sidebar icons and canvas (no more than 3 primary colors) 2) Proper layout spacing following 8px grid system 3) Professional typography (≥14px font size, 1.5x line height) 4) Clear visual hierarchy between sidebar and canvas. Deduct 3 points for each crowded visual element, 5 points for glaring color combinations, and 5 points for chaotic icon layout in sidebar.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether drag interactions conform to human perception: 1) Drag initiation feedback ≤100ms 2) Smooth drag animations without performance drops 3) Clear drop zone indicators 4) Proper hover states on sidebar icons 5) Form field focus management. Deduct 5 points for each laggy drag operation, 3 points for unclear drop feedback, and 5 points for missing hover states on draggable elements. Requires 60fps drag performance.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "medium"
+}

package/library/web_applications-web_visuals/electronic-map-mark-points-insert-photos.json

@@ -0,0 +1,68 @@
+{
+  "index": 922,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable and can be demonstrated. I need code or a program that can mark points on an electronic map and insert photos at those points.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the map initialization and basic functionality properly implemented?",
+      "description": "Review whether the code correctly initializes a map using a standard mapping API (like Google Maps, Leaflet, or Mapbox), with proper API keys and configuration. Check if the map renders correctly with appropriate initial zoom level and center coordinates. Score 0 if no map is displayed, 5 if basic map display works but with initialization issues, and 10 if the map initializes perfectly with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the marker placement functionality fully implemented?",
+      "description": "Evaluate whether users can add markers to the map through clicks or coordinate input. Check if markers persist after placement and if their positions are accurately maintained when zooming or panning. Deduct 5 points if marker placement works but lacks user interaction feedback, 3 points if markers don't maintain accurate positions, and 5 points if no custom styling options are available. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the photo upload and attachment system well-designed?",
+      "description": "Check if the code includes functionality to upload photos (through drag-and-drop, file picker, or URL input) and attach them to specific markers. Verify that multiple file formats are supported (at least JPG, PNG, GIF) and that proper validation occurs for file size and type. Deduct 5 points if only one upload method is available, 3 points if file validation is missing, and 5 points if large photos aren't resized/compressed for performance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the photo-marker association and display functionality effective?",
+      "description": "Assess whether photos are visibly associated with their respective markers and if they display properly when interacting with markers (on click, hover, etc.). Check for preview thumbnails, full-size viewing options, and if multiple photos per marker are supported. Deduct 5 points if the photo-marker visual association is unclear, 3 points if there's no larger view option for photos, and 5 points if multiple photos per marker aren't supported. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid image files, network interruption during uploads, marker placement outside valid map areas, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Geolocation to add markers at user's current position 2. Clustering for managing many markers 3. Photo editing/filters before attaching to markers 4. Export/import functionality for saving marked maps). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to add markers with duplicate code) 2. Function modules unrelated to map/photo features (e.g., unnecessary social sharing widgets) 3. Fancy effects that affect performance (e.g., excessive animations when showing photos). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating map logic/photo handling/UI components), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Marker placement feedback delay ≤ 100ms 2) Photo loading indicators when attaching images 3) Smooth transitions when opening/viewing photos from markers. Deduct 5 points for each operation without feedback, 3 points for laggy photo loading without indicators, and 5 points for abrupt transitions when interacting with markers and photos. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "medium"
+}

package/library/web_applications-web_visuals/elementui-navigation-page-custom-layout.json

@@ -0,0 +1,68 @@
+{
+  "index": 1389,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes. For ElementUI, create a navigation page with customized information at the top, a left-side navigation bar, and a dynamic main area on the right.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the ElementUI navigation structure correctly implemented?",
+      "description": "Verify the implementation includes header, left sidebar, and main content area according to ElementUI's container layout principles. Check for proper nesting of el-container, el-header, el-aside, and el-main components. Deduct 5 points if responsive design is missing (mobile adaptation), 5 points if layout breaks at different screen sizes, and full 10 points if layout is properly implemented with responsive design.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the top navigation customized with required information?",
+      "description": "Evaluate if the header contains customized information such as logo, application name, user profile, and action buttons. Check for proper alignment (logo left, user info right) and styling consistency. 10 points if fully customized with proper styling, 5 points if basic implementation without attention to detail, 0 points if default/minimal customization.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the left-side navigation bar properly implemented?",
+      "description": "Check if el-menu is correctly configured with nested menu items (using el-submenu and el-menu-item), proper icons, and collapse functionality. Verify if the menu items have appropriate routing capabilities. Deduct 3 points if menu doesn't handle active states, 3 points if collapse functionality is missing, 4 points if submenu structure is incorrectly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the dynamic main area implementation complete?",
+      "description": "Review if the main content area changes dynamically based on navigation selection. Check for vue-router integration, transition effects, and content loading states. Full 10 points requires proper route configuration, component lazy loading, and smooth transitions. Deduct 5 points if dynamic content loading works but lacks transitions, 5 points if router setup is incomplete.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as route errors, component loading failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Customized theme switching 2. Breadcrumb navigation with history 3. User preference persistence). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple navigation control methods) 2. Function modules unrelated to navigation layout (e.g., embedded mini-games) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating components, styles, and utility functions), component reusability, and proper use of Vue practices. Deduct 5 points if global state management is poorly implemented; deduct 5 points if component composition is inappropriate (too large or too fragmented); deduct 5 points if naming conventions and code structure are inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/engineering-graphics-3d-visualization-vue-element-plus-interface.json

@@ -0,0 +1,68 @@
+{
+  "index": 898,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for display. Create an interface for an engineering graphics-based 3D visualization system using Vue and Element Plus.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the 3D visualization core functionality implemented?",
+      "description": "Review whether the code accurately implements a 3D visualization system using WebGL/Three.js/Babylon.js within Vue. Check if basic 3D operations are supported (camera rotation, zooming, panning). Score 0 if the core 3D rendering is not implemented, 5 if only basic rendering is implemented without interactions, and 10 if full 3D object manipulation, camera controls, and proper perspective are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the engineering graphics functionality incorporated?",
+      "description": "Evaluate whether the visualization system supports engineering graphics features such as precise measurements, dimensioning, cross-sectioning, wireframe mode, and technical specifications display. Check for CAD-like functionalities such as snap-to-grid, orthographic projections, and technical drawing standards. Deduct 3 points if measurements are missing, 3 points if dimensioning is absent, and 4 points if technical drawing capabilities are lacking. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is Vue properly integrated with Element Plus for the UI?",
+      "description": "Check whether Vue components are correctly structured with proper props/emits, composition API or options API is used appropriately, and Element Plus components are properly integrated. Look for reactive data management, component lifecycle handling, and proper event bindings. Deduct 5 points for improper Vue component architecture, 3 points for incorrect Element Plus usage, and 2 points for state management issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are engineering data visualization features implemented?",
+      "description": "Review if the code includes specialized engineering visualization capabilities like material property rendering, stress analysis coloring, parametric modeling, assembly visualization, or BIM/CAD data support. Check for technical specs display, layer management, and metadata visualization. Deduct 3 points for each major engineering visualization feature missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid 3D models, browser compatibility issues, memory management with large models, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time collaborative viewing/editing 2. AR/VR compatibility 3. Physics-based simulation 4. Exploded view animations). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple camera control systems coexisting) 2. Function modules unrelated to engineering visualization (e.g., excessive animations) 3. Heavy effects that affect performance (e.g., unnecessary post-processing or particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating 3D engine logic/UI components/data services), unit test coverage, and build process optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process does not optimize 3D assets. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern engineering software design principles: 1) Clear workspace separation (viewport, toolbar, property panels) 2) Proper use of Element Plus components with consistent styling 3) Professional color scheme with sufficient contrast for technical data. Deduct 3 points for each crowded panel, 5 points for inconsistent component styling, and 5 points for poor information hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the 3D performance and UI responsiveness conform to professional standards: 1) Stable 30+ FPS even with complex models 2) Smooth transitions between different views/modes 3) Responsive UI despite heavy 3D rendering. Deduct 5 points for frame drops during interaction, 3 points for sluggish UI response when manipulating models, and 5 points for lack of loading indicators during heavy operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "medium"
+}

package/library/web_applications-web_visuals/face-swapping-frontend-interface.json

@@ -0,0 +1,68 @@
+{
+  "index": 273,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable.\n\nThis is a Python face-swapping project I found on GitHub. Here's the file structure, and now I'd like you to help me create a frontend interface where I can upload the face image I want to swap and the target face image, then click a generate button to perform the face swap and display the successfully swapped face image in the frontend interface. Below is the Python code from the run.py file:\n\n```python\n#!/usr/bin/env python3\n\nfrom roop import core\nfrom inference_codeformer import inference_codeformer\n\nif __name__ == \"__main__\":\n    newface = r\"inputs/1.jpg\"  # New face image\n    oldface = r\"inputs/4.jpg\"  # Old face image\n    savepath = r\"outputs/output_009.png\"\n\n    core.run(newface, oldface, savepath)\n    inference_codeformer.run(savepath)",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic face-swapping functionality properly implemented in the frontend?",
+      "description": "Check whether the frontend interface correctly implements the core functionality to upload two face images (source and target) and trigger the face-swapping process. The interface should include clear upload areas for both images with proper labeling and a generate button. Score 0 if uploads aren't implemented, 5 if only basic uploads work without proper validation, and 10 if the interface handles the complete workflow with clear visual guidance.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the backend integration with the Python face-swapping code properly implemented?",
+      "description": "Evaluate whether the frontend properly communicates with the Python backend (core.run and inference_codeformer.run functions). This includes handling API calls, processing responses, and managing errors. Check if the implementation uses appropriate techniques like AJAX, fetch API, or WebSockets. Deduct 5 points if there's no error handling, and 3 points if the backend communication is inefficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is image preview functionality implemented before and after face-swapping?",
+      "description": "Check if the interface provides image previews of both source images before processing and the resulting face-swapped image after processing. The previews should be properly sized, maintain aspect ratios, and be clearly labeled. Deduct 5 points if only the result is shown without previews of source images, and 3 points if previews exist but have rendering issues. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there appropriate feedback during the face-swapping process?",
+      "description": "Evaluate whether the interface provides clear loading indicators, progress updates, or status messages during the face-swapping operation. Users should know when the process starts, its current status, and when it completes. Deduct 5 points if there's no loading indicator, and 3 points if the feedback is present but unclear or misleading. Full score is 10 points for comprehensive, user-friendly processing feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid image uploads, network interruption, backend errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Face detection preview with markers 2. Image adjustment tools before processing 3. Gallery of previous swaps 4. Image comparison slider). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple image processing methods) 2. Function modules unrelated to face-swapping (e.g., unnecessary social media integration) 3. Fancy effects that affect performance (e.g., heavy animations that slow down the interface). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/API/processing logic), code organization, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/font-awesome-icon-preview-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 1189,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for display purposes. Create a preview webpage for Font Awesome, displaying each icon.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Font Awesome preview core functionality implemented?",
+      "description": "Review whether the code accurately implements a catalog of Font Awesome icons that displays all available icons. Check if icons are properly loaded and rendered using the Font Awesome library. Score 0 if icons are not displayed at all, 5 if only basic display is implemented, and 10 if a complete, categorized display is implemented with proper naming convention for each icon.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the icon search functionality implemented?",
+      "description": "Evaluate whether the implementation includes a search mechanism that allows users to filter icons by name, category, or tags. Check if the search is responsive (updates results as the user types) and has error handling for no results. Deduct 5 points if search is missing, 3 points if it's basic without real-time filtering, and 2 points if it lacks visual feedback when no results are found. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the icon preview interaction properly designed?",
+      "description": "Assess whether the code includes interactive preview functionality such as hovering effects, click-to-copy functionality for icon names/classes, and the ability to view icons at different sizes or styles (solid, regular, brands, etc.). Deduct 5 points if there's no interaction with icons, 3 points if only basic hover effects exist, and 2 points if copy functionality is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is proper categorization and pagination implemented?",
+      "description": "Check whether icons are organized by categories (such as 'business', 'communication', etc.) with appropriate pagination or infinite scrolling to handle the large number of Font Awesome icons. Deduct 5 points if categorization is missing, 3 points if pagination/infinite scrolling is not implemented for large icon sets, and 2 points if the category navigation is not intuitive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as Font Awesome CDN loading failures, missing icon references, browser compatibility issues) and provide friendly error prompts or fallback mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Color customization for icons 2. Export options for selected icons 3. Icon comparison or favorites system 4. Animation previews for animated icons). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant loading of Font Awesome resources (multiple versions or duplicate imports) 2. Feature modules unrelated to icon preview (e.g., a built-in calendar) 3. Heavy visual effects that affect performance (e.g., excessive animations when scrolling through icons). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data/rendering/interaction logic), caching strategy for icons, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance optimizations exist for rendering hundreds of icons. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching that highlights icons without overwhelming them 2) Proper layout spacing with consistent grid or flexbox alignment 3) Professional typography that doesn't compete with icon display. Deduct 3 points for each crowded visual element, 5 points for a color scheme that makes icons hard to distinguish, and 5 points for inconsistent spacing between icon elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Quick icon loading with appropriate placeholders 2) Smooth filtering transitions when searching or changing categories 3) Responsive layout that adapts to different screen sizes. Deduct 5 points for noticeable lag when loading large icon sets, 3 points for jarring transitions between views, and 5 points for poor mobile responsiveness. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "medium"
+}