@windward/core 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -1,20 +1,38 @@
 # Changelog
 
-## Release [0.22.0] - 2025-08-25
+## Release [0.23.0] - 2025-09-18
 
+* Merged in feature/LE-2099-track-engagement-on-videos-from- (pull request #439)
+* Merged in bugfix/LE-2071-vimeo-videos-not-working (pull request #438)
+* Merged in bugfix/LE-2071-vimeo-videos-not-working (pull request #437)
+* Merged in bugfix/LE-2088-open-response-block-remove-edito (pull request #434)
+* Merged in bugfix/MIND-6075-decouple-generateaiquestionbut (pull request #432)
+* Merged in bugfix/LE-2071-vimeo-videos-not-working (pull request #433)
+* Merged in bugfix/LE-2052-clickable-icon-text-color-should (pull request #426)
+* Merged in bugfix/LE-2088-open-response-block-remove-edito (pull request #430)
+* Merged release/0.23.0 into bugfix/LE-2071-vimeo-videos-not-working
+* Merged release/0.22.0 into bugfix/LE-2052-clickable-icon-text-color-should
+
+
+## Release [0.22.0] - 2025-08-28
+
+* Merge branch 'master' into release/0.22.0
 * Merged in bugfix/LE-2075-the-panel-of-the-text-block-isnt (pull request #427)
 * Merged in bug-fix/LE-2060/llm-character-limit-validation (pull request #421)
 * Merged in bugfix/LE-2031-open-response-download-collate-q (pull request #422)
 * Merged in bugfix/LE-1960-video-using-urls-as-a-source (pull request #423)
+* Merged in hotfix/0.21.1 (pull request #425)
 * Merged release/0.22.0 into bugfix/LE-1960-video-using-urls-as-a-source
 * Merged in bugfix/LE-2057-save-button-disappeared-again-on (pull request #419)
 * Merged release/0.22.0 into bugfix/LE-1960-video-using-urls-as-a-source
 * Merged in feature/LE-2036/word-jumble-gen (pull request #420)
 * Merged in feature/LE-1997/scenario-gen (pull request #416)
 * Merged in bugfix/LE-1928-user-upload-allowed-file-types (pull request #415)
+* Merged in release/0.21.0 (pull request #401)
 * Merged release/0.21.0 into bugfix/LE-1960-video-using-urls-as-a-source
 * Merged release/0.21.0 into bugfix/LE-1928-user-upload-allowed-file-types
 
+
 ## Hotfix [0.21.1] created - 2025-08-20
 
 

package/components/Content/Blocks/ClickableIcons.vue

@@ -54,10 +54,10 @@
                             </v-avatar>
                             <v-icon
                                 v-else-if="isIcon(item.icon)"
-                                class="clickable--icon black--text"
-                                >{{ item.icon }}</v-icon
-                            >
-                            <span v-else :class="iconClass + ' black--text'">{{
+                                class="clickable--icon dark-text--text"
+                                >{{ item.icon }}
+                            </v-icon>
+                            <span v-else :class="iconClass + ' dark-text--text'">{{
                                 decode(item.icon)
                             }}</span>
                         </button>
@@ -142,7 +142,7 @@ export default {
                     ) &&
                     this.itemColor(itemIndex)
                 ) {
-                    classes += ' ' + this.itemColor(itemIndex) + ' black--text'
+                    classes += ' ' + this.itemColor(itemIndex) + ' dark-text--text'
                 }
                 return classes
             }
@@ -276,6 +276,9 @@ button.button-icon.button-icon--outline {
     background-color: #fff !important;
     border-width: 4px;
     border-style: solid;
+    i.clickable--icon.dark-text--text {
+        color: var(--v-dark-text-base) !important;
+    }
 }
 
 button.button-icon.button-icon--rounded {

package/components/Content/Blocks/OpenResponse.vue

@@ -33,6 +33,7 @@
                     v-model="response"
                     :height="200"
                     menubar=""
+                    :toolbar="'styles | bold italic underline strikethrough removeformat | alignleft aligncenter alignright | table tablerowprops tablecellprops |bullist numlist outdent indent | a11yButton | undo redo'"
                 ></TextEditor>
                 <p class="pa-3 text-center">
                     <v-btn

package/components/Content/Blocks/Video.vue

@@ -390,6 +390,9 @@ export default {
                     this.emitCompleted()
                 }
             }
+
+            // Manually emit `hook:updated` on timeupdates since otherwise the DOM isn't actually changing so the state never gets preserved
+            this.$emit('hook:updated')
         },
         async onBeforeSave() {
             this.block.body = 'video'

package/components/Settings/ScenarioChoiceSettings.vue

@@ -129,17 +129,21 @@
                 </v-btn>
             </v-row>
         </v-container>
-        
+
         <v-container class="pa-4 mb-6">
             <v-row>
                 <v-col cols="12">
-                    <GenerateAIQuestionButton
-                        :course="course"
-                        :content="currentContent"
-                        :block="block"
-                        question-type="scenario_game"
-                        @click:generate="onGeneratedScenarioGame"
-                    ></GenerateAIQuestionButton>
+                    <PluginRef
+                        target="contentBlockSettingTool"
+                        :attrs="{
+                            value: block,
+                            course: course,
+                            content: currentContent,
+                        }"
+                        :on="{
+                            append: onPluginAppendBlock,
+                        }"
+                    ></PluginRef>
                 </v-col>
             </v-row>
         </v-container>
@@ -203,14 +207,14 @@
 </template>
 <script>
 import _ from 'lodash'
-import BaseContentBlockSettings from '~/components/Content/Settings/BaseContentBlockSettings.vue'
 import { mapGetters } from 'vuex'
+import BaseContentBlockSettings from '~/components/Content/Settings/BaseContentBlockSettings.vue'
 import BaseContentSettings from '~/components/Content/Settings/BaseContentSettings.js'
 import SortableExpansionPanel from '~/components/Core/SortableExpansionPanel.vue'
 import DialogBox from '~/components/Core/DialogBox.vue'
 import Uuid from '~/helpers/Uuid'
 import TextEditor from '~/components/Text/TextEditor'
-import GenerateAIQuestionButton from '../utils/GenerateAIQuestionButton.vue'
+import PluginRef from '~/components/Core/PluginRef.vue'
 
 export default {
     name: 'ScenarioChoiceSettings',
@@ -219,7 +223,7 @@ export default {
         TextEditor,
         DialogBox,
         BaseContentBlockSettings,
-        GenerateAIQuestionButton,
+        PluginRef,
     },
     extends: BaseContentSettings,
     data() {
@@ -369,41 +373,52 @@ export default {
                 !_.isEmpty(this.block.metadata.config.link_content_id) &&
                 !_.isEmpty(this.block.metadata.config.link_text)
         },
-        onGeneratedScenarioGame(activityData) {
+        onPluginAppendBlock(activityData) {
             // Process the activity data
-            if (activityData && activityData.metadata && 
+            if (
+                activityData &&
+                activityData.metadata &&
                 activityData.metadata.config &&
                 activityData.metadata.config.items &&
-                Array.isArray(activityData.metadata.config.items)) {
-
+                Array.isArray(activityData.metadata.config.items)
+            ) {
                 // Clear existing items and replace with generated ones
-                this.block.metadata.config.items.splice(0, this.block.metadata.config.items.length)
+                this.block.metadata.config.items.splice(
+                    0,
+                    this.block.metadata.config.items.length
+                )
 
                 // Add all new choices
-                activityData.metadata.config.items.forEach(item => {
+                activityData.metadata.config.items.forEach((item) => {
                     this.block.metadata.config.items.push({
                         title: item.title || '',
                         body: item.body || '<p></p>',
-                        correct: item.correct || false
+                        correct: item.correct || false,
                     })
                 })
 
                 // Update title and instructions if provided
                 if (activityData.metadata.config.title) {
-                    this.block.metadata.config.title = activityData.metadata.config.title
+                    this.block.metadata.config.title =
+                        activityData.metadata.config.title
                 }
 
                 if (activityData.metadata.config.instructions) {
-                    this.block.metadata.config.instructions = activityData.metadata.config.instructions
+                    this.block.metadata.config.instructions =
+                        activityData.metadata.config.instructions
                 }
 
                 this.$toast.success(
-                    this.$t('windward.core.components.settings.scenario_choice.generated_successfully'),
+                    this.$t(
+                        'windward.core.components.settings.scenario_choice.generated_successfully'
+                    ),
                     { duration: 3000 }
                 )
             } else {
                 this.$toast.error(
-                    this.$t('windward.core.components.settings.scenario_choice.invalid_response'),
+                    this.$t(
+                        'windward.core.components.settings.scenario_choice.invalid_response'
+                    ),
                     { duration: 5000 }
                 )
             }

package/components/Settings/VideoSettings/SourcePicker.vue

@@ -3,7 +3,7 @@
         <ContentBlockAsset
             :value="source"
             :assets="assets"
-            mimes="video/mp4,video/webm,video/youtube,audio/mpeg,audio/ogg,audio/webm,audio/wav"
+            mimes="video/mp4,video/webm,video/youtube,video/vimeo,audio/mpeg,audio/ogg,audio/webm,audio/wav"
             allow-url
             class="mb-4"
             :disabled="disabled"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@windward/core",
-    "version": "0.22.0",
+    "version": "0.23.0",
     "description": "Windward UI Core Plugins",
     "main": "plugin.js",
     "scripts": {
@@ -21,7 +21,7 @@
     "license": "MIT",
     "homepage": "https://bitbucket.org/mindedge/windward-ui-plugin-core#readme",
     "dependencies": {
-        "@mindedge/vuetify-player": "^0.4.9",
+        "@mindedge/vuetify-player": "^0.5.1",
         "@tinymce/tinymce-vue": "^3.2.8",
         "accessibility-scanner": "^0.0.1",
         "eslint": "^8.11.0",

package/plugin.js

@@ -294,7 +294,7 @@ export default {
                 },
             },
         ],
-        settings: [
+        contentBlockSetting: [
             {
                 tag: 'core-open-response-settings',
                 template: OpenResponseSettings,

package/utils/index.js

@@ -7,7 +7,6 @@ import TinyMCEWrapper from '../components/utils/TinyMCEWrapper.vue'
 import MathExpressionEditor from '../components/utils/MathExpressionEditor'
 import CourseGlossary from '../components/utils/glossary/CourseGlossary.vue'
 import CourseGlossaryForm from '../components/utils/glossary/CourseGlossaryForm.vue'
-import GenerateAIQuestionButton from '../components/utils/GenerateAIQuestionButton.vue'
 
 export {
     MathHelper,
@@ -17,5 +16,4 @@ export {
     TinyMCEWrapper,
     CourseGlossary,
     CourseGlossaryForm,
-    GenerateAIQuestionButton,
 }

package/components/utils/GenerateAIQuestionButton.vue

@@ -1,826 +0,0 @@
-<template>
-    <div>
-        <v-row class="container-generate-ai mt-2">
-            <v-col>{{
-                $t(
-                    'windward.core.components.content.blocks.generate_questions.ai_assistance'
-                )
-            }}</v-col>
-            <v-col>
-                <v-select
-                    v-model="selectedContent"
-                    :items="flattenedContent"
-                    class="btn-selector"
-                    outlined
-                    hide-details
-                    dense
-                    :label="
-                        $t(
-                            'windward.core.components.content.blocks.generate_questions.selected_pages'
-                        )
-                    "
-                    item-text="content.name"
-                    return-object
-                ></v-select>
-            </v-col>
-            <v-col>
-                <v-select
-                    v-model="selectedDifficulty"
-                    :items="taxonomyLevels"
-                    item-text="text"
-                    class="btn-selector"
-                    outlined
-                    :hide-details="!isBucketGameType"
-                    dense
-                    :label="
-                        $t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.blooms_taxonomy'
-                        )
-                    "
-                    return-object
-                ></v-select>
-                <div v-if="isBucketGameType" class="text-caption mt-1">
-                    {{ $t('windward.core.components.content.blocks.generate_questions.replaces_content') }}
-                </div>
-            </v-col>
-            <v-col
-                v-if="isFlashcardType || isMatchingGameType || isSortingGameType || isWordJumbleType"
-                cols="auto"
-                class="d-flex align-center"
-            >
-                <v-switch
-                    v-model="replaceExisting"
-                    hide-details
-                    dense
-                    color="secondary"
-                    class="mt-0 pt-0"
-                    :label="replaceExistingLabel"
-                    :disabled="isLoading"
-                ></v-switch>
-            </v-col>
-            <v-col>
-                <v-btn
-                    elevation="0"
-                    color="secondary"
-                    class="mb-1 btn-selector"
-                    :loading="isLoading"
-                    :disabled="isLoading"
-                    @click="generateAIQuestion"
-                >
-                    <v-icon v-if="!isLoading" class="pr-1"
-                        >mdi-magic-staff</v-icon
-                    >
-                    {{ buttonLabel }}
-                    <template v-slot:loader>
-                        <v-progress-circular
-                            indeterminate
-                            size="23"
-                        ></v-progress-circular>
-                    </template>
-                </v-btn>
-            </v-col>
-        </v-row>
-    </div>
-</template>
-
-<script>
-import _ from 'lodash'
-import { mapGetters } from 'vuex'
-import AssessmentQuestion from '~/models/AssessmentQuestion'
-import Course from '~/models/Course'
-import Assessment from '~/models/Assessment'
-import Content from '~/models/Content'
-import Activity from '../../models/Activity'
-
-export default {
-    name: 'GenerateAIQuestionButton',
-    props: {
-        course: { type: Object, required: true },
-        content: { type: Object, required: true },
-        block: { type: Object, required: true },
-        questionType: { type: String, required: true },
-        replaceExistingMode: { type: Boolean, default: false },
-    },
-    data() {
-        return {
-            isLoading: false,
-            selectedContent: '',
-            selectedDifficulty: {
-                value: 'None',
-                text: this.$t(
-                    'windward.core.components.content.blocks.generate_questions.blooms.none'
-                ),
-            },
-            replaceExisting: this.questionType === 'bucket_game' || this.questionType === 'word_jumble' ? true : this.replaceExistingMode,
-        }
-    },
-    computed: {
-        ...mapGetters({
-            contentTree: 'content/getTree',
-        }),
-        isFlashcardType() {
-            return this.questionType === 'flashcard'
-        },
-        isBucketGameType() {
-            return this.questionType === 'bucket_game'
-        },
-        isMatchingGameType() {
-            
-            return this.questionType === 'matching_game'
-        },
-        isSortingGameType() {
-            return this.questionType === 'sorting_game'
-        },
-        isScenarioGameType() {
-            return this.questionType === 'scenario_game'
-        },
-        isWordJumbleType() {
-            return this.questionType === 'word_jumble'
-        },
-        replaceExistingLabel() {
-            if (this.isBucketGameType) {
-                return this.$t(
-                    'windward.games.components.settings.bucket_game.form.replace_existing'
-                )
-                return this.$t(
-                    'windward.games.components.settings.bucket_game.form.replace_existing'
-                )
-            }
-            if (this.isMatchingGameType) {
-                return this.$t(
-                'windward.games.components.settings.matching_game.form.replace_existing')
-            }
-            if (this.isSortingGameType) {
-                return this.$t(
-                'windward.games.components.settings.sorting_game.form.replace_existing')
-            }
-            if (this.isWordJumbleType) {
-                return this.$t(
-                'windward.games.components.settings.word_jumble.form.replace_existing')
-            }
-            return this.$t(
-                'windward.games.components.settings.flashcard.form.replace_existing'
-            
-            )
-        },
-        flattenedContent() {
-            let cloneContentTree = _.cloneDeep(this.contentTree)
-            const homepage = this.$ContentService.getHomepage()
-            if (!_.isEmpty(homepage)) {
-                cloneContentTree.unshift(homepage)
-            }
-            let fullTree = []
-            // flatten content tree to get nested children pages
-            cloneContentTree.forEach((content) => {
-                fullTree.push(content)
-                if (content.children.length > 0) {
-                    fullTree = fullTree.concat(_.flatten(content.children))
-                    // check if children have children
-                    content.children.forEach((child) => {
-                        fullTree = fullTree.concat(_.flatten(child.children))
-                    })
-                }
-            })
-            //
-            if (_.isEmpty(this.selectedContent)) {
-                // returns array so hold here to pluck out below
-                const currentPage = fullTree.filter(
-                    (contentPage) => contentPage.id === this.content.id
-                )
-                this.selectedContent = currentPage[0] ? currentPage[0] : ''
-            }
-            return fullTree
-        },
-        taxonomyLevels() {
-            // For word jumble games, only show None, Remember, Understand, Apply
-            if (this.isWordJumbleType) {
-                return [
-                    {
-                        value: 'None',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.none'
-                        ),
-                    },
-                    {
-                        value: 'Remember',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.remember'
-                        ),
-                    },
-                    {
-                        value: 'Understand',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.understand'
-                        ),
-                    },
-                    {
-                        value: 'Apply',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.apply'
-                        ),
-                    },
-                ]
-            }
-            
-            // For scenario games, only show None, Apply, Analyze, Evaluate
-            if (this.isScenarioGameType) {
-                return [
-                    {
-                        value: 'None',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.none'
-                        ),
-                    },
-                    {
-                        value: 'Apply',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.apply'
-                        ),
-                    },
-                    {
-                        value: 'Analyze',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.analyze'
-                        ),
-                    },
-                    {
-                        value: 'Evaluate',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.evaluate'
-                        ),
-                    },
-                ]
-            }
-            
-            // Basic Bloom's taxonomy levels available to all question types
-            let basicBloomTaxonomy = [
-                {
-                    value: 'None',
-                    text: this.$t(
-                        'windward.core.components.content.blocks.generate_questions.blooms.none'
-                    ),
-                },
-                {
-                    value: 'Remember',
-                    text: this.$t(
-                        'windward.core.components.content.blocks.generate_questions.blooms.remember'
-                    ),
-                },
-                {
-                    value: 'Understand',
-                    text: this.$t(
-                        'windward.core.components.content.blocks.generate_questions.blooms.understand'
-                    ),
-                },
-                {
-                    value: 'Apply',
-                    text: this.$t(
-                        'windward.core.components.content.blocks.generate_questions.blooms.apply'
-                    ),
-                },
-            ]
-
-            // Only add higher-level Bloom's taxonomy for supported question types
-            const supportsAdvancedTaxonomy = 
-                this.isSortingGameType ||
-                this.isScenarioGameType ||
-                ([
-                    'multi_choice_single_answer',
-                    'multi_choice_multi_answer',
-                    'ordering'
-                ].includes(this.questionType) &&
-                !this.isFlashcardType &&
-                !this.isBucketGameType &&
-                !this.isMatchingGameType)
-
-            if (supportsAdvancedTaxonomy) {
-                const multiBlooms = [
-                    {
-                        value: 'Analyze',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.analyze'
-                        ),
-                    },
-                    {
-                        value: 'Evaluate',
-                        text: this.$t(
-                            'windward.core.components.content.blocks.generate_questions.blooms.evaluate'
-                        ),
-                    },
-                ]
-                basicBloomTaxonomy = basicBloomTaxonomy.concat(multiBlooms)
-            }
-            return basicBloomTaxonomy
-        },
-        buttonLabel() {
-            if (this.questionType === 'flashcard') {
-                return this.$t(
-                    'windward.core.components.content.blocks.generate_questions.button_label_flashcard'
-                )
-            } else if (this.questionType === 'bucket_game') {
-                return this.$t(
-                    'windward.core.components.content.blocks.generate_questions.button_label_bucket_game'
-                )
-            } else if (this.questionType === 'matching_game') {
-                return this.$t(
-                    'windward.core.components.content.blocks.generate_questions.button_label_matching_game'
-                )
-            } else if (this.questionType === 'sorting_game') {
-                return this.$t(
-                    'windward.core.components.content.blocks.generate_questions.button_label_sorting_game'
-                )
-            } else if (this.questionType === 'scenario_game') {
-                return this.$t(
-                    'windward.core.components.content.blocks.generate_questions.button_label_scenario_game'
-                )
-            } else if (this.questionType === 'word_jumble') {
-                return this.$t(
-                    'windward.core.components.content.blocks.generate_questions.button_label_word_jumble'
-                )
-            } else {
-                return this.$t(
-                    'windward.core.components.content.blocks.generate_questions.button_label'
-                )
-            }
-        },
-    },
-    methods: {
-        async generateAIQuestion() {
-            this.isLoading = true
-            try {
-                let bloomsRequest = ''
-                if (
-                    this.selectedDifficulty.text !==
-                    this.$t(
-                        'windward.core.components.content.blocks.generate_questions.blooms.none'
-                    )
-                ) {
-                    bloomsRequest = `?blooms_level=${this.selectedDifficulty.value}`
-                }
-
-                const course = new Course(this.course)
-                const contentData = this.selectedContent || this.content
-                const content = new Content(contentData)
-
-                let response
-                if (this.questionType === 'flashcard') {
-                    // FLASHCARD GENERATION
-                    const activity = new Activity()
-
-                    const endpoint = `suggest/flashcard${bloomsRequest}`
-
-                    // Call the endpoint exactly like FlashCardSlidesManager does
-                    response = await Activity.custom(
-                        course,
-                        content,
-                        activity,
-                        endpoint
-                    ).get()
-
-                    let activityData = null
-
-                    if (response && response.activity) {
-                        activityData = response.activity
-                    } else if (
-                        response &&
-                        response.length > 0 &&
-                        response[0] &&
-                        response[0].activity
-                    ) {
-                        activityData = response[0].activity
-                    } else if (Array.isArray(response) && response.length > 0) {
-                        activityData = response[0]
-                    }
-
-                    if (
-                        activityData &&
-                        activityData.metadata &&
-                        activityData.metadata.config &&
-                        activityData.metadata.config.cards &&
-                        Array.isArray(activityData.metadata.config.cards)
-                    ) {
-                        // We pass the activity data and the replace flag to the parent component
-                        this.$emit(
-                            'click:generate',
-                            activityData,
-                            this.replaceExisting
-                        )
-                    } else {
-                        throw new Error(
-                            'Invalid response from flashcard generation'
-                        )
-                    }
-                } else if (this.questionType === 'bucket_game') {
-                    // BUCKET GAME GENERATION
-                    const activity = new Activity()
-
-                    const endpoint = `suggest/bucket_game${bloomsRequest}`
-
-                    response = await Activity.custom(
-                        course,
-                        content,
-                        activity,
-                        endpoint
-                    ).get()
-
-                    let activityData = null
-
-                    if (response && response.activity) {
-                        activityData = response.activity
-                    } else if (
-                        response &&
-                        response.length > 0 &&
-                        response[0] &&
-                        response[0].activity
-                    ) {
-                        activityData = response[0].activity
-                    } else if (Array.isArray(response) && response.length > 0) {
-                        activityData = response[0]
-                    }
-
-                    if (
-                        activityData &&
-                        activityData.metadata &&
-                        activityData.metadata.config &&
-                        activityData.metadata.config.bucket_titles &&
-                        activityData.metadata.config.bucket_answers
-                    ) {
-                        // For bucket games, always use replace mode
-                        this.$emit(
-                            'click:generate',
-                            activityData,
-                            true
-                        )
-                    } else {
-                        throw new Error(
-                            'Invalid response from bucket game generation'
-                        )
-                    }
-                } else if (this.questionType === 'matching_game') {
-                    // MATCHING GAME GENERATION
-                    const activity = new Activity()
-
-                    const endpoint = `suggest/matching_game${bloomsRequest}`;
-
-                    response = await Activity.custom(
-                        course,
-                        content,
-                        activity,
-                        endpoint
-                    ).get()
-
-                    let activityData = null
-
-                    if (response && response.activity) {
-                        activityData = response.activity
-                    } else if (
-                        response &&
-                        response.length > 0 &&
-                        response[0] &&
-                        response[0].activity
-                    ) {
-                        activityData = response[0].activity
-                    } else if (Array.isArray(response) && response.length > 0) {
-                        activityData = response[0]
-                    }
-
-                    if (activityData && activityData.metadata &&
-                        activityData.metadata.config &&
-                        activityData.metadata.config.answerObjects &&
-                        activityData.metadata.config.prompts
-                    ) {
-                        // We pass the activity data and the replace flag to the parent component
-                        this.$emit(
-                            'click:generate',
-                            activityData,
-                            this.replaceExisting
-                        )
-                    } else {
-                        throw new Error(
-                            'Invalid response from matching game generation'
-                        )
-                    }
-                } else if (this.questionType === 'sorting_game') {
-                    // SORTING GAME GENERATION
-                    const activity = new Activity()
-
-                    const endpoint = `suggest/sorting_game${bloomsRequest}`;
-
-                    response = await Activity.custom(
-                        course,
-                        content,
-                        activity,
-                        endpoint
-                    ).get()
-
-                    let activityData = null
-
-                    if (response && response.activity) {
-                        activityData = response.activity
-                    } else if (
-                        response &&
-                        response.length > 0 &&
-                        response[0] &&
-                        response[0].activity
-                    ) {
-                        activityData = response[0].activity
-                    } else if (Array.isArray(response) && response.length > 0) {
-                        activityData = response[0]
-                    } else if (response) {
-                        activityData = response
-                    }
-
-                    if (activityData && activityData.metadata &&
-                        activityData.metadata.config &&
-                        activityData.metadata.config.answer &&
-                        Array.isArray(activityData.metadata.config.answer)
-                    ) {
-                        // We pass the activity data and the replace flag to the parent component
-                        this.$emit(
-                            'click:generate',
-                            activityData,
-                            this.replaceExisting
-                        )
-                    } else {
-                        throw new Error(
-                            'Invalid response from sorting game generation'
-                        )
-                    }
-                } else if (this.questionType === 'scenario_game') {
-                    // SCENARIO GAME GENERATION
-                    const activity = new Activity()
-
-                    const endpoint = `suggest/scenario_game${bloomsRequest}`;
-
-                    response = await Activity.custom(
-                        course,
-                        content,
-                        activity,
-                        endpoint
-                    ).get()
-
-                    let activityData = null
-
-                    if (response && response.activity) {
-                        activityData = response.activity
-                    } else if (
-                        response &&
-                        response.length > 0 &&
-                        response[0] &&
-                        response[0].activity
-                    ) {
-                        activityData = response[0].activity
-                    } else if (Array.isArray(response) && response.length > 0) {
-                        activityData = response[0]
-                    } else if (response) {
-                        activityData = response
-                    }
-
-                    if (activityData && activityData.metadata &&
-                        activityData.metadata.config &&
-                        activityData.metadata.config.items &&
-                        Array.isArray(activityData.metadata.config.items)
-                    ) {
-                        // For scenario games, always replace existing content
-                        this.$emit(
-                            'click:generate',
-                            activityData,
-                            true
-                        )
-                    } else {
-                        throw new Error('activity.error.content_mismatch')
-                    }
-                } else if (this.questionType === 'word_jumble') {
-                    // WORD JUMBLE GENERATION
-                    const activity = new Activity()
-
-                    const endpoint = `suggest/word_jumble${bloomsRequest}`
-
-                    response = await Activity.custom(
-                        course,
-                        content,
-                        activity,
-                        endpoint
-                    ).get()
-
-                    let activityData = null
-
-                    if (response && response.activity) {
-                        activityData = response.activity
-                    } else if (
-                        response &&
-                        response.length > 0 &&
-                        response[0] &&
-                        response[0].activity
-                    ) {
-                        activityData = response[0].activity
-                    } else if (Array.isArray(response) && response.length > 0) {
-                        activityData = response[0]
-                    }
-
-                    if (
-                        activityData &&
-                        activityData.metadata &&
-                        activityData.metadata.config &&
-                        activityData.metadata.config.words &&
-                        Array.isArray(activityData.metadata.config.words)
-                    ) {
-                        // We pass the activity data and the replace flag to the parent component
-                        this.$emit(
-                            'click:generate',
-                            activityData,
-                            this.replaceExisting
-                        )
-                    } else {
-                        throw new Error(
-                            'Invalid response from word jumble generation'
-                        )
-                    }
-                } else {
-                    // ASSESSMENT QUESTION GENERATION
-                    const assessment = new Assessment({ id: this.block.id })
-                    const question = new AssessmentQuestion()
-
-                    response = await AssessmentQuestion.custom(
-                        course,
-                        content,
-                        assessment,
-                        question,
-                        `suggest/${this.questionType}${bloomsRequest}`
-                    ).get()
-
-                    if (response && response.length > 0) {
-                        const generatedQuestion = response[0]
-                        this.$emit('click:generate', generatedQuestion)
-                    } else {
-                        throw new Error(
-                            'Invalid response from question generation'
-                        )
-                    }
-                }
-            } catch (error) {
-                const errorMessage =
-                    error.response?.data?.error?.message ||
-                    error.message ||
-                    'assessment.error.technical'
-                const errorType = errorMessage.split('.').pop()
-                const basePath =
-                    'windward.core.components.content.blocks.generate_questions.error'
-
-                let errorText = ''
-
-                // Check for character limit error by structured data first
-                const errorSubtype = error.response?.data?.error?.details?.error_subtype
-                const errorDetails = error.response?.data?.error?.details
-                
-                if (errorSubtype === 'CHARACTER_LIMIT_EXCEEDED') {
-                    // Use structured data if available
-                    const field = errorDetails?.field || 'content'
-                    const limit = errorDetails?.limit
-                    const actual = errorDetails?.actual
-                    
-                    // Use parameterized message if we have the data
-                    if (limit && actual) {
-                        errorText = this.$t(`${basePath}.character_limit_detailed`, { field, limit, actual })
-                    } else {
-                        // Fallback to generic message
-                        errorText = this.$t(`${basePath}.character_limit`)
-                    }
-                }
-                // Keep backward compatibility - check for old message pattern
-                else if (errorDetails?.message === 'An error occurred while generating content. Try generating again.') {
-                    errorText = this.$t(`${basePath}.character_limit`)
-                } else if (
-                    // Check for content mismatch error specifically for bucket games
-                    (errorMessage === 'activity.error.content_mismatch' ||
-                        errorType === 'content_mismatch') &&
-                    this.questionType === 'bucket_game'
-                ) {
-                    errorText =
-                        this.$t(`${basePath}.content_mismatch_bucket_game`) +
-                        '\n\n' +
-                        this.$t(
-                            `${basePath}.content_mismatch_bucket_game_support`
-                        )
-                } else if (
-                    (errorMessage === 'activity.error.content_mismatch' ||
-                        errorType === 'content_mismatch') &&
-                    this.questionType === 'matching_game'
-                ) {
-                    errorText =
-                        this.$t(`${basePath}.content_mismatch_matching_game`) +
-                        '\n\n' +
-                        this.$t(
-                            `${basePath}.content_mismatch_matching_game_support`
-                        )
-                } else if (
-                    (errorMessage === 'activity.error.content_mismatch' ||
-                        errorType === 'content_mismatch') &&
-                    this.questionType === 'sorting_game'
-                ) {
-                    errorText =
-                        this.$t(`${basePath}.content_mismatch_sorting_game`) +
-                        '\n\n' +
-                        this.$t(
-                            `${basePath}.content_mismatch_sorting_game_support`
-                        )
-                } else if (
-                    (errorMessage === 'activity.error.content_mismatch' ||
-                        errorType === 'content_mismatch') &&
-                    this.questionType === 'scenario_game'
-                ) {
-                    errorText =
-                        this.$t(`${basePath}.content_mismatch_scenario_game`) +
-                        '\n\n' +
-                        this.$t(
-                            `${basePath}.content_mismatch_scenario_game_support`
-                        )
-                } else if (
-                    (errorMessage === 'activity.error.content_mismatch' ||
-                        errorType === 'content_mismatch') &&
-                    this.questionType === 'word_jumble'
-                ) {
-                    errorText =
-                        this.$t(`${basePath}.content_mismatch_word_jumble`) +
-                        '\n\n' +
-                        this.$t(
-                            `${basePath}.content_mismatch_word_jumble_support`
-                        )
-                } else if (errorType === 'insufficient_content' && error.response?.data?.error?.details) {
-                    // Handle dynamic Bloom's taxonomy insufficient content errors
-                    const details = error.response.data.error.details
-                    const bloomsLevel = details.blooms_level
-                    const minimumRequired = details.minimum_required
-                    
-                    if (bloomsLevel && bloomsLevel !== 'None') {
-                        // Message with Bloom's level
-                        errorText =
-                            this.$t(`${basePath}.insufficient_content_blooms`, { bloomsLevel }) +
-                            '\n\n' +
-                            this.$t(`${basePath}.insufficient_content_blooms_support`, { minimumRequired })
-                    } else if (minimumRequired) {
-                        // Message without Bloom's level but with word count
-                        errorText =
-                            this.$t(`${basePath}.insufficient_content_dynamic`) +
-                            '\n\n' +
-                            this.$t(`${basePath}.insufficient_content_dynamic_support`, { minimumRequired })
-                    } else {
-                        // Fallback to static translation
-                        errorText =
-                            this.$t(`${basePath}.${errorType}`) +
-                            '\n\n' +
-                            this.$t(`${basePath}.${errorType}_support`)
-                    }
-                } else {
-                    // Check if the error type is a valid i18n key
-                    const errorKey = `${basePath}.${errorType}`
-                    const supportKey = `${basePath}.${errorType}_support`
-                    
-                    // Try to get the translation, fall back to default error if not found
-                    const hasTranslation = this.$te(errorKey)
-                    
-                    if (hasTranslation) {
-                        errorText =
-                            this.$t(errorKey) +
-                            '\n\n' +
-                            this.$t(supportKey)
-                    } else {
-                        // Fall back to default error message
-                        errorText =
-                            this.$t(`${basePath}.default`) +
-                            '\n\n' +
-                            this.$t(`${basePath}.default_support`)
-                    }
-
-                    if (errorType === 'technical') {
-                        const errorCode =
-                            error.response?.data?.error?.details?.error_type ||
-                            'UNKNOWN'
-                        errorText = errorText.replace('[ERROR_CODE]', errorCode)
-                    }
-                }
-
-                this.$dialog.error(errorText, {
-                    duration: 5000,
-                    keepOnHover: true,
-                    singleton: true,
-                    type: 'error',
-                })
-            } finally {
-                this.isLoading = false
-            }
-        },
-    },
-}
-</script>
-
-<style scoped>
-.btn-selector {
-    width: 100%;
-}
-.container-generate-ai {
-    outline: 1px solid var(--v-secondary-base);
-    border-radius: 15px;
-}
-</style>
-