@getollie/cli 0.0.1

package/library/web_applications-web_visuals/html-code-minecraft-theme.json

@@ -0,0 +1,68 @@
+{
+  "index": 1046,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code for demonstration whenever possible. Help me create an HTML code with the theme of Minecraft.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Minecraft visual style accurately reproduced?",
+      "description": "Review whether the HTML/CSS implementation accurately captures the distinctive blocky, pixelated aesthetic of Minecraft. Score 0 if there's no visual resemblance to Minecraft, 5 if basic blocky elements are present but lack authenticity, and 10 if the implementation convincingly recreates the game's iconic visual style including textures, colors, and proportions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are Minecraft-specific elements included?",
+      "description": "Evaluate the presence of recognizable Minecraft elements such as blocks (dirt, stone, wood), characters (Steve, creepers, endermen), items (pickaxe, sword), or environments (biomes). Score 3 points for each category of elements properly implemented (blocks, characters, items, environments) with a maximum of 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there any interactive functionality that reflects Minecraft gameplay?",
+      "description": "Check whether the implementation includes interactive elements like block placement/breaking, character movement, crafting mechanics, or day/night cycles. Award 3 points for each interactive Minecraft-like feature that works properly, with basic interaction receiving 5 points and complex gameplay mechanics earning the full 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Minecraft audio experience incorporated?",
+      "description": "Assess whether the code implements Minecraft-style sound effects (block breaking sounds, background music, mob noises) or music that enhances the Minecraft theme. Score 0 if no audio is included, 5 if basic sound effects are implemented, and 10 if there's a comprehensive audio experience that authentically reproduces the Minecraft soundscape.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, different screen sizes, browser compatibility issues) and provide appropriate fallbacks. 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. Procedural terrain generation 2. Weather effects 3. Mob AI simulation). 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 render the same block type) 2. Function modules unrelated to Minecraft (e.g., non-thematic elements) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core Minecraft theme is interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating rendering logic from game mechanics), code organization, and performance optimization. Deduct 5 points if global variable pollution is found; deduct 5 points if the code is not organized into logical components; deduct 5 points if there are significant performance issues. 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 while maintaining Minecraft aesthetics: 1) Faithful color palette matching the game 2) Proper layout spacing for UI elements 3) Consistent pixelated styling. Deduct 3 points for each inconsistently styled element, 5 points for colors that don't match Minecraft's palette, and 5 points for mixing pixel art with high-resolution elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether any animations or transitions feel appropriate to Minecraft: 1) Block breaking/placement animations 2) Character movement fluidity 3) UI responsiveness. Deduct 5 points for each choppy animation, 3 points for inconsistent movement speed, and 5 points for laggy interactions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "medium"
+}

package/library/web_applications-web_visuals/html-display-local-media.json

@@ -0,0 +1,68 @@
+{
+  "index": 1434,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and can be displayed. Help me write a web page code for a local HTML file that will display all image and video files from a folder located in the same directory as the HTML file when opened.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the local file system access implementation correct?",
+      "description": "Evaluate whether the code properly implements the File System Access API or an alternative method to access local files. Check if it handles browser security restrictions correctly. Score 0 if no file system access is implemented, 5 if basic access is implemented but with limitations, and 10 if it handles all edge cases including file permissions and browser compatibility.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the file filtering mechanism work correctly?",
+      "description": "Check if the code correctly identifies and filters image and video files by extension or MIME types. It should recognize common formats (JPG, PNG, GIF, WebP, MP4, WebM, etc.). Deduct 3 points if some common formats are missing, 5 points if the filtering logic has errors, and 7 points if there's no filtering at all.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the gallery rendering implementation complete?",
+      "description": "Evaluate whether the code properly renders the discovered files in a gallery format. Check for proper image/video element creation, source setting, and container organization. Deduct 5 points if media doesn't display correctly, 3 points if there are rendering issues with certain file types, and 2 points if the display logic isn't optimized.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper error handling and user feedback?",
+      "description": "Assess whether the code includes comprehensive error handling for cases like permission denied, unsupported files, or empty directories. Check if clear feedback is provided to users when issues occur. Deduct 5 points if critical errors aren't handled, 3 points if error messages are unclear, and 2 points if minor edge cases are unhandled.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid file formats, large files, many files, 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. Thumbnail generation 2. Sorting options 3. Lightbox preview 4. Lazy loading for better performance). 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 file loading methods) 2. Function modules unrelated to file display (e.g., a built-in editing tool) 3. Fancy effects that affect performance (e.g., unnecessary 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 file access/rendering/UI components), code organization, and maintainability. Deduct 5 points if global scope 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 clear 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 gallery design (consistent thumbnail sizes, proper margins). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic media 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) Image loading indicators 2) Smooth transitions when browsing through media 3) Clear visual feedback for user actions. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between media items, and 5 points for unresponsive UI when loading large files. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-File Management",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/html-iphone-image-video-viewer-interface.json

@@ -0,0 +1,68 @@
+{
+  "index": 1437,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration. HTML code to simulate iPhone interface for viewing images or videos - source code",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Does the simulated iPhone interface accurately mimic the real iOS design?",
+      "description": "Evaluate if the interface includes key iPhone elements (status bar, home indicator, correct screen dimensions). Check if it uses accurate iOS design system (SF Pro font, iOS color palette, correct corner radius). Score 0 if it looks nothing like iOS, 5 if it has basic resemblance, 10 if it's nearly indistinguishable from real iOS.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image/video viewing functionality properly implemented?",
+      "description": "Check if the code provides smooth viewing experience with proper loading states and error handling. Evaluate support for both images and videos with appropriate format compatibility (JPEG, PNG, MP4, WebM). Test for zoom/pinch functionality and rotation support. Deduct 5 points if missing video support, 3 points if missing zoom functionality, 5 points if lacking proper media controls.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are iOS-specific gestures and interactions implemented?",
+      "description": "Review implementation of standard iOS photo/video viewing gestures: pinch-to-zoom, swipe-to-dismiss, double-tap to zoom in/out, swipe between media items. Test for smooth animations with proper physics (deceleration, bounce effects). Score 0 if no gesture support, 5 if basic gestures work, 10 if all gestures work with proper iOS-like physics.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the media gallery functionality robust and complete?",
+      "description": "Evaluate if the code includes gallery view with thumbnails, transitions between gallery/detail views, proper handling of portrait/landscape orientations. Check if it includes media metadata display, sharing options, and deletion functionality. Deduct 3 points for missing transitions, 3 points for poor orientation support, 4 points for missing metadata/actions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as broken image links, unsupported media formats, network issues during loading, touch events on non-touchscreen devices). 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. Live Photo support with force touch simulation 2. Memory-efficient lazy loading of high-resolution images 3. Custom filters or editing tools 4. Intelligent face detection for improved cropping). 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 loading libraries coexisting) 2. Function modules unrelated to image/video viewing (e.g., unnecessary social media integration) 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/logic/data layers), code reusability, 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 there are no performance optimizations for image/video loading. 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 iOS design principles: 1) Consistent color matching with iOS system colors 2) Proper layout spacing according to iOS guidelines 3) Correct typography using SF Pro font family. Deduct 3 points for each non-iOS visual element, 5 points for incorrect color schemes, and 5 points for improper spacing or font usage. 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 iOS interaction patterns: 1) Response to touch within 100ms 2) Smooth animations at 60fps 3) Proper haptic feedback simulation 4) Spring animations for bounces and transitions. Deduct 5 points for janky scrolling/zooming, 3 points for non-standard transition animations, and 5 points for significant UI freezing during operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "hard"
+}

package/library/web_applications-web_visuals/html-upload-image-analyze-results.json

@@ -0,0 +1,68 @@
+{
+  "index": 372,
+  "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 for demonstration. Based on the image content, write a similar HTML code that can upload images and analyze results.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload functionality fully implemented?",
+      "description": "Check if the HTML/JavaScript code provides a complete image upload mechanism including: file input control, drag-and-drop support, preview functionality, and validation for file types (images only) and sizes. Score 0 if no upload functionality exists, 5 if only basic file input is implemented, and 10 if it includes multiple upload methods with proper validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image analysis functionality implemented?",
+      "description": "Evaluate whether the code includes client-side or server-side image analysis capabilities such as basic properties extraction (dimensions, format, size) or more advanced features (object detection, color analysis, etc.). Deduct 5 points if only metadata display is implemented without actual analysis, and 3 points if the analysis lacks depth. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the result visualization properly implemented?",
+      "description": "Assess how the analysis results are presented to users - through text descriptions, charts, overlays on the image, or other visual methods. Check if the visualization is clear, informative and interactive. Deduct 5 points if results are only displayed as plain text, and 3 points if visualizations lack interactivity. Full score requires comprehensive and interactive visualizations.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there appropriate feedback during the upload and analysis process?",
+      "description": "Verify if the code implements loading indicators, progress bars, or other feedback mechanisms during file upload and processing. Check for proper error handling and user notifications. Deduct 5 points if there's no visual feedback during processing, and 3 points if error states are not properly communicated. 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 file uploads, failed analysis, browser compatibility issues, 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. Batch processing multiple images 2. Comparison views between original and analyzed images 3. Exportable analysis reports). 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 pipelines) 2. Function modules unrelated to image upload and analysis 3. Fancy effects that affect performance (e.g., unnecessary 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/processing/visualization logic), error handling patterns, 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 the code lacks comments or documentation. 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) Immediate feedback after upload action 2) Transition animation during analysis process 3) Clear visual indication of completed analysis. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between states, and 5 points for confusing workflow that doesn't guide users. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/html-webpage-mp3-wav-playlist-playback.json

@@ -0,0 +1,68 @@
+{
+  "index": 979,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that the code you generate is executable and can be demonstrated. Help me create an HTML webpage that reads MP3 and WAV files within the current directory to create a playlist for online playback.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the file loading and directory scanning mechanism properly implemented?",
+      "description": "Check if the code correctly implements file system access API or uses input type='file' with proper directory scanning. For browsers with FileSystem API support, verify directory traversal logic for MP3/WAV files. Score 0 if no file scanning is implemented, 5 if only basic file selection exists, and 10 if recursive directory scanning with proper error handling is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the audio player implement all core playback controls?",
+      "description": "Verify if the implementation includes play/pause, next/previous track, volume control, mute toggle, and progress bar functionality. Each missing control deducts 2 points. The player should properly handle transitions between tracks and maintain state when navigating the playlist. Score 10 for comprehensive controls with smooth transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is proper audio metadata extraction and display implemented?",
+      "description": "Evaluate whether the code extracts and displays ID3 tags from MP3 files and metadata from WAV files (artist, title, album, duration, etc.). Check for proper error handling when metadata is missing. Score 3 for basic filename display, 7 for partial metadata extraction, and 10 for complete metadata with album art display when available.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the playlist management system fully functional?",
+      "description": "Review if the code implements saving/loading playlists, drag-and-drop reordering, search/filter functionality, and playlist persistence (localStorage or IndexedDB). Deduct 2 points for each missing feature. Score 10 if the implementation includes shuffle, repeat modes, and custom playlist creation capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as unsupported file formats, corrupted audio files, browser compatibility issues, 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. Visualizer for audio frequencies 2. Keyboard shortcuts for playback control 3. Dark/light theme toggle). 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 volume control mechanisms) 2. Function modules unrelated to audio playback 3. Fancy effects that affect performance (e.g., unnecessary 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 audio processing/UI/storage logic), proper event handling patterns, and clean code structure. 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 error handling for browser compatibility. 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) Progress bar updates smoothly during playback 3) Clear visual feedback for current playing track. Deduct 5 points for each operation without feedback, 3 points for choppy progress updates during playback, and 5 points for hard-to-identify the current playing track. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/implement-curve-drawing-ol-js.json

@@ -0,0 +1,68 @@
+{
+  "index": 235,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure the code you generate is executable for demonstration purposes. Implement curve drawing using ol.js.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is a basic OpenLayers map initialization implemented correctly?",
+      "description": "Review whether the code properly initializes the OpenLayers (ol.js) map with appropriate configuration for projection, view settings, and base layers. Check if the map renders correctly with proper center coordinates and zoom level. Score 0 if map initialization is missing, 5 if basic initialization exists but with configuration issues, and 10 if fully implemented with proper configuration.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are curve drawing functionalities properly implemented?",
+      "description": "Evaluate whether the code successfully implements curve drawing capabilities using ol.js. Check for support of different curve types (Bezier, spline, arc, etc.) and proper use of ol.geom classes. Review if control points are properly handled. Score 0 if no curve implementation exists, 5 if only basic single-type curves are supported, and 10 if multiple curve types are implemented with appropriate control point handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is interactive curve creation/editing functionality implemented?",
+      "description": "Check if the code allows users to interactively create and edit curves by adding/dragging control points. Evaluate whether proper event handling (click, drag, mouseover) is implemented for curve manipulation. Score 0 if no interaction exists, 5 if basic point-adding functionality exists but lacks editing capabilities, and 10 if comprehensive curve creation and editing is implemented with proper event handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is curve styling properly implemented with customization options?",
+      "description": "Review whether the code provides options for styling curves (color, width, dash pattern, etc.) using ol.style classes. Check if the styling can be dynamically changed and if there are reasonable defaults. Score 0 if no styling is implemented, 5 if basic styling exists but lacks customization, and 10 if comprehensive styling options are available with appropriate defaults and dynamic updating.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input coordinates, edge cases like overlapping control points, browser resize events, 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. Curve animation along a path 2. Real-time curve measurements 3. Curve snapping to features 4. Curve interpolation options). 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 curve algorithms 2. Function modules unrelated to curve drawing/mapping 3. Fancy effects that affect map performance. 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 (separating curve logic, drawing utilities, and UI components), proper code organization, and performant implementation patterns. 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 is no separation between curve calculation logic and rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional mapping application standards?",
+      "description": "Evaluate whether the overall design follows mapping UI principles: 1) Appropriate positioning of controls (zoom, pan, curve tools) 2) Clear visual differentiation between different curve types 3) Professional map styling with appropriate contrast to drawn curves. Deduct 3 points for poorly positioned controls, 5 points for indistinguishable curve types, and 5 points for poor contrast between curves and basemap. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the curve drawing interaction smooth and intuitive?",
+      "description": "Judge whether the curve drawing interactions conform to user expectations: 1) Immediate visual feedback during drawing/editing 2) Smooth curve rendering without jitter during manipulation 3) Intuitive control point interaction. Deduct 5 points for laggy curve updates, 3 points for unclear control point visualizations, and 5 points for unintuitive curve manipulation mechanics. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/implement-windows-like-multi-window-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 270,
+  "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 for demonstration purposes. Implement Windows-like multi-window functionality in HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Window Creation and Management System",
+      "description": "Evaluate whether the code properly implements a window creation system with the ability to create, close, minimize, maximize, and restore windows. Check if windows have proper title bars, borders, and control buttons that respond to user interactions.0 points if window creation is not implemented; 5 points if basic window creation exists but lacks some controls; 10 points if the implementation includes all standard window controls (minimize, maximize, restore, close) with proper functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Window Dragging and Resizing",
+      "description": "Assess the implementation of window dragging (by title bar) and resizing (by borders or corners) functionality. Check if the code uses proper mouse event handling for smooth dragging and resizing operations, including cursor style changes when hovering over resize areas.0 points if dragging/resizing is not implemented; 5 points if only dragging is implemented or if resizing has significant limitations; 10 points if both dragging and resizing work smoothly with proper visual feedback and edge handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Z-Index Management and Focus Handling",
+      "description": "Evaluate the window stacking order management (z-index) and focus handling. Windows should come to front when clicked, and the active window should be visually distinguished from inactive ones. Check if there's proper management of window focus state.0 points if no z-index management exists; 5 points if basic z-index handling is implemented but with focus issues; 10 points if windows properly stack, with clear visual indication of the active window and correct focus management.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Window Content Management",
+      "description": "Check how window content is handled - whether windows can load different types of content (HTML elements, iframes, dynamic content), and if content correctly scales/scrolls when windows are resized. Evaluate if window content is properly contained within window boundaries.0 points if windows cannot hold content properly; 5 points if basic content display works but with limitations in scaling/scrolling; 10 points if windows can handle various content types with proper scaling, scrolling and containment.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code Robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicks, resizing beyond screen boundaries, memory management for multiple windows, etc.) and provide friendly error handling or recovery mechanisms.0 points if no exception handling exists; 5 points if basic error handling is implemented but some edge cases are unhandled; 10 points if comprehensive error handling is implemented with graceful degradation.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Innovative Features Implementation",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Snap-to-grid functionality 2. Window snapping to screen edges 3. Window grouping/tabbing 4. Virtual desktop/workspace implementation).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Feature Redundancy",
+      "description": "Strictly check for redundancies: 1. Redundant implementation of similar functions (e.g., multiple window management systems coexisting) 2. Function modules unrelated to window management 3. Fancy effects that affect performance without adding value.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": "Engineering Quality",
+      "description": "Review modular design (separation of window management logic from presentation), code organization, use of appropriate design patterns, and reusability of components. Check for proper event handling cleanup to avoid memory leaks.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 event listeners aren't properly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Visual Design and Windows UI Standards",
+      "description": "Evaluate whether the windows follow standard UI conventions and have a professional appearance: 1) Consistent visual styling 2) Proper spacing and padding within window elements 3) Professional-looking window decorations (title bars, borders, buttons) that match Windows-like aesthetics.Deduct 3 points for each inconsistent visual element, 5 points for non-standard window controls placement, and 5 points for unprofessional window styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Interaction Feedback and Animation Quality",
+      "description": "Judge whether the window interactions provide appropriate feedback and animations: 1) Windows respond immediately to user actions 2) Smooth minimize/maximize animations 3) Visual feedback during dragging/resizing operations 4) Appropriate transitions between window states.Deduct 5 points for each operation without feedback, 3 points for choppy or unnatural animations, and 5 points for missing visual cues during important interactions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}

package/library/web_applications-web_visuals/integrate-mapbox-gl-in-react.json

@@ -0,0 +1,68 @@
+{
+  "index": 1255,
+  "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. Help me generate code for integrating MapBox-GL in React.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the MapBox-GL integration properly initialized in React?",
+      "description": "Review whether the code correctly imports and initializes MapBox-GL with an API key, appropriate container configuration, and proper React lifecycle management. Check if useEffect is used correctly to handle map initialization and cleanup. Score 0 if MapBox-GL initialization is missing, 5 if basic initialization exists but with flaws, and 10 if fully implemented with proper access token management and error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are React-specific MapBox integration practices followed?",
+      "description": "Evaluate if the code follows React best practices for MapBox integration: using refs for DOM container management, handling component unmounting properly to prevent memory leaks, and efficiently managing state for map properties. Deduct 3 points if ref management is improper, 3 points if unmounting cleanup is missing, and 4 points if state management causes unnecessary re-renders. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are MapBox event handlers properly implemented?",
+      "description": "Check if map events (click, hover, drag, zoom) are handled correctly using React patterns. Event handlers should be properly memoized with useCallback to prevent unnecessary re-renders, and should correctly manage event propagation. Deduct 2 points for each event type that's improperly handled and 4 points if event cleanup on unmount is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper handling of MapBox layers and sources?",
+      "description": "Examine how the code manages MapBox layers and data sources. Proper implementation should include abstraction for layer management, conditional rendering of layers, and efficient updates without recreating the entire map. Deduct 3 points if layer management is hardcoded, 4 points if data source updates trigger full map reloads, and 3 points if there's no separation between data and presentation layers. 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 MapBox loading failures, API key errors, geolocation permission denials, 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. Custom map controls with React components 2. Animated data visualization layers 3. Integration with other geospatial libraries like Turf.js). 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 MapBox-GL wrapper libraries that add complexity without value 2. Unnecessary re-rendering of map or components 3. Over-fetching of geospatial data that could be optimized. 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 configuration/hooks/components), TypeScript typing for MapBox objects, and proper documentation. Deduct 5 points if global state pollution is found or custom hooks aren't created for reusable functionality; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the component structure doesn't follow 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) Proper map styling and theme consistency with the React application 2) Responsive design for different screen sizes 3) Accessibility considerations for map controls. Deduct 3 points for inconsistent styling, 5 points for non-responsive implementations, and 5 points for accessibility issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the map interaction smooth and performant?",
+      "description": "Judge whether the map interactions are optimized: 1) Map rendering performance during pan/zoom operations 2) Efficient handling of large datasets with clustering or virtualization 3) Appropriate use of worker threads for heavy computations. Deduct 5 points for noticeable frame drops during interaction, 3 points for performance bottlenecks with large datasets, and 5 points for blocking the main thread with intensive operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Web Visuals",
+  "difficulty": "easy"
+}