@getollie/cli 0.0.4 → 0.2.0

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

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

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

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

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

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

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

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

package/library/web_applications-web_visuals/frontend-online-preview-file-streams-vue2.json

@@ -1,68 +0,0 @@
-{
-  "index": 308,
-  "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 purposes. Implement frontend online preview of file streams in Vue 2.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the file streaming preview functionality fully implemented?",
-      "description": "Check whether the code correctly implements file streaming preview for common formats (PDF, images, videos, audio, text) using appropriate native or third-party viewers. Score 0 if no preview functionality is implemented, 5 if only basic formats are supported, and 10 if comprehensive format support with fallback mechanisms is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Vue 2 implementation technically correct?",
-      "description": "Evaluate whether the code follows Vue 2 best practices, including proper component structure, lifecycle hooks, and reactivity patterns. Check if it uses Vue-specific features appropriately (e.g., props, computed properties, watchers). Deduct 5 points for anti-patterns like direct DOM manipulation outside of directives, and 3 points for not using Vue's reactivity system properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the streaming implementation optimized?",
-      "description": "Assess if the implementation uses efficient streaming techniques like chunked loading, progressive rendering, or range requests instead of loading the entire file at once. Check if it handles large files (>10MB) without memory issues. Deduct 5 points if streaming is simulated with complete downloads, and 3 points if no loading progress indicator is provided. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the preview functionality secure and robust against malicious files?",
-      "description": "Verify that the code includes security measures such as content type validation, sanitization for potentially dangerous files, and proper error handling for corrupted files. Score 0 if no security measures are implemented, 5 if basic validation exists, and 10 if comprehensive protection (including sandboxing where appropriate) is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as unsupported file types, network interruptions, partial file loads, CORS 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. Automatic format detection 2. Thumbnail generation for quick preview 3. Dark mode support for previews 4. Annotation capabilities). 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 preview libraries for the same file type) 2. Function modules unrelated to file preview (e.g., built-in editing capabilities) 3. Fancy effects that affect performance (e.g., unnecessary animations during file loading). 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 preview logic/UI/network layers), test coverage, and error handling. Deduct 5 points if global state pollution is found or if 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 proper error boundary implementation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the preview interface follows modern design principles: 1) Responsive layout that works across device sizes 2) Proper controls positioning and sizing (play/pause, zoom, navigation) 3) Consistent visual language with the surrounding Vue application. Deduct 3 points for each usability issue, 5 points for disproportionate control sizes, and 5 points for preview containers that don't adapt to available space. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the preview interactions conform to user expectations: 1) Loading states with progress indication 2) Smooth transitions when switching between files or preview modes 3) Intuitive controls for different file types. Deduct 5 points for each missing loading indicator, 3 points for jarring transitions between states, and 5 points for unintuitive or inconsistent control behaviors across file types. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-File Management",
-  "difficulty": "easy"
-}

package/library/web_applications-web_visuals/frontend-rotating-ppt-charts-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 328,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for display. Create a frontend program that shows rotating PPT charts.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic PPT chart rotation functionality implemented?",
-      "description": "Check if the code implements core functionality for displaying and rotating between slides. Score 0 if no rotation mechanism exists, 5 if only basic manual navigation (prev/next) is implemented, 10 if it includes both manual and automatic rotation with transition controls.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are multiple chart types supported in the implementation?",
-      "description": "Evaluate the variety of chart types supported (e.g., bar charts, line charts, pie charts, scatter plots). Score 3 points for each chart type implemented with proper rendering and data binding, up to a maximum of 10 points. If only one basic chart type is implemented, score no more than 5 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the data visualization properly implemented with a flexible data structure?",
-      "description": "Review whether the code uses appropriate data structures for chart data and supports dynamic data updates. Score 0 if data is hardcoded without abstraction, 5 if there's basic data structure but limited flexibility, 10 if it provides a complete data model with update mechanisms and data validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are interactive chart features implemented?",
-      "description": "Examine whether the charts include interactive features such as tooltips on hover, zoom functionality, click events, or data filtering. Score 2 points for each interactive feature that enhances user experience, up to 10 points. Basic interactivity scores 5 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid data formats, missing values, window resizing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should 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 animation effects between slides 2. Theme switching capability 3. Export/import of chart configurations). 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 animation systems coexisting) 2. Function modules unrelated to PPT charts (e.g., unnecessary form elements) 3. Fancy effects that affect performance (e.g., excessive animations that slow down transitions). 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 chart logic/view/data layers), code reusability, and maintainability. 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 code organization or comments. 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) Slide transition smoothness with no visual stuttering 2) Transition animation duration controlled between 300-500ms 3) Clear visual cues for current slide position. Deduct 5 points for jarring or abrupt transitions, 3 points for animations that feel too slow or too fast, and 5 points for lack of progress indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "medium"
-}

package/library/web_applications-web_visuals/gridstackjs-vue3-designer.json

@@ -1,68 +0,0 @@
-{
-  "index": 1103,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration purposes. https://gridstackjs.com/ is the official website of gridstackjs. I want to create a large screen designer based on it with: left component list, layer management, top menu bar, middle layer area, and right property configuration panel. It should allow dynamically adding and dragging Vue components, dynamically adjusting component layers, and support features like screen theme colors, background images, and responsive design. Please implement this based on Vue3 + TypeScript.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the layout structure properly implemented with all required panels?",
-      "description": "Review whether the code correctly implements the five main areas (left component list, layer management, top menu bar, middle layer area, right property configuration panel) using proper Vue 3 components and CSS grid/flex layouts. Check if responsive breakpoints are properly defined and if the layout adapts well to different screen sizes. Deduct 3 points if any section is missing, 3 points for improper responsive design implementation, and 5 points if the panels cannot be resized or collapsed.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is GridStack.js correctly integrated with Vue 3 and TypeScript?",
-      "description": "Examine whether GridStack.js is properly wrapped as Vue components with TypeScript interfaces. Check if GridStack events are properly bound to Vue methods, if GridStack options are properly typed, and if the integration follows Vue 3 Composition API patterns. Score 10 points if fully implemented with proper type safety, 5 points if basic functionality works but with type issues, 0 points if the integration is broken or incomplete.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the component drag-and-drop system fully functional?",
-      "description": "Verify if components can be dragged from the left panel to the grid area with proper preview and positioning. Check if the drag interactions handle edge cases (grid boundaries, overlapping elements, etc.) and if the component is properly instantiated upon drop with correct properties. Evaluate if custom drag handles are implemented and if position data is properly synchronized with the state management system. Deduct 5 points if drag-and-drop doesn't work consistently, 3 points if it lacks visual feedback during drag.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the layer management system properly implemented?",
-      "description": "Assess if the layer panel correctly displays all components in the design with proper hierarchy, allows reordering through drag-and-drop, and synchronizes z-index changes with the GridStack instance. Check if layer visibility toggling, locking, and selection highlighting are implemented. Deduct 5 points if z-index management is broken, 3 points if layer reordering doesn't work properly, and 2 points if visual indicators for selection/visibility are missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as component loading errors, network interruptions, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms. Check if there are proper validation for user inputs, error boundaries for components, and defensive programming practices. 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. Component templates/presets system 2. Undo/redo functionality 3. Export/import capability 4. Real-time collaboration 5. Component animation editor). 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 state management solutions coexisting) 2. Function modules unrelated to screen design (e.g., built-in irrelevant tools) 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 TypeScript type definitions (proper interfaces, generics, and type guards), component composition (proper props/emits definitions, lifecycle handling), and build process setup. Check if the application follows Vue 3 best practices (Composition API usage, proper refs/reactive objects). Deduct 5 points if TypeScript is used incorrectly or has any \"any\" types; deduct 5 points if Vue components are poorly structured; deduct 3 points if there's no proper build configuration or optimization. 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 for the editor UI (distinguishable from the designed content) 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 between panels. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic panel organization. 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 when interacting with components 2) Smooth animations for resizing/moving components (60fps) 3) Clear visual indicators for selection, hover states, and active elements 4) Proper loading states for asynchronous operations. Deduct 5 points for sluggish drag operations, 3 points for missing interaction feedback, and 5 points for confusing UI states during operations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "hard"
-}

package/library/web_applications-web_visuals/h5-panoramic-vr-effect-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 1102,
-  "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. H5 implementation of panoramic VR effect code (without introducing other library files)",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the panoramic VR rendering core implemented correctly?",
-      "description": "Verify the implementation of the spherical projection algorithm, ensuring correct texture mapping using equirectangular projection. Check if the code includes proper handling of field of view (FOV), aspect ratio, and perspective distortion correction. Score 0 if no spherical projection is implemented, 5 if basic projection exists with inaccuracies, and 10 if the projection correctly renders 360° imagery with proper distortion handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mouse/touch interaction for camera control properly implemented?",
-      "description": "Evaluate the implementation of drag-to-rotate functionality, including proper event listeners for both mouse and touch inputs. Check for smooth damping effects, proper calculation of rotation angles based on input deltas, and prevention of gimbal lock. Look for inertia implementation for natural movement. Deduct 5 points if only one input method is supported, 3 points if interaction feels jerky or unnatural, and 2 points if edge cases (like rapid movements) aren't handled.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is device orientation support implemented for mobile VR experience?",
-      "description": "Assess whether the code uses the DeviceOrientation API to allow navigation via physical device movement. Check if the implementation includes proper permission handling, fallbacks for unsupported devices, and calibration options. Verify that orientation changes are translated correctly to camera rotation. Score 0 if completely missing, 5 if implemented but with significant limitations (e.g., works only in certain orientations), and 10 if fully functional with smooth and accurate tracking.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the panoramic image loading and texture management efficient?",
-      "description": "Check if the code implements proper image loading with progress indicators, error handling for failed loads, and optimization techniques like mip-mapping or progressive loading for large panoramic images. Verify that memory management is considered for large textures. Deduct 3 points if no loading feedback is provided, 5 points if image optimizations are absent, and 5 points if errors in loading aren't gracefully handled.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as unsupported browsers, WebGL initialization failures, image loading errors, etc.) and provide friendly error prompts or fallback mechanisms. Code with strong robustness should detect WebGL support, handle various aspect ratios, and manage resource limitations gracefully. Give 10 points for comprehensive error handling, 5 points for partial error handling, and 0 points if exceptions are unmanaged.",
-      "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 VR experience (e.g., 1. Hotspot navigation system 2. Animated transitions between panoramas 3. Customizable viewing filters 4. Audio spatialization tied to viewing direction). 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. Duplicate rendering approaches coexisting unnecessarily 2. Overly complex shader code for simple effects 3. Unused event listeners or abandoned experimental features still present in the code. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core VR functionality is impaired by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review the code structure for separation of concerns (renderer, controls, UI components), proper namespacing to avoid global pollution, and appropriate commenting. Check for hard-coded values that should be configurable parameters. Deduct 5 points for excessive global variables, 5 points for poor code organization (monolithic structure), and 5 points for inadequate documentation of the API or functions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether UI elements (controls, loading indicators, hotspots) follow modern design principles: 1) Minimal and unobtrusive UI that doesn't distract from the immersive experience 2) Clear iconography for interactive elements 3) Proper contrast ensuring visibility against varying panorama backgrounds. Deduct 3 points for cluttered UI elements, 5 points for controls that obscure the VR experience, and 5 points for poor visibility of interactive elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the performance optimization adequate for smooth VR experience?",
-      "description": "Judge whether the implementation maintains 60fps minimum for a smooth VR experience: 1) Efficient WebGL practices (proper use of buffers, minimal state changes) 2) Render optimizations like frustum culling or level-of-detail 3) Appropriate texture size management for mobile devices. Deduct 5 points for each noticeable frame drop during rotation, 5 points for excessive memory usage causing browser warnings, and 5 points if the code doesn't adapt rendering quality for different devices. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "hard"
-}