@getollie/cli 0.0.1

package/library/multimedia_editing-image_editing/batch-image-compression-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 682,
+  "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.\n\n======== ROLE ========\nYou are an experienced code expert. You are provided with a software development requirement description and asked to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code with simple, easy-to-understand comments. Don't output anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code and ensure the project is fully executable\n2. Ensure all code files you output are complete, don't omit any code\n3. Carefully review and check all code before final output to evaluate its executability. If the code cannot be executed or contains errors, regenerate it\n4. If the requirements involve external API access or using user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nImplement a batch image compression tool. Users can upload multiple images and select a compression quality percentage. The tool needs to compress the images and provide a packaged download function.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the batch image upload functionality fully implemented?",
+      "description": "Review whether the code accurately implements multiple file selection through HTML file input with 'multiple' attribute, includes proper file type validation (JPEG, PNG, WebP, etc.), and handles file size limitations. Check if drag-and-drop upload is supported and if upload progress indicators are provided. Score 0 if basic multi-file upload is not working, 5 if only basic upload without validation is implemented, and 10 if all upload features including drag-and-drop and progress tracking are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image compression algorithm properly implemented?",
+      "description": "Evaluate whether the compression logic uses Canvas API or similar technology to resize and compress images with configurable quality settings. Check if the tool maintains aspect ratios, supports different output formats, and provides real-time compression preview. Deduct 5 points if compression quality control is not implemented, 3 points if aspect ratio is not preserved, and 2 points if no compression preview is available. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the batch processing mechanism efficiently designed?",
+      "description": "Check whether the batch processing uses Web Workers or similar asynchronous processing to prevent UI blocking, includes progress tracking for individual files and overall batch progress, and handles concurrent processing limits. Evaluate if error handling for individual file failures doesn't stop the entire batch. Deduct 5 points if processing blocks the UI, 3 points if no progress indication is provided, and 2 points if one file failure stops all processing.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the packaged download functionality complete?",
+      "description": "Verify whether the code implements ZIP file generation using JSZip or similar library, provides download triggers with proper file naming, and includes compression statistics (original vs compressed sizes). Check if the download handles large file batches without memory issues. Deduct 5 points if ZIP packaging is not implemented, 3 points if download fails for large batches, and 2 points if no compression statistics are provided. 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 corrupted image files, unsupported formats, memory limitations, network interruptions, and browser compatibility issues) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like extremely large files or invalid image data, 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 file size comparison charts 2. Batch rename functionality with custom patterns 3. Image format conversion options 4. EXIF data preservation settings 5. Compression quality preview with before/after comparison). 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 compression algorithms doing the same job) 2. Function modules unrelated to image compression (e.g., built-in image editor with complex filters) 3. Fancy effects that affect performance (e.g., heavy animations during compression). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core compression 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 handling/compression logic/UI layers), proper error handling, and code organization. Deduct 5 points if global state pollution is found or no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no proper file cleanup or memory management is implemented. 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) 4) Clear visual hierarchy for upload area, settings, and download sections. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic layout of compression controls. 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) File upload feedback delay ≤ 100ms 2) Compression progress animations are smooth and informative 3) Quality slider provides real-time preview updates 4) Clear visual focus guidance during batch processing. Deduct 5 points for each operation without feedback, 3 points for laggy progress indicators, and 5 points if compression quality changes don't provide immediate visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/canvas-javascript-image-editor-with-zoom.json

@@ -0,0 +1,68 @@
+{
+  "index": 938,
+  "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 demonstrated. Write an image editor using canvas + JavaScript, providing the following features:\n\n1. A button to open PNG, BMP, and JPG images\n\n2. The canvas size is temporarily fixed at 800x800. When an image is loaded, the initial display state shows only the 800x800 portion starting from the top-left corner (0,0) of the image. For images smaller than 800x800, the canvas displays a gray background in areas where the image doesn't reach. For images larger than 800x800, the canvas provides sliders to help users navigate to different positions within the image.\n\n3. Image zoom in/out functionality: When an image is successfully loaded, users can zoom in/out using the mouse wheel. During zooming, the canvas size remains fixed at 800x800, but the portion of the image displayed in the canvas area changes. If zoomed in, ensure that the maximum zoom limit displays one pixel of the image as 3x3 pixels on the canvas.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image loading functionality properly implemented?",
+      "description": "Review whether the code correctly implements file input for PNG, BMP, and JPG formats, handles file loading events, and properly displays the image on canvas. Check if file type validation is performed and appropriate error handling exists for unsupported formats or corrupted files.0 points if image loading fails completely, 5 points if basic loading works but lacks error handling, 10 points if all formats load correctly with proper error messages.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the canvas initialization and image rendering implemented correctly?",
+      "description": "Verify that the canvas is properly initialized with 800x800 dimensions, the context is correctly set up, and the initial image rendering displays the top-left (0,0) portion correctly. Check if gray background is properly rendered for images smaller than canvas dimensions.Deduct 5 points if canvas initialization is incorrect, 3 points if the initial rendering position is wrong, and 3 points if small images don't show proper gray background. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the sliders for large images implemented and functioning properly?",
+      "description": "Evaluate whether horizontal and vertical sliders appear for images larger than 800x800, and if they correctly control the viewport position on the image. Check if sliders are proportionally sized based on the image-to-canvas ratio and if scrolling is smooth and responsive.Deduct 4 points if sliders don't appear for large images, 3 points if slider positioning is inaccurate, and 3 points if scrolling performance is poor. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the zoom functionality working correctly with mouse wheel events?",
+      "description": "Check if mouse wheel events are properly captured and translated to zoom operations on the image. Verify that zooming maintains the point under the cursor as the focal point, respects the maximum zoom limit (1px of image = 3x3px on canvas), and preserves image quality during zoom operations.0 points if zooming doesn't work, 5 points if basic zooming works but without focal point preservation, 10 points if zooming is fully implemented with all requirements met.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles edge cases such as very large images, unsupported file types, rapid zoom operations, and browser compatibility issues. Check if there's proper error handling for failed image loading, browser canvas limitations, and memory management for large images.Give 10 points for strong robustness handling all edge cases, 5 points for average robustness with some edge cases handled, and 0 points if no error handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check for additional useful features beyond requirements, such as: 1. Image rotation tools 2. Basic filters (brightness/contrast/saturation) 3. Crop functionality 4. Undo/redo capability 5. Image export in different formats/sizes.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 for three types of redundancy: 1. Redundant canvas redraws that affect performance 2. Unnecessary event listeners or duplicate zoom/pan code paths 3. Overly complex implementations that could be simplified. Check if any code interferes with core image editing functionality.Deduct 3 points for each redundancy found, and directly deduct 10 points if core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular organization (separation of concerns between image loading, rendering, UI controls), code reusability, proper variable/function naming, and maintainability. Check for memory leaks when loading multiple large images.Deduct 5 points for global state pollution or lack of design patterns, 5 points for code duplication rate over 30%, 5 points if memory management is poor. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI follows modern design principles: 1) Clean, minimal control panel layout 2) Proper spacing between controls 3) Consistent button styling and visual feedback 4) Clear visual indicators for zoom level and canvas boundaries.Deduct 3 points for each crowded visual element, 5 points for inconsistent control styling, and 5 points for poor visual feedback during operations. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether image rendering and manipulation have acceptable performance: 1) Smooth zooming without visible lag 2) Responsive slider movement for large images 3) Immediate visual feedback when loading images 4) No freezing during image operations.Deduct 5 points for each operation with noticeable lag, 3 points for visual artifacts during zooming/panning, and 5 points for sluggish response on larger images. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "easy"
+}

package/library/multimedia_editing-image_editing/drawing-board-ios-notes-paperjs-vue3.json

@@ -0,0 +1,68 @@
+{
+  "index": 1634,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Implement a drawing board similar to the iOS Notes app functionality using Paper.js with Vue 3.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic drawing functionality properly implemented with Paper.js?",
+      "description": "Check whether the code correctly integrates Paper.js with Vue 3, implements proper canvas initialization, and provides fundamental drawing capabilities (pencil tool). Score 0 if Paper.js is not properly initialized, 5 if only basic drawing is implemented without proper event handling, and 10 if the implementation includes proper path creation, stroke management, and tool selection with appropriate event binding.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are essential drawing tools and features implemented?",
+      "description": "Evaluate whether the implementation includes essential drawing tools similar to iOS Notes: pencil with various thicknesses, eraser, selection tool, color picker with a palette matching iOS aesthetics. Deduct 2 points for each missing essential tool. Additionally, check for basic operations like undo/redo functionality (deduct 3 points if missing). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Vue 3 integration properly structured?",
+      "description": "Assess whether the code follows Vue 3 best practices: using Composition API correctly, proper lifecycle hooks management for canvas initialization/cleanup, and component-based architecture for tools and UI elements. Check if reactivity is properly handled for drawing state. Deduct 3 points if using Options API inappropriately, 3 points if Paper.js instances aren't properly managed in the component lifecycle, and 5 points if the implementation doesn't leverage Vue's reactivity system properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the implementation include iOS Notes-specific features?",
+      "description": "Verify that the implementation contains iOS Notes-specific features such as: pressure sensitivity support (if applicable), palm rejection simulation, seamless canvas panning/zooming, automatic stroke smoothing, and responsive design adapting to different screen sizes. Award 2 points for each feature properly implemented, with a maximum of 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, browser compatibility issues, touch/mouse input differences, memory management for large drawings) and provide friendly error handling. Code with strong robustness should gracefully 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. Shape recognition for converting rough sketches to perfect shapes, 2. Smart selection tool that recognizes drawing objects, 3. Background templates/grids, 4. Multi-layer support, 5. Export to multiple formats). Add 2 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 drawing engines coexisting) 2. Function modules unrelated to drawing (e.g., a built-in image gallery not tied to drawing) 3. Fancy effects that affect performance (e.g., excessive animations that impact drawing responsiveness). 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 drawing logic/UI/state management), unit test coverage, and build process configuration. 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 lacks optimization for canvas performance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet iOS Notes app design standards?",
+      "description": "Evaluate whether the overall design follows iOS Notes app aesthetic principles: 1) Minimalist UI with appropriate white space 2) iOS-style color palette and icons 3) Proper tool placement matching iOS conventions (bottom or top toolbar) 4) Consistent typography matching iOS standards. Deduct 3 points for each significant deviation from iOS design language, 5 points for cluttered or non-intuitive interfaces. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the drawing experience smooth and responsive?",
+      "description": "Judge whether the drawing experience matches the fluid nature of iOS Notes: 1) No visible lag between input and drawing (≤ 16ms delay) 2) Smooth line rendering without jitter 3) Proper handling of rapid drawing movements 4) Efficient canvas rendering even with complex drawings. Deduct 3 points for each noticeable performance issue, 5 points for significant input lag, and 5 points if the drawing experience degrades with moderately complex sketches. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/frontend-batch-image-annotation-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 586,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for demonstration.\n\n======== ROLE ========\nYou are an experienced code expert. I am providing you with a software development requirement description and asking you to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code with simple and easy-to-understand comments. Don't output anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code. Please ensure the project is fully executable\n2. Ensure all code files you output are complete, don't omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, it needs to be regenerated\n4. If the requirements involve external API access or need to use user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nWrite code to create a frontend project for batch image annotation. Users upload multiple images and can add text annotations to each image on the frontend interface. The annotation position can be customized. After completing the annotations, users can batch download the annotated images.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload functionality properly implemented?",
+      "description": "Evaluate whether the code provides a robust mechanism for selecting and uploading multiple images. Check if it handles various image formats (JPG, PNG, GIF, etc.), validates file types and sizes, and provides appropriate feedback during the upload process. The implementation should include drag-and-drop support and a traditional file browser option.0 points if image upload is not implemented; 5 points if basic upload is implemented but lacks validation or multi-file support; 10 points for complete implementation with proper validation, progress indicators, and error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image annotation feature fully functional?",
+      "description": "Check if the code allows users to add text annotations at custom positions on the images. Examine whether the annotation interface is intuitive, allows positioning via click or drag, and supports customization of text properties (font, size, color). Verify that annotations persist when switching between images and can be edited or deleted after creation.0 points if annotation functionality is missing; 5 points if basic text placement is implemented but lacks customization options; 10 points for a complete annotation system with positioning, styling options, and edit capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the batch processing capability implemented effectively?",
+      "description": "Assess whether the code supports efficient handling of multiple images. Check for a gallery or carousel view that allows users to navigate between uploaded images, maintain annotations separately for each image, and process all images as a batch when downloading. Look for optimization techniques that handle large numbers of images without performance degradation.0 points if only single image processing is supported; 5 points if batch viewing is implemented but lacks efficient navigation or separate annotation storage; 10 points for complete batch processing with optimization for large sets.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the batch download functionality properly implemented?",
+      "description": "Examine whether users can download all annotated images with a single action. Check if the code correctly merges annotations with original images, preserves image quality, and provides options for output format. Verify that the download process includes proper progress indication and handles potential errors gracefully.0 points if download functionality is missing; 5 points if download works but only for individual images or with quality loss; 10 points for complete batch download with preserved quality and format options.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations such as browser compatibility issues, large file uploads, unsupported image formats, or memory constraints. Check for appropriate error handling, fallback mechanisms, and user-friendly error messages.0 points if no exception handling exists; 5 points if basic error catching is implemented but lacks recovery mechanisms; 10 points for comprehensive error handling with graceful degradation and helpful user feedback.",
+      "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. Auto-adjustment of text color based on background brightness 2. Templates for common annotation patterns 3. Image enhancement tools 4. AI-assisted annotation positioning).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 libraries doing the same thing) 2. Function modules unrelated to image annotation (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive 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 annotation logic/image processing/UI components), code reusability, and appropriate use of design patterns. Check for proper state management, clean component hierarchy, and well-structured data flow.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 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 font system (body font size ≥ 14px, line height over 1.5 times). Check if the interface remains clean and focused on the primary task of image annotation.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) Responsive annotation placement with immediate visual feedback 2) Smooth transitions when switching between images 3) Intuitive drag-and-drop functionality for positioning annotations. Check if the interface remains responsive even when working with multiple high-resolution images.Deduct 5 points for each operation without feedback, 3 points for laggy performance during annotation placement, and 5 points for confusing navigation between images. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/frontend-image-editing-with-history-revert.json

@@ -0,0 +1,68 @@
+{
+  "index": 1617,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure that the generated code is executable for demonstration. Front-end image editing features including cutting, doodling, etc., with memory capability to revert to previous steps.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core image editing functionality correctly implemented?",
+      "description": "Review whether the code accurately implements essential image editing features (cutting, cropping, resizing, rotation) through Canvas/WebGL APIs. Check if the implementation handles proper aspect ratio maintenance, anti-aliasing for smooth edges, and correct pixel manipulation. Score 0 if no editing functions work, 5 if basic operations are buggy, and 10 if all operations produce professional-quality results.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the doodling/drawing system properly implemented?",
+      "description": "Evaluate if the drawing system includes multiple brush types, line smoothing algorithms, pressure sensitivity (if applicable), and proper rendering techniques. Check for stroke interpolation to ensure smooth curves even with fast mouse movements. Deduct 3 points if only basic drawing is implemented, 3 points if line quality is jagged, and 3 points if brush customization is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the undo/redo memory stack functionality complete?",
+      "description": "Assess if the code implements a proper state management system with command pattern or similar architecture to track editing history. Check if the memory management efficiently handles large images (using differential snapshots rather than full copies). Deduct 5 points if the history is limited to fewer than 10 steps, 3 points if large images cause performance issues, and 5 points if redo functionality is missing after undo. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are image manipulation filters and adjustments implemented?",
+      "description": "Check for implementation of common adjustments (brightness, contrast, saturation, etc.) and filters (blur, sharpen, etc.). Verify if the preview system allows real-time feedback before applying effects. Deduct 3 points if adjustments lack preview capability, 3 points if filters are implemented inefficiently causing lag, and 5 points if histogram visualization is missing for precise adjustments. 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 oversized images, unsupported formats, out-of-memory conditions, etc.) and provide friendly error prompts or recovery mechanisms. Check for proper validation before operations and graceful degradation on errors. 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. AI-assisted selection tools 2. Non-destructive editing layers 3. Advanced content-aware fill 4. Custom filter creation). 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 crop tools with identical functionality) 2. Function modules unrelated to image editing (e.g., built-in games) 3. Fancy effects that affect performance (e.g., excessive animations when switching tools). 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 core editing logic/rendering/UI layers), unit test coverage, and build process optimization. Check for proper separation of concerns and appropriate design patterns. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not optimized for performance. 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 professional image editor conventions: 1) Logical tool grouping and accessibility 2) Proper layout with adequate workspace emphasis 3) Non-intrusive UI that maximizes canvas visibility. Deduct 3 points for cluttered toolbars, 5 points for inconsistent icon design, and 5 points for poor contrast that affects usability. Check if the interface resembles industry standards like Photoshop or GIMP. 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 professional editing software standards: 1) Responsive brush strokes with no visible lag (≤ 16ms delay) 2) Smooth zoom/pan operations with proper interpolation 3) Appropriate visual feedback for selection and transformation operations. Deduct 5 points for noticeable lag when drawing, 3 points for jarring transitions between edit states, and 5 points for cursor feedback that doesn't match the active tool. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "hard"
+}

package/library/multimedia_editing-image_editing/gif-player-with-scroll-and-multiple-gifs.json

@@ -0,0 +1,68 @@
+{
+  "index": 1001,
+  "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. I need a player that can scroll through and play multiple GIFs.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the GIF player's core functionality fully implemented?",
+      "description": "Review whether the code accurately implements loading, displaying, and scrolling through multiple GIFs. Check if it handles different GIF formats properly and maintains timing for animated GIFs. Score 0 if the core functionality is missing, 5 if only basic display is implemented without scrolling, and 10 if both display and navigation between multiple GIFs work correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the playback control system robust and complete?",
+      "description": "Evaluate the implementation of play, pause, stop, and navigation controls between multiple GIFs. Check if the player properly maintains the playback state of each GIF when switching between them. Deduct 3 points if play/pause functionality is buggy, 3 points if navigation controls are missing or incomplete, and 4 points if the current playback state is not preserved when switching between GIFs.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the solution handle GIF loading and optimization properly?",
+      "description": "Check whether the code implements proper preloading mechanisms for smooth transition between GIFs, lazy loading for better performance, and error handling for failed loads. Assess if it manages memory efficiently when dealing with multiple GIFs. Deduct 3 points for missing preloading, 3 points for excessive memory usage, and 4 points for poor error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a responsive design for different screen sizes?",
+      "description": "Evaluate whether the GIF player is responsive across different devices and screen sizes. Check if it properly scales GIFs without breaking aspect ratios, and if the controls remain accessible and usable on mobile devices. Deduct 5 points if the layout breaks on mobile devices, 3 points if controls become unusable at certain screen sizes, and 2 points if GIFs don't scale properly.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted GIFs, varying GIF sizes, network interruption during loading, 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. GIF speed control 2. Frame-by-frame navigation 3. Thumbnail previews of all GIFs 4. Filter or effect application to GIFs). 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 scrolling mechanisms) 2. Function modules unrelated to GIF playback (e.g., unnecessary audio players) 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 GIF loading/playback/UI components), 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 no performance optimizations are implemented for handling multiple large GIFs. 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) Clean and intuitive controls that don't obstruct GIF viewing. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poorly positioned controls that interfere with content. 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) Smooth transitions between GIFs with animation duration between 300-500ms 2) Responsive controls with click feedback delay ≤ 100ms 3) Clear visual indication of current GIF in the sequence. Deduct 5 points for each operation without feedback, 3 points for jerky transitions between GIFs, and 5 points for unclear navigation elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "easy"
+}

package/library/multimedia_editing-image_editing/hbuilder-simple-drawing-app.json

@@ -0,0 +1,68 @@
+{
+  "index": 1535,
+  "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 and demonstrable. Please create a simple drawing app using HBuilder, with complete, runnable code for browsers. Provide step-by-step instructions on how to create it, how to import it, and how to package it.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the drawing functionality fully implemented?",
+      "description": "Check if the code provides core drawing capabilities: free-hand drawing, shape creation (at least rectangles, circles, and lines), color selection, and brush size adjustment. Score 0 if basic drawing isn't implemented, 5 if only basic pen tool works, 10 if all essential drawing tools are functional with proper event handling and canvas manipulation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the HBuilder integration properly explained?",
+      "description": "Evaluate whether clear instructions for HBuilder setup, project creation, and code organization are provided. Check for specific HBuilder-related configurations, plugin recommendations, and proper directory structures. Deduct 5 points if instructions are vague, 3 points if missing import/export procedures. Full score requires detailed steps with HBuilder-specific screenshots or command references.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the packaging process thoroughly documented?",
+      "description": "Assess if the code includes complete packaging instructions for different platforms (Web, Android, iOS) using HBuilder's capabilities. Check for manifest configuration, app icons setup, and deployment steps. Deduct 5 points if packaging steps are incomplete, 3 points if platform-specific settings are missing. Full score requires comprehensive packaging workflow with proper error handling scenarios.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are save/export functionalities implemented?",
+      "description": "Review whether the drawing app allows users to save their creations as image files (PNG/JPEG), and possibly export to cloud storage or share via social media. Check if the implementation includes file naming options and quality settings. Deduct 5 points if only basic saving is implemented, 3 points if no preview before saving exists. Full score requires multiple export formats and sharing capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, canvas size limitations, memory management for large drawings, 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. Layer management 2. Filters and effects 3. Undo/Redo history with previews). 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 color pickers) 2. Function modules unrelated to drawing (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations during drawing). 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/drawing logic/storage layers), code reusability, 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 drawing interactions conform to human perception characteristics: 1) No visible lag between pen movement and drawing (≤ 16ms) 2) Smooth transitions between tools and states 3) Clear visual feedback for selections and operations. Deduct 5 points for noticeable drawing lag, 3 points for jerky tool transitions, and 5 points for confusing or hidden tool states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "easy"
+}

package/library/multimedia_editing-image_editing/html-double-layer-rubiks-cube-photo-effect.json

@@ -0,0 +1,68 @@
+{
+  "index": 1116,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring that the generated code is executable for demonstration. Write an HTML program that creates a double-layer Rubik's cube photo effect.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the double-layer Rubik's cube photo effect correctly implemented?",
+      "description": "Check whether the code successfully creates a visual effect where photos are displayed on a double-layer Rubik's cube structure. The implementation should show correct perspective and layering with photos mapped onto cube faces. Score 0 if the effect is not implemented, 5 if only a basic cube with images is created, and 10 if a true double-layer structure with proper depth and perspective is achieved.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the HTML/CSS 3D transformation properly implemented?",
+      "description": "Evaluate the use of CSS 3D transforms (transform-style, perspective, rotateX/Y/Z) to create the cube structure. Check if the code correctly implements proper perspective origin, backface visibility, and z-index management. Deduct 5 points if the 3D illusion breaks at certain angles, 3 points if the perspective depth feels unnatural, and 5 points if transforms are improperly nested. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the cube rotation and interaction mechanism well-designed?",
+      "description": "Assess whether user interactions (mouse/touch) allow intuitive rotation of the cube. The code should include proper event handling, smooth transition between states, and maintain the integrity of the cube during rotation. Deduct 5 points if rotation is jerky, 3 points if the rotation axis is inconsistent with user input direction, and 5 points if the cube structure distorts during rotation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the photo mapping and texture handling properly implemented?",
+      "description": "Check if images are properly mapped to cube faces without distortion, if image preloading is implemented, and if the code handles different image aspect ratios. Deduct 3 points for visible seams between cube faces, 5 points for image distortion, and 5 points if images aren't responsive to container size changes. 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 missing images, browser compatibility issues, variable screen sizes, etc.) and provide fallbacks or graceful degradation. 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. Animated cube assembly/disassembly 2. Dynamic photo transitions when rotating 3. Light/shadow effects that respond to cube orientation). 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 CSS properties that override each other 2. Unnecessary JavaScript calculations that don't contribute to the core functionality 3. Excessive visual elements that distract from the Rubik's cube photo effect. 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 structure/style/interaction logic), code reusability, and performance optimization. Deduct 5 points if global variables are overused or if there's no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no performance optimizations (e.g., for animations). 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) Clean presentation of the cube without visual clutter 2) Proper contrast between cube elements and background 3) Professional UI elements for any controls. Deduct 3 points for each instance of poor element spacing, 5 points for clashing colors that affect visibility, and 5 points for awkward positioning of the cube in the viewport. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the animations and transitions conform to human perception characteristics: 1) Smooth rotation without frame drops 2) Appropriate easing functions for natural movement 3) Clear visual feedback during interactions. Deduct 5 points for jerky animations, 3 points for abrupt transitions between states, and 5 points for delayed response to user input (>100ms). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}