@getollie/cli 0.0.1

package/library/web_applications-education_learning/vue-example-for-comprehensive-understanding.json

@@ -0,0 +1,68 @@
+{
+  "index": 893,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Write a Vue example for me that will help me comprehensively understand Vue.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Does the example cover essential Vue fundamentals?",
+      "description": "Check if the code clearly demonstrates Vue's core concepts: data binding, directives (v-if, v-for, v-model, v-on), computed properties, watchers, and lifecycle hooks. All fundamental concepts should be included with proper explanations. Score 10 points for comprehensive coverage, 5 points if only basic concepts are included, 0 if fundamental Vue features are missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is component architecture properly demonstrated?",
+      "description": "Evaluate whether the example showcases Vue's component system including: parent-child components, props passing, custom events for child-to-parent communication, slots for content distribution, and scoped slots. Deduct 2 points for each missing component interaction pattern. The full implementation should demonstrate at least 3 levels of component nesting with clear separation of concerns.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is Vue Router implementation included and properly configured?",
+      "description": "Assess if the code includes Vue Router with dynamic routing, nested routes, navigation guards, route parameters, and programmatic navigation. The implementation should demonstrate lazy loading routes and route meta fields. Deduct 3 points if only basic routing is shown, 5 points if navigation guards are missing, and 10 points if routing is not implemented at all.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is Vuex state management properly implemented?",
+      "description": "Check if the example demonstrates Vuex with proper store structure (state, getters, mutations, actions, and modules). The code should show best practices for accessing store state, committing mutations, and dispatching actions. Look for module namespacing and proper separation of concerns. Full score requires at least 2 modules with different domains and async operations in actions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common edge cases (empty data, loading states, error handling) and includes proper input validation. Code with strong robustness should include try/catch blocks, form validation, and graceful error presentation. Score 10 points if error handling is comprehensive, 5 points if basic error handling exists, 0 points if no error handling is present.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes advanced features like: 1. Custom directives 2. Mixins or composition API usage 3. Render functions or JSX 4. Vue plugins 5. Performance optimizations like keep-alive. 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 reactive data that could be computed properties 2. Unnecessary component nesting 3. Overcomplicated solutions for simple problems. Deduct 3 points for each redundancy found, and directly deduct 10 points if core Vue concepts are obscured by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review code organization (proper component structure, single file components), naming conventions, comments/documentation, and reusability. Deduct 3 points if global state is overused; deduct 3 points if components exceed 200 lines; deduct 2 points if naming is inconsistent; deduct 2 points if documentation is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI components follow modern design principles: 1) Consistent color scheme 2) Proper spacing between elements 3) Responsive design considerations 4) Accessible contrast ratios. Deduct 3 points for inconsistent styling, 3 points for poor mobile responsiveness, 2 points for inaccessible color contrast, and 2 points for cluttered layouts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether transition/animation features are properly implemented: 1) Vue transition components for element/component transitions 2) List transitions 3) State transitions 4) Loading states with appropriate feedback. Deduct 3 points for missing transitions on important state changes, 3 points for janky animations, 2 points for missing loading indicators, and 2 points for abrupt UI changes. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/vue-mathlive-web-applications.json

@@ -0,0 +1,68 @@
+{
+  "index": 1529,
+  "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. Now, if we're developing a webpage using Vue combined with MathLive for web-only applications...",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue + MathLive integration properly implemented?",
+      "description": "Review whether the code correctly integrates MathLive with Vue using proper component wrapping or directives. Check for proper initialization, event handling, and data binding between Vue's reactive system and MathLive's editor. Score 0 if integration is missing, 5 if basic implementation exists but with reactivity issues, 10 if seamlessly integrated with proper Vue lifecycle management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the math input handling complete?",
+      "description": "Evaluate the implementation of math input functionality including keyboard shortcuts, special character input, LaTeX parsing, and formula validation. Check for support of common mathematical notations (fractions, integrals, matrices, etc.). Deduct 5 points if complex mathematical structures are unsupported, 3 points if keyboard shortcuts are incomplete. Full score requires comprehensive math input capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the MathLive configuration options properly utilized?",
+      "description": "Assess whether the code leverages MathLive's configuration options effectively (virtual keyboards, styling, fonts, locale settings, etc.). Check for customization that enhances user experience while maintaining accessibility. Deduct 3 points for each missing essential configuration (keyboard layout, styling, locale support). Give 10 points only if configuration is comprehensive and well-documented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper ARIA and accessibility implementation?",
+      "description": "Check whether the implementation includes proper screen reader support, keyboard navigation, and ARIA attributes for math content. Verify that mathematical expressions are accessible to assistive technologies. Deduct 5 points if ARIA attributes are missing, 3 points if keyboard navigation is incomplete, and 5 points if screen reader testing wasn't considered. Full score requires comprehensive accessibility implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid LaTeX input, browser compatibility issues, network interruption during resource 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. Real-time preview of rendered expressions 2. Formula history with undo/redo 3. Auto-completion for mathematical symbols 4. Formula templates library). 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 initialization of MathLive instances 2. Function modules unrelated to math editing (e.g., overengineered features) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down math rendering). 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 component architecture (such as separating UI/logic/state management), test coverage, and build process integration. Deduct 5 points if global state is used inappropriately; deduct 5 points if the code has high duplication; deduct 5 points if Vue best practices (computed properties, watchers, etc.) are not followed. 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 math editor 2) Proper layout spacing around mathematical expressions 3) Professional typesetting of mathematical content. Deduct 3 points for each poorly spaced element, 5 points for inconsistent styling between UI and math content, and 5 points for poor mathematical typesetting quality. 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 rendering of math input ≤ 100ms 2) Smooth cursor movement in complex expressions 3) Clear visual feedback during editing operations. Deduct 5 points for each noticeable lag during formula editing, 3 points for flickering during formula updates, and 5 points for confusing cursor behavior in complex expressions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/vue-reader-template-text-splitting-page-turning.json

@@ -0,0 +1,68 @@
+{
+  "index": 1272,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable for demonstration. Write a reader template using Vue.js that supports automatic splitting of long text and gesture-based page turning.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue.js reader component structure properly implemented?",
+      "description": "Review whether the code implements a proper Vue.js component structure with clear separation of template, script, and style. Check if Vue lifecycle hooks are correctly utilized (mounted, created, etc.). Score 0 if the component structure is missing, 5 if basic structure exists but lacks proper organization, and 10 if the component follows Vue.js best practices with proper props, emits, and composition API or options API usage.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the text splitting algorithm correctly implemented?",
+      "description": "Evaluate the text splitting logic to ensure it correctly calculates visible text per page based on container dimensions, font size, line height, and margins. Check if it handles edge cases like varying character widths, word breaks, and different languages. Deduct 3 points if it only works with fixed-width fonts, 5 points if it breaks words incorrectly, and 7 points if it doesn't adjust to container size changes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are gesture-based interactions properly implemented for page turning?",
+      "description": "Check if touch/swipe gestures are implemented for mobile and click/drag for desktop. Assess whether the code handles touch start, move, and end events correctly, with proper threshold calculation for determining page turns. Deduct 5 points if only one platform is supported (mobile or desktop), 3 points if gesture detection lacks sensitivity configuration, and 5 points if there's no visual feedback during gestures. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the reader include responsive design and viewport adaptation?",
+      "description": "Evaluate if the reader adapts to different screen sizes and orientations, recalculating page content dynamically. Check if it uses responsive units (vh/vw/rem) instead of fixed pixels, and implements media queries or dynamic calculations. Deduct 5 points if orientation changes aren't handled, 3 points if font size doesn't scale appropriately, and 5 points if the reader breaks on smaller screens. 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 empty text input, extremely long words, special characters, unicode emojis, 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 reading experience (e.g., 1. Page turning animations 2. Theme switching capabilities 3. Font size adjustment 4. Reading progress tracking 5. Bookmark functionality). 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 event listeners or watchers that could cause memory leaks 2. Function modules unrelated to reading experience (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive animations that impact page turning speed). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic/state management), reusability of components, and code maintainability. Deduct 5 points if global state is used excessively; deduct 3 points if the code lacks comments or documentation; deduct 5 points if there's significant code duplication instead of reusable functions. Check if proper Vue.js patterns are used (computed properties vs methods, refs vs reactive). 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 reading app principles: 1) Appropriate contrast for readability (light/dark modes) 2) Proper spacing between lines and paragraphs 3) Professional typography (suitable font choices, proper line length of 50-75 characters). Deduct 3 points for poor text contrast, 3 points for insufficient line spacing, 4 points for awkward text alignment, and 3 points for lack of visual reading cues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the page turning interaction smooth and intuitive?",
+      "description": "Judge whether the page transitions feel natural and responsive: 1) Page turn animation duration between 200-400ms 2) Visual feedback during swipe/drag operations 3) Clear indicators for page position and total pages. Deduct 5 points for jarring or stuttering transitions, 3 points for lack of visual confirmation during page turns, and 5 points if the interaction method isn't discoverable without instructions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/vue-simple-news-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 1513,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Develop a simple news webpage using Vue.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue application structure properly set up?",
+      "description": "Evaluate whether the code includes proper Vue application initialization, component structure, and project organization. Look for a main Vue instance, component registration, and appropriate separation of concerns. Score 0 if Vue is not properly initialized, 5 if basic setup exists but lacks organization, and 10 if the project follows Vue best practices with proper component hierarchy and module structure.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are news data fetching and state management implemented effectively?",
+      "description": "Check if the application includes proper data fetching (using Axios, Fetch API, etc.) from news APIs or mock data. Verify implementation of state management (Vuex store, reactive data, or composition API). Deduct 5 points if there's no error handling for failed requests, 3 points if caching mechanisms are absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the news listing functionality complete?",
+      "description": "Assess whether the code implements core news listing features including article cards, pagination/infinite scroll, and category filtering. Verify that article previews show essential information (title, date, source, thumbnail). Score 0 if basic listing is missing, 5 if only simple listing exists without filtering/pagination, and 10 if the implementation is comprehensive with multiple viewing options.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the application provide news detail view and user interaction?",
+      "description": "Evaluate if the application includes article detail views with Vue Router implementation, and user interaction features such as bookmarking, sharing, or commenting functionality. Check for proper route navigation and parameter passing. Deduct 5 points if routing is incorrectly implemented, 3 points if back navigation is broken. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, malformed data, slow network connections, 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. Dark mode toggle 2. Reading time estimation 3. Text-to-speech for articles 4. Personalized news recommendations). 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 state management solutions coexisting) 2. Function modules unrelated to news (e.g., a built-in calculator) 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 component design (such as separating presentational/container components), proper Vue lifecycle usage, computed properties vs methods usage, and build process configuration. Deduct 5 points if prop validation is missing; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if event handling is improperly 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). 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 scrolling, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/vue3-sql-to-er-diagram-converter.json

@@ -0,0 +1,68 @@
+{
+  "index": 1052,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Implement a website that converts SQL to ER diagrams using Vue 3.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "SQL Parsing and Schema Extraction",
+      "description": "Evaluate whether the code correctly parses various SQL schemas (CREATE TABLE statements) including constraints, foreign keys, and data types. Look for robust parsing that handles edge cases like quoted identifiers, comments, and multi-line SQL. Check if the parser can detect primary keys, foreign keys, nullable fields, default values, and complex constraints.0 points if no parsing logic is implemented, 5 points for basic CREATE TABLE parsing only, 10 points for complete parsing including constraints, relationships, and handling edge cases.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "ER Diagram Generation Logic",
+      "description": "Verify if the code correctly transforms the parsed SQL schema into proper entity-relationship model components. Check if entities, attributes, relationships (one-to-one, one-to-many, many-to-many) are properly identified. Assess whether cardinality and participation constraints are correctly inferred from foreign key definitions.Deduct 3 points if relationships are incorrectly identified, 3 points if attribute types are ignored, 2 points if cardinality is wrong. Full score for accurate transformation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Vue 3 Implementation Quality",
+      "description": "Evaluate if the code properly utilizes Vue 3 features such as Composition API, reactive state management, and component structure. Check for proper separation of concerns, reusable components, and Vue 3 best practices. Assess if the application uses ref/reactive appropriately and implements proper component lifecycle management.3 points for proper Vue 3 setup, 3 points for effective use of Composition API, 2 points for reactive state management, 2 points for well-structured components.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Diagram Visualization Technique",
+      "description": "Assess the visual representation technique (SVG/Canvas/WebGL) and rendering approach. Evaluate if entities, relationships, and attributes are visually distinguishable. Check if the diagram uses proper visual grammar (shape, color, connection styles) for ER notation standards (Chen/Crow's Foot/IE Notation/UML).Deduct 5 points if visualization is static/non-interactive, 3 points if standard ER notation principles are violated, 2 points if text/elements overlap. Full score for clean, standard-compliant visualization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code Robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed SQL input, large schemas, circular references) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases.0 points if no exception handling exists, 5 points if basic input validation is present, 10 points if comprehensive error handling with useful error messages is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Innovative Features",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time SQL validation 2. Export to multiple formats (PNG, PDF, JSON) 3. Interactive editing of the generated diagram 4. Schema optimization suggestions 5. Collaborative sharing).Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Feature Redundancy and Performance Impact",
+      "description": "Strictly check three types of redundancy: 1. Redundant parsing implementations 2. Function modules unrelated to SQL-to-ER conversion 3. Fancy effects that affect performance (e.g., unnecessary animations, over-complex rendering).Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Engineering Quality",
+      "description": "Review modular design (such as separating parsing logic, diagram generation, and UI components), unit test coverage, and build process automation. Check for proper error handling, code documentation, and maintenance considerations.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high; deduct 2 points if the build process is not automated.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Interface Design Quality",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color scheme appropriate for a technical tool 2) Proper layout with clear input/output sections 3) Professional typography with proper hierarchy for SQL code and diagram elements.Deduct 3 points for each usability issue, 4 points for poor contrast/readability, 3 points for inconsistent visual styling across components.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Interaction and User Experience",
+      "description": "Judge whether the interaction flow meets users' expectations: 1) Clear input method for SQL code 2) Responsive diagram generation 3) Intuitive diagram manipulation (pan/zoom/select) 4) Proper loading states and transitions when processing large schemas.Deduct 3 points for each missing interaction capability, 2 points for laggy/unresponsive UI, 2 points for confusing workflow, 3 points for lack of visual feedback during operations.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/vue3-vant-pdf-preview-functionality.json

@@ -0,0 +1,68 @@
+{
+  "index": 409,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration purposes. Implement PDF file preview functionality in a Vue 3 and Vant project.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the PDF preview core functionality fully implemented?",
+      "description": "Evaluate whether the implementation uses appropriate PDF rendering libraries (like PDF.js) with proper integration into Vue 3. Check if the PDF document loads correctly, pages render with proper quality, and zoom controls work. Score 0 if the core rendering is not implemented, 5 if only basic preview is available without navigation controls, and 10 if full PDF viewing capabilities are implemented including page navigation, zooming, and rotation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is Vue 3 integration correctly implemented?",
+      "description": "Verify that the PDF viewer properly utilizes Vue 3's Composition API, reactive state management, and lifecycle hooks. Check for proper component structure, ref/reactive usage, and setup() function implementation. Deduct 5 points if the implementation uses outdated patterns from Vue 2, 3 points if reactivity isn't properly utilized for PDF state management, and 2 points if proper error boundaries are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is Vant UI properly integrated with the PDF viewer?",
+      "description": "Assess whether Vant UI components are correctly used for the PDF viewer interface (e.g., buttons, loaders, icons, dialogs). Check if the implementation follows Vant design principles and responsive behaviors on mobile devices. Deduct 5 points if custom components are used where appropriate Vant components exist, 3 points if Vant theming isn't consistently applied, and 3 points if mobile adaptations are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are PDF loading states and error handling properly implemented?",
+      "description": "Check if the implementation handles different loading states (loading, success, error) with appropriate UI feedback using Vant components like Toast, Dialog, or Loading. Verify that network errors, invalid PDFs, and other edge cases are gracefully handled with user-friendly messages. Deduct 4 points for missing loading indicators, 4 points for inadequate error handling, and 2 points for missing retry mechanisms. 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 (large PDF files, slow networks, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Text search and highlighting 2. PDF annotation capabilities 3. Thumbnail navigation panel 4. Night mode for reading). Add 2.5 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 PDF rendering engines used simultaneously) 2. Function modules unrelated to PDF preview (e.g., built-in document editor) 3. Unnecessary animations or effects that affect performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of PDF rendering logic from UI components), configuration options, memory management, and resource disposal. Deduct 3 points if global state pollution is found; deduct 3 points if the PDF viewer doesn't properly clean up resources when unmounted; deduct 4 points if configuration options aren't abstracted properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the PDF viewer UI follows modern mobile design principles: 1) Consistent with Vant design language 2) Proper layout spacing for touch interactions (controls minimum 44px height) 3) Professional typography for PDF content display. Deduct 3 points for cluttered controls, 4 points for inconsistent design with the rest of the Vant application, and 3 points for poor readability of PDF content. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the PDF interactions conform to mobile touch behavior: 1) Smooth pinch-to-zoom 2) Responsive page navigation without jank 3) Clear loading progress indicators and transitions. Deduct 3 points for laggy page rendering, 3 points for unresponsive zoom controls, and 4 points for jarring page transitions or rendering artifacts. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/vue3-vite-render-docx-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 368,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure any code you generate is executable for demonstration purposes. Vue3 + Vite rendering docx to a webpage",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the docx rendering implementation complete?",
+      "description": "Review whether the code accurately implements docx rendering functionality using Vue3 and Vite. Check if it handles all essential document elements (paragraphs, tables, lists, images, styles, formatting). Score 0 if the core rendering is not implemented, 5 if only basic text rendering works, and 10 if the implementation handles complex document features including styles and formatting.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Vue3 component architecture well-designed?",
+      "description": "Evaluate the component hierarchy design for docx rendering. Check for proper use of Vue3 features (Composition API, setup script, reactive state management). Components should be modular, reusable, and follow single-responsibility principle. Deduct 3 points for monolithic components, 3 points for prop drilling beyond 3 levels, and 3 points for not utilizing Vue3's reactivity system effectively. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Vite configuration properly optimized for the docx rendering?",
+      "description": "Check whether the Vite configuration is optimized for docx processing (proper plugins, asset handling, build optimization). Verify that dependencies for docx parsing are correctly integrated. Deduct 3 points if WASM/worker threads aren't used for heavy parsing, 3 points for missing code splitting, and 3 points if build optimizations aren't tailored for document processing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the docx parsing and rendering pipeline efficient?",
+      "description": "Assess the efficiency of the parsing and rendering pipeline. Check if it uses streaming parsing for large documents, implements virtualization for long documents, and optimizes render cycles. Deduct 5 points if loading 5MB+ documents causes UI freezing, 3 points if rendering is not incremental/lazy, and 5 points if memory usage grows continuously with document size. 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 malformed docx files, network interruption during file loading, memory constraints). Code with strong robustness should gracefully handle these edge cases and provide user-friendly error messages. Award 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if exceptions crash the application.",
+      "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 editing 2. Automatic document outline generation 3. Search/indexing of document content 4. Print-to-PDF with preservation of formatting). 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 parsing/rendering logic (e.g., multiple docx parsers being used) 2. Function modules unrelated to document rendering (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations during document 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 parsing/rendering/UI layers), test coverage for parsing edge cases, 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 rendered document follows modern design principles: 1) Faithful reproduction of original docx styling 2) Proper layout spacing and margins 3) Professional font rendering with proper fallbacks. Deduct 3 points for inconsistent spacing between elements, 5 points for font rendering issues (jagged fonts, incorrect line height), and 5 points for layout that breaks on different screen sizes. 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) Document loading progress indicators 2) Smooth scrolling through long documents 3) Responsive UI during document processing. Deduct 5 points if loading lacks progress indication, 3 points for scroll jank or stuttering, and 5 points for UI elements that shift during document rendering. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/web-based-text-editor.json

@@ -0,0 +1,68 @@
+{
+  "index": 1287,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code in your demonstration. Write an HTTP website that allows users to edit and save text. Using the most simple and straightforward language, tell me how to do this.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is a complete HTTP server properly implemented?",
+      "description": "Evaluate whether the code implements a proper HTTP server using appropriate frameworks/libraries (e.g., Express.js, Flask, etc.). Check if it correctly handles HTTP requests (GET, POST) for serving the editor page and saving text. Deduct 5 points if the server doesn't implement proper routing, 5 points if error handling is missing, and 5 points if it lacks appropriate HTTP status codes. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the text editor UI functionality fully implemented?",
+      "description": "Review whether the code implements a functional text editor interface with essential features like text input, cursor positioning, and basic formatting. Score 0 if there's no editor implementation, 5 if only a basic textarea is provided without any enhancement, and 10 if the editor includes proper styling, clear visual feedback, and intuitive controls for text editing. Check if the editor component is appropriately integrated with the page layout.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the text saving mechanism properly implemented?",
+      "description": "Assess whether the code includes a proper mechanism to save edited text (client-side AJAX calls, form submission, etc.) and appropriate server-side handlers to process and store the data. Check for data persistence methods (file system, database). Deduct 5 points if saving is client-side only without server persistence, 5 points if there's no feedback after saving, and 3 points if there's no validation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a text loading/retrieval mechanism to edit previously saved content?",
+      "description": "Evaluate if the code implements functionality to retrieve and load previously saved text into the editor. Check for proper handling of file/data fetching and display in the editor. Deduct 5 points if there's no way to list or select saved files, 5 points if loading doesn't maintain formatting or content integrity, and 3 points if error handling for missing files is absent. 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 empty submissions, excessively large text inputs, concurrent edits, server 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. Auto-save functionality 2. Markdown support 3. Syntax highlighting 4. Version history/diff viewing). 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 saving mechanisms coexisting) 2. Function modules unrelated to text editing (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., complex animations that slow down typing). 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 editor logic/view/data layers), error handling, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between front-end and back-end concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Save operation feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for saving status. Deduct 5 points for each operation without feedback, 3 points for lag during typing or saving, and 5 points for confusing UI state indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}