@salesforce/plugin-omnistudio-migration-tool 2.0.0-rc.2 → 2.0.0-rc.20

package/lib/migration/flexcard.js

@@ -8,6 +8,7 @@ const VlocityCard_1 = __importDefault(require("../mappings/VlocityCard"));
 const utils_1 = require("../utils");
 const net_1 = require("../utils/net");
 const base_1 = require("./base");
+const interfaces_1 = require("./interfaces");
 const logger_1 = require("../utils/logger");
 const base_2 = require("./base");
 const stringContants_1 = require("../utils/constants/stringContants");
@@ -21,7 +22,9 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
         return 'FlexCards';
     }
     getRecordName(record) {
-        return record['Name'];
+        return this.allVersions
+            ? `${record['Name']}_${record[this.namespacePrefix + CardMigrationTool.VERSION_PROP]}`
+            : record['Name'];
     }
     getMappings() {
         return [
@@ -55,14 +58,41 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
     // Perform Records Migration from VlocityCard__c to OmniUiCard
     async migrate() {
         // Get All the Active VlocityCard__c records
-        const cards = await this.getAllActiveCards();
-        logger_1.Logger.log(this.messages.getMessage('foundFlexCardsToMigrate', [cards.length]));
-        const progressBar = (0, base_2.createProgressBar)('Migrating', 'Flexcard');
+        const allCards = await this.getAllActiveCards();
+        logger_1.Logger.log(this.messages.getMessage('foundFlexCardsToMigrate', [allCards.length]));
+        // Filter out FlexCards with Angular OmniScript dependencies
+        const cards = [];
+        const skippedCards = new Map();
+        for (const card of allCards) {
+            if (this.hasAngularOmniScriptDependencies(card)) {
+                // Skip FlexCard with Angular dependencies
+                logger_1.Logger.logVerbose(`${this.messages.getMessage('skipFlexcardAngularOmniScriptDependencyWarning', [card['Name']])}`);
+                skippedCards.set(card['Id'], {
+                    referenceId: card['Id'],
+                    id: '',
+                    success: false,
+                    hasErrors: false,
+                    errors: [],
+                    warnings: [this.messages.getMessage('flexCardWithAngularOmniScriptWarning')],
+                    newName: '',
+                    skipped: true,
+                });
+            }
+            else {
+                cards.push(card);
+            }
+        }
+        logger_1.Logger.log(`${this.messages.getMessage('flexCardMigrationProcessingMessage', [cards.length, skippedCards.size])}`);
+        const progressBar = (0, base_2.createProgressBar)('Migrating', 'Flexcards');
         // Save the Vlocity Cards in OmniUiCard
         const cardUploadResponse = await this.uploadAllCards(cards, progressBar);
+        // Add skipped cards to the response
+        for (const [cardId, skippedResult] of skippedCards.entries()) {
+            cardUploadResponse.set(cardId, skippedResult);
+        }
         const records = new Map();
-        for (let i = 0; i < cards.length; i++) {
-            records.set(cards[i]['Id'], cards[i]);
+        for (let i = 0; i < allCards.length; i++) {
+            records.set(allCards[i]['Id'], allCards[i]);
         }
         return [
             {
@@ -77,19 +107,21 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             logger_1.Logger.log(this.messages.getMessage('startingFlexCardAssessment'));
             const flexCards = await this.getAllActiveCards();
             logger_1.Logger.log(this.messages.getMessage('foundFlexCardsToAssess', [flexCards.length]));
-            const flexCardsAssessmentInfos = this.processCardComponents(flexCards);
+            const flexCardsAssessmentInfos = await this.processCardComponents(flexCards);
+            this.prepareAssessmentStorageForFlexcards(flexCardsAssessmentInfos);
             return flexCardsAssessmentInfos;
         }
         catch (err) {
-            logger_1.Logger.error(this.messages.getMessage('errorDuringFlexCardAssessment'));
-            logger_1.Logger.error(JSON.stringify(err));
-            logger_1.Logger.error(err.stack);
+            if (err instanceof interfaces_1.InvalidEntityTypeError) {
+                throw err;
+            }
+            logger_1.Logger.error(this.messages.getMessage('errorDuringFlexCardAssessment'), err);
         }
     }
     async processCardComponents(flexCards) {
         const flexCardAssessmentInfos = [];
         let progressCounter = 0;
-        const progressBar = (0, base_2.createProgressBar)('Assessing', 'Flexcard');
+        const progressBar = (0, base_2.createProgressBar)('Assessing', 'Flexcards');
         progressBar.start(flexCards.length, progressCounter);
         const uniqueNames = new Set();
         // Now process each OmniScript and its elements
@@ -101,6 +133,7 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             catch (e) {
                 flexCardAssessmentInfos.push({
                     name: flexCard['Name'],
+                    oldName: flexCard['Name'],
                     id: flexCard['Id'],
                     dependenciesIP: [],
                     dependenciesDR: [],
@@ -109,11 +142,12 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                     dependenciesLWC: [],
                     dependenciesApexRemoteAction: [],
                     infos: [],
-                    warnings: [this.messages.getMessage('unexpectedError')],
+                    warnings: [],
+                    errors: [this.messages.getMessage('unexpectedError')],
+                    migrationStatus: 'Failed',
                 });
                 const error = e;
-                logger_1.Logger.error(JSON.stringify(error));
-                logger_1.Logger.error(error.stack);
+                logger_1.Logger.error('Error processing flex card', error);
             }
             progressBar.update(++progressCounter);
         }
@@ -123,8 +157,10 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
     async processFlexCard(flexCard, uniqueNames) {
         const flexCardName = flexCard['Name'];
         logger_1.Logger.info(this.messages.getMessage('processingFlexCard', [flexCardName]));
+        const version = flexCard[this.namespacePrefix + CardMigrationTool.VERSION_PROP];
         const flexCardAssessmentInfo = {
-            name: flexCardName,
+            name: this.allVersions ? `${flexCardName}_${version}` : flexCardName,
+            oldName: this.allVersions ? `${flexCardName}_${version}` : flexCardName,
             id: flexCard['Id'],
             dependenciesIP: [],
             dependenciesDR: [],
@@ -134,27 +170,38 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             dependenciesApexRemoteAction: [],
             infos: [],
             warnings: [],
+            errors: [],
+            migrationStatus: '',
         };
         // Check for name changes due to API naming requirements
         const originalName = flexCardName;
         const cleanedName = this.cleanName(originalName);
+        let assessmentStatus = 'Ready for migration';
+        flexCardAssessmentInfo.name = this.allVersions ? `${cleanedName}_${version}` : cleanedName;
         if (cleanedName !== originalName) {
             flexCardAssessmentInfo.warnings.push(this.messages.getMessage('cardNameChangeMessage', [originalName, cleanedName]));
+            assessmentStatus = 'Warnings';
         }
         // Check for duplicate names
         if (uniqueNames.has(cleanedName)) {
             flexCardAssessmentInfo.warnings.push(this.messages.getMessage('duplicateCardNameMessage', [cleanedName]));
+            assessmentStatus = 'Needs Manual Intervention';
         }
         uniqueNames.add(cleanedName);
-        this.addToAssessmentStorage(originalName, cleanedName);
         // Check for author name changes
         const originalAuthor = flexCard[this.namespacePrefix + 'Author__c'];
         if (originalAuthor) {
             const cleanedAuthor = this.cleanName(originalAuthor);
             if (cleanedAuthor !== originalAuthor) {
                 flexCardAssessmentInfo.warnings.push(this.messages.getMessage('authordNameChangeMessage', [originalAuthor, cleanedAuthor]));
+                assessmentStatus = 'Warnings';
             }
         }
+        flexCardAssessmentInfo.nameMapping = {
+            oldName: flexCardName,
+            newName: cleanedName,
+        };
+        flexCardAssessmentInfo.migrationStatus = assessmentStatus;
         this.updateDependencies(flexCard, flexCardAssessmentInfo);
         return flexCardAssessmentInfo;
     }
@@ -173,10 +220,12 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             const originalBundle = (_a = dataSource.value) === null || _a === void 0 ? void 0 : _a.bundle;
             if (originalBundle) {
                 const cleanedBundle = this.cleanName(originalBundle);
-                flexCardAssessmentInfo.dependenciesDR.push(cleanedBundle);
+                // Push original name instead of cleaned name for assessment consistency
+                flexCardAssessmentInfo.dependenciesDR.push(originalBundle);
                 // Add warning if DataRaptor name will change
                 if (originalBundle !== cleanedBundle) {
                     flexCardAssessmentInfo.warnings.push(this.messages.getMessage('dataRaptorNameChangeMessage', [originalBundle, cleanedBundle]));
+                    flexCardAssessmentInfo.migrationStatus = 'Warnings';
                 }
             }
         }
@@ -186,14 +235,17 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 const parts = originalIpMethod.split('_');
                 const cleanedParts = parts.map((p) => this.cleanName(p, true));
                 const cleanedIpMethod = cleanedParts.join('_');
-                flexCardAssessmentInfo.dependenciesIP.push(cleanedIpMethod);
+                // Push original name instead of cleaned name for assessment consistency
+                flexCardAssessmentInfo.dependenciesIP.push(originalIpMethod);
                 // Add warning if IP name will change
                 if (originalIpMethod !== cleanedIpMethod) {
                     flexCardAssessmentInfo.warnings.push(this.messages.getMessage('integrationProcedureNameChangeMessage', [originalIpMethod, cleanedIpMethod]));
+                    flexCardAssessmentInfo.migrationStatus = 'Warnings';
                 }
                 // Add warning for IP references with more than 2 parts (which potentially need manual updates)
                 if (parts.length > 2) {
                     flexCardAssessmentInfo.warnings.push(this.messages.getMessage('integrationProcedureManualUpdateMessage', [originalIpMethod]));
+                    flexCardAssessmentInfo.migrationStatus = 'Needs Manual Intervention';
                 }
             }
         }
@@ -206,7 +258,7 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 flexCardAssessmentInfo.dependenciesApexRemoteAction.push(`${remoteClass}.${remoteMethod}`);
             }
         }
-        // Check for OmniScript dependencies in the card's definition
+        // Check for Omniscript dependencies in the card's definition
         try {
             const definition = JSON.parse(flexCard[this.namespacePrefix + 'Definition__c'] || '{}');
             if (definition && definition.states) {
@@ -214,8 +266,15 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                     if (state.omniscripts && Array.isArray(state.omniscripts)) {
                         for (const os of state.omniscripts) {
                             if (os.type && os.subtype) {
-                                const osRef = `${os.type}_${os.subtype}_${os.language || 'English'}`;
-                                flexCardAssessmentInfo.dependenciesOS.push(osRef);
+                                const originalOsRef = `${os.type}_${os.subtype}_${os.language || 'English'}`;
+                                const cleanedOsRef = `${this.cleanName(os.type)}_${this.cleanName(os.subtype)}_${os.language || 'English'}`;
+                                // Push original name for consistency
+                                flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                                // Add warning if OmniScript name will change
+                                if (originalOsRef !== cleanedOsRef) {
+                                    flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                                    flexCardAssessmentInfo.migrationStatus = 'Warnings';
+                                }
                             }
                         }
                     }
@@ -231,7 +290,17 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 }
             }
             let childCards = this.readChildCardsFromDefinition(flexCard);
-            flexCardAssessmentInfo.dependenciesFC.push(...childCards);
+            // Add warnings for child card name changes
+            for (const childCardName of childCards) {
+                const cleanedChildCardName = this.cleanName(childCardName);
+                // Push original child card name for consistency
+                flexCardAssessmentInfo.dependenciesFC.push(childCardName);
+                // Add warning if child card name will change
+                if (childCardName !== cleanedChildCardName) {
+                    flexCardAssessmentInfo.warnings.push(this.messages.getMessage('cardNameChangeMessage', [childCardName, cleanedChildCardName]));
+                    flexCardAssessmentInfo.migrationStatus = 'Warnings';
+                }
+            }
         }
         catch (err) {
             // Log the error but continue processing
@@ -263,19 +332,46 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                             const originalName = omniType.Name;
                             const parts = originalName.split('/');
                             if (parts.length >= 2) {
-                                // Check for name changes in each part
+                                // Create both original and cleaned references for comparison
+                                const originalOsRef = parts.join('_');
                                 const cleanedParts = parts.map((p) => this.cleanName(p));
-                                const cleanedName = cleanedParts.join('_');
-                                flexCardAssessmentInfo.dependenciesOS.push(cleanedName);
-                                // Add warning if any part of the name will change
-                                for (let i = 0; i < parts.length; i++) {
-                                    if (parts[i] !== cleanedParts[i]) {
-                                        flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [parts[i], cleanedParts[i]]));
-                                    }
+                                const cleanedOsRef = cleanedParts.join('_');
+                                // Push original name for consistency
+                                flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                                // Add warning only if the overall name will change
+                                if (originalOsRef !== cleanedOsRef) {
+                                    flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                                    flexCardAssessmentInfo.migrationStatus = 'Warnings';
                                 }
                             }
                         }
                     }
+                    // MISSING PATTERN FIXED: Case 1b: Direct OmniScript reference without type check (for test compatibility)
+                    else if (action.stateAction.omniType && !action.stateAction.type) {
+                        const omniType = action.stateAction.omniType;
+                        // Handle both string omniType and object with Name property
+                        let omniTypeName;
+                        if (typeof omniType === 'string') {
+                            omniTypeName = omniType;
+                        }
+                        else if (omniType.Name && typeof omniType.Name === 'string') {
+                            omniTypeName = omniType.Name;
+                        }
+                        else {
+                            continue; // Skip if we can't extract the name
+                        }
+                        const parts = omniTypeName.split('/');
+                        if (parts.length >= 2) {
+                            const originalOsRef = parts.join('_');
+                            const cleanedParts = parts.map((p) => this.cleanName(p));
+                            const cleanedOsRef = cleanedParts.join('_');
+                            flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                            if (originalOsRef !== cleanedOsRef) {
+                                flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                                flexCardAssessmentInfo.migrationStatus = 'Warnings';
+                            }
+                        }
+                    }
                     // Case 2: Flyout OmniScript reference
                     else if (action.stateAction.type === 'Flyout' &&
                         action.stateAction.flyoutType === stringContants_1.Constants.OmniScriptPluralName &&
@@ -286,15 +382,16 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                             const originalName = osName;
                             const parts = originalName.split('/');
                             if (parts.length >= 2) {
-                                // Check for name changes in each part
+                                // Create both original and cleaned references for comparison
+                                const originalOsRef = parts.join('_');
                                 const cleanedParts = parts.map((p) => this.cleanName(p));
-                                const cleanedName = cleanedParts.join('_');
-                                flexCardAssessmentInfo.dependenciesOS.push(cleanedName);
-                                // Add warning if any part of the name will change
-                                for (let i = 0; i < parts.length; i++) {
-                                    if (parts[i] !== cleanedParts[i]) {
-                                        flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [parts[i], cleanedParts[i]]));
-                                    }
+                                const cleanedOsRef = cleanedParts.join('_');
+                                // Push original name for consistency
+                                flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                                // Add warning only if the overall name will change
+                                if (originalOsRef !== cleanedOsRef) {
+                                    flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                                    flexCardAssessmentInfo.migrationStatus = 'Warnings';
                                 }
                             }
                         }
@@ -320,10 +417,79 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 if (action.stateAction && action.stateAction.omniType) {
                     const omniType = action.stateAction.omniType;
                     if (omniType.Name && typeof omniType.Name === 'string') {
-                        const parts = omniType.Name.split('/');
+                        const originalName = omniType.Name;
+                        const parts = originalName.split('/');
                         if (parts.length >= 2) {
-                            const osRef = parts.join('_');
-                            flexCardAssessmentInfo.dependenciesOS.push(osRef);
+                            // Create both original and cleaned references for comparison
+                            const originalOsRef = parts.join('_');
+                            const cleanedParts = parts.map((p) => this.cleanName(p));
+                            const cleanedOsRef = cleanedParts.join('_');
+                            // Push original name for consistency
+                            flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                            // Add warning if OmniScript name will change
+                            if (originalOsRef !== cleanedOsRef) {
+                                flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                                flexCardAssessmentInfo.migrationStatus = 'Warnings';
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // MISSING PATTERN FIXED: Handle direct stateAction on component property
+        if (component.property && component.property.stateAction) {
+            // Case 1: Direct OmniScript reference on component property
+            if (component.property.stateAction.omniType) {
+                const omniType = component.property.stateAction.omniType;
+                if (omniType.Name && typeof omniType.Name === 'string') {
+                    const originalName = omniType.Name;
+                    const parts = originalName.split('/');
+                    if (parts.length >= 2) {
+                        const originalOsRef = parts.join('_');
+                        const cleanedParts = parts.map((p) => this.cleanName(p));
+                        const cleanedOsRef = cleanedParts.join('_');
+                        flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                        if (originalOsRef !== cleanedOsRef) {
+                            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                            flexCardAssessmentInfo.migrationStatus = 'Warnings';
+                        }
+                    }
+                }
+            }
+            // Case 2: Flyout OmniScript reference on component property
+            if (component.property.stateAction.type === 'Flyout' &&
+                component.property.stateAction.flyoutType === 'OmniScripts' &&
+                component.property.stateAction.osName) {
+                const osName = component.property.stateAction.osName;
+                if (typeof osName === 'string') {
+                    const parts = osName.split('/');
+                    if (parts.length >= 2) {
+                        const originalOsRef = parts.join('_');
+                        const cleanedParts = parts.map((p) => this.cleanName(p));
+                        const cleanedOsRef = cleanedParts.join('_');
+                        flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                        if (originalOsRef !== cleanedOsRef) {
+                            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                            flexCardAssessmentInfo.migrationStatus = 'Warnings';
+                        }
+                    }
+                }
+            }
+        }
+        // MISSING PATTERN FIXED: Handle omni-flyout elements (from tests)
+        if (component.element === 'omni-flyout' && component.property && component.property.flyoutOmniScript) {
+            if (component.property.flyoutOmniScript.osName) {
+                const osName = component.property.flyoutOmniScript.osName;
+                if (typeof osName === 'string') {
+                    const parts = osName.split('/');
+                    if (parts.length >= 2) {
+                        const originalOsRef = parts.join('_');
+                        const cleanedParts = parts.map((p) => this.cleanName(p));
+                        const cleanedOsRef = cleanedParts.join('_');
+                        flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+                        if (originalOsRef !== cleanedOsRef) {
+                            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+                            flexCardAssessmentInfo.migrationStatus = 'Warnings';
                         }
                     }
                 }
@@ -346,11 +512,21 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 { field: 'Name', direction: utils_1.SortDirection.ASC },
                 { field: this.namespacePrefix + 'Version__c', direction: utils_1.SortDirection.ASC },
             ];
-            return await utils_1.QueryTools.queryWithFilterAndSort(this.connection, this.namespace, CardMigrationTool.VLOCITYCARD_NAME, this.getCardFields(), filters, sortFields);
+            return await utils_1.QueryTools.queryWithFilterAndSort(this.connection, this.namespace, CardMigrationTool.VLOCITYCARD_NAME, this.getCardFields(), filters, sortFields).catch((err) => {
+                if (err.errorCode === 'INVALID_TYPE') {
+                    throw new interfaces_1.InvalidEntityTypeError(`${CardMigrationTool.VLOCITYCARD_NAME} type is not found under this namespace`);
+                }
+                throw err;
+            });
         }
         else {
             filters.set(this.namespacePrefix + 'Active__c', true);
-            return await utils_1.QueryTools.queryWithFilter(this.connection, this.namespace, CardMigrationTool.VLOCITYCARD_NAME, this.getCardFields(), filters);
+            return await utils_1.QueryTools.queryWithFilter(this.connection, this.namespace, CardMigrationTool.VLOCITYCARD_NAME, this.getCardFields(), filters).catch((err) => {
+                if (err.errorCode === 'INVALID_TYPE') {
+                    throw new interfaces_1.InvalidEntityTypeError(`${CardMigrationTool.VLOCITYCARD_NAME} type is not found under this namespace`);
+                }
+                throw err;
+            });
         }
     }
     // Upload All the VlocityCard__c records to OmniUiCard
@@ -399,13 +575,13 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 transformedCardName = transformedCard['Name'];
             }
             const transformedCardAuthorName = transformedCard['AuthorName'];
-            if (uniqueNames.has(transformedCardName)) {
+            if (uniqueNames.has(transformedCard['Name'])) {
                 this.setRecordErrors(card, this.messages.getMessage('duplicatedCardName'));
                 originalRecords.set(recordId, card);
                 return;
             }
             // Save the name for duplicated names check
-            uniqueNames.add(transformedCardName);
+            uniqueNames.add(transformedCard['Name']);
             // Create a map of the original records
             originalRecords.set(recordId, card);
             // Create card
@@ -422,7 +598,7 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                     uploadResult.warnings.unshift(this.messages.getMessage('cardAuthorNameChangeMessage', [transformedCardAuthorName]));
                 }
                 uploadResult.newName = transformedCardName;
-                if (transformedCardName !== card['Name']) {
+                if (transformedCard['Name'] !== card['Name']) {
                     uploadResult.warnings.unshift(this.messages.getMessage('cardNameChangeMessage', [transformedCardName]));
                 }
                 if (uploadResult.id && invalidIpNames.size > 0) {
@@ -454,42 +630,76 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             });
         }
     }
-    addToAssessmentStorage(originalName, cleanedName) {
+    prepareAssessmentStorageForFlexcards(flexcardAssessmentInfos) {
         let storage = storageUtil_1.StorageUtil.getOmnistudioAssessmentStorage();
-        if (storage.fcStorage.has(originalName)) {
-            storage.fcStorage.get(originalName).isDuplicate = true;
-        }
-        else {
-            storage.fcStorage.set(originalName, {
-                name: cleanedName,
-                isDuplicate: false,
-            });
+        for (let flexCardAssessmentInfo of flexcardAssessmentInfos) {
+            try {
+                if (flexCardAssessmentInfo === undefined ||
+                    flexCardAssessmentInfo === null ||
+                    flexCardAssessmentInfo.nameMapping === undefined ||
+                    flexCardAssessmentInfo.nameMapping === null) {
+                    logger_1.Logger.error(this.messages.getMessage('missingInfo'));
+                    return;
+                }
+                let value = {
+                    name: flexCardAssessmentInfo.nameMapping.newName,
+                    isDuplicate: false,
+                };
+                if (flexCardAssessmentInfo.errors && flexCardAssessmentInfo.errors.length > 0) {
+                    value.error = flexCardAssessmentInfo.errors;
+                    value.migrationSuccess = false;
+                }
+                else {
+                    value.migrationSuccess = true;
+                }
+                let finalKey = `${flexCardAssessmentInfo.nameMapping.oldName}`;
+                finalKey = finalKey.toLowerCase();
+                if (storage.fcStorage.has(finalKey)) {
+                    // Key already exists - handle accordingly
+                    logger_1.Logger.logVerbose(this.messages.getMessage('keyAlreadyInStorage', [finalKey]));
+                    value.isDuplicate = true;
+                    storage.fcStorage.set(finalKey, value);
+                }
+                else {
+                    // Key doesn't exist - safe to set
+                    storage.fcStorage.set(finalKey, value);
+                }
+            }
+            catch (error) {
+                logger_1.Logger.logVerbose(this.messages.getMessage('errorWhileProcessingFlexcardStorage'));
+                logger_1.Logger.error(error);
+            }
         }
+        storageUtil_1.StorageUtil.printAssessmentStorage();
     }
     prepareStorageForFlexcards(cardsUploadInfo, originalRecords) {
-        logger_1.Logger.logVerbose('Started preparing storage for flexcards');
+        logger_1.Logger.logVerbose(this.messages.getMessage('flexcardStorageProcessingStarted'));
         let storage = storageUtil_1.StorageUtil.getOmnistudioMigrationStorage();
         for (let key of Array.from(originalRecords.keys())) {
             try {
                 let oldrecord = originalRecords.get(key);
                 let newrecord = cardsUploadInfo.get(key);
-                logger_1.Logger.logVerbose('Oldrecord - ' + JSON.stringify(oldrecord));
-                logger_1.Logger.logVerbose('Newrecord - ' + JSON.stringify(newrecord));
                 let value = {
-                    name: newrecord['newName'],
+                    name: newrecord === null || newrecord === void 0 ? void 0 : newrecord.newName,
                     isDuplicate: false,
                 };
-                if (newrecord.hasErrors) {
-                    value.error = newrecord.errors;
-                    value.migrationSuccess = false;
+                if (newrecord === undefined) {
+                    value.error = ['Migration Failed'];
                 }
                 else {
-                    value.migrationSuccess = true;
+                    if (newrecord.hasErrors) {
+                        value.error = newrecord.errors;
+                        value.migrationSuccess = false;
+                    }
+                    else {
+                        value.migrationSuccess = true;
+                    }
                 }
                 let finalKey = `${oldrecord['Name']}`;
+                finalKey = finalKey.toLowerCase();
                 if (storage.fcStorage.has(finalKey)) {
                     // Key already exists - handle accordingly
-                    logger_1.Logger.logVerbose(`Key ${finalKey} already exists in flexcard storage`);
+                    logger_1.Logger.logVerbose(this.messages.getMessage('keyAlreadyInStorage', [finalKey]));
                     value.isDuplicate = true;
                     storage.fcStorage.set(finalKey, value);
                 }
@@ -499,7 +709,7 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 }
             }
             catch (error) {
-                logger_1.Logger.logVerbose('Error occurred while processing key for flexcard storage');
+                logger_1.Logger.logVerbose(this.messages.getMessage('errorWhileProcessingFlexcardStorage'));
                 logger_1.Logger.error(error);
             }
             storageUtil_1.StorageUtil.printMigrationStorage();
@@ -579,77 +789,435 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             }
             mappedObject[VlocityCard_1.default.Datasource__c] = JSON.stringify(datasource);
         }
-        // Update the propertyset datasource
+        // Update all dependencies comprehensively
+        this.updateAllDependenciesWithRegistry(mappedObject, invalidIpNames);
+        mappedObject['attributes'] = {
+            type: CardMigrationTool.OMNIUICARD_NAME,
+            referenceId: cardRecord['Id'],
+        };
+        return mappedObject;
+    }
+    /**
+     * Comprehensive dependency update using NameMappingRegistry - mirrors assessment logic
+     */
+    updateAllDependenciesWithRegistry(mappedObject, invalidIpNames) {
+        // 1. Handle propertySet (Definition) datasource
         const propertySet = JSON.parse(mappedObject[VlocityCard_1.default.Definition__c] || '{}');
         if (propertySet) {
-            if (propertySet.dataSource) {
-                const type = propertySet.dataSource.type;
-                if (type === 'DataRaptor') {
-                    propertySet.dataSource.value.bundle = this.cleanName(propertySet.dataSource.value.bundle);
-                }
-                else if (type === 'IntegrationProcedures') {
-                    const ipMethod = propertySet.dataSource.value.ipMethod || '';
-                    const parts = ipMethod.split('_');
-                    const newKey = parts.map((p) => this.cleanName(p, true)).join('_');
-                    propertySet.dataSource.value.ipMethod = newKey;
-                    if (parts.length > 2) {
-                        invalidIpNames.set('DataSource', ipMethod);
+            // Use NameMappingRegistry to update all dependency references first
+            const updatedPropertySet = this.nameRegistry.updateDependencyReferences(propertySet);
+            // Handle dataSource in propertySet
+            if (updatedPropertySet.dataSource) {
+                this.updateDataSourceWithRegistry(updatedPropertySet.dataSource, invalidIpNames, 'PropertySet');
+            }
+            // Handle states comprehensively
+            if (updatedPropertySet.states && Array.isArray(updatedPropertySet.states)) {
+                for (let i = 0; i < updatedPropertySet.states.length; i++) {
+                    const state = updatedPropertySet.states[i];
+                    // Handle child cards using registry
+                    if (state.childCards && Array.isArray(state.childCards)) {
+                        state.childCards = state.childCards.map((c) => {
+                            if (c && this.nameRegistry.hasFlexCardMapping(c)) {
+                                return this.nameRegistry.getFlexCardCleanedName(c);
+                            }
+                            else {
+                                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['FlexCard', c])}`);
+                                return this.cleanName(c);
+                            }
+                        });
+                    }
+                    // Handle omniscripts using registry
+                    if (state.omniscripts && Array.isArray(state.omniscripts)) {
+                        for (let osIdx = 0; osIdx < state.omniscripts.length; osIdx++) {
+                            this.updateOmniScriptReferenceWithRegistry(state.omniscripts[osIdx]);
+                        }
+                    }
+                    // Handle components comprehensively using registry
+                    if (state.components) {
+                        for (const componentKey in state.components) {
+                            if (state.components.hasOwnProperty(componentKey)) {
+                                const component = state.components[componentKey];
+                                this.updateComponentDependenciesWithRegistry(component);
+                            }
+                        }
                     }
                 }
             }
-            // update the states for child cards
-            for (let i = 0; i < (propertySet.states || []).length; i++) {
-                const state = propertySet.states[i];
-                // Clean childCards property
-                if (state.childCards && Array.isArray(state.childCards)) {
-                    state.childCards = state.childCards.map((c) => this.cleanName(c));
+            mappedObject[VlocityCard_1.default.Definition__c] = JSON.stringify(updatedPropertySet);
+        }
+    }
+    /**
+     * Update dataSource (DataRaptor, Integration Procedures, Apex Remote) using registry
+     */
+    updateDataSourceWithRegistry(dataSource, invalidIpNames, context) {
+        var _a, _b;
+        const type = dataSource.type;
+        if (type === stringContants_1.Constants.DataRaptorComponentName || type === 'DataRaptor') {
+            // Handle DataRaptor using registry
+            const originalBundle = ((_a = dataSource.value) === null || _a === void 0 ? void 0 : _a.bundle) || '';
+            if (originalBundle && this.nameRegistry.hasDataMapperMapping(originalBundle)) {
+                dataSource.value.bundle = this.nameRegistry.getDataMapperCleanedName(originalBundle);
+            }
+            else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', originalBundle])}`);
+                dataSource.value.bundle = this.cleanName(originalBundle);
+            }
+        }
+        else if (type === stringContants_1.Constants.IntegrationProcedurePluralName || type === 'IntegrationProcedures') {
+            // Handle Integration Procedures using registry
+            const ipMethod = ((_b = dataSource.value) === null || _b === void 0 ? void 0 : _b.ipMethod) || '';
+            const hasRegistryMapping = this.nameRegistry.hasIntegrationProcedureMapping(ipMethod);
+            if (hasRegistryMapping) {
+                const cleanedIpName = this.nameRegistry.getIntegrationProcedureCleanedName(ipMethod);
+                dataSource.value.ipMethod = cleanedIpName;
+            }
+            else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['IntegrationProcedure', ipMethod])}`);
+                const parts = ipMethod.split('_');
+                const newKey = parts.map((p) => this.cleanName(p, true)).join('_');
+                dataSource.value.ipMethod = newKey;
+                if (parts.length > 2) {
+                    invalidIpNames.set(context, ipMethod);
                 }
-                // Fix the "components" for child cards
-                for (let componentKey in state.components) {
-                    if (state.components.hasOwnProperty(componentKey)) {
-                        const component = state.components[componentKey];
-                        if (component.children && Array.isArray(component.children)) {
-                            this.fixChildren(component.children);
-                        }
+            }
+        }
+    }
+    /**
+     * Update OmniScript reference using registry
+     */
+    updateOmniScriptReferenceWithRegistry(omniscriptRef) {
+        const originalType = omniscriptRef.type;
+        const originalSubtype = omniscriptRef.subtype;
+        const language = omniscriptRef.language || 'English';
+        // Construct full OmniScript name to check registry
+        const fullOmniScriptName = `${originalType}_${originalSubtype}_${language}`;
+        if (this.nameRegistry.hasOmniScriptMapping(fullOmniScriptName)) {
+            // Registry has mapping for this OmniScript - extract cleaned parts
+            const cleanedFullName = this.nameRegistry.getCleanedName(fullOmniScriptName, 'OmniScript');
+            const parts = cleanedFullName.split('_');
+            if (parts.length >= 2) {
+                omniscriptRef.type = parts[0];
+                omniscriptRef.subtype = parts[1];
+                // Language doesn't typically change, but update if provided
+                if (parts.length >= 3) {
+                    omniscriptRef.language = parts[2];
+                }
+            }
+        }
+        else {
+            // No registry mapping - use original fallback approach
+            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['OmniScript', fullOmniScriptName])}`);
+            omniscriptRef.type = this.cleanName(originalType);
+            omniscriptRef.subtype = this.cleanName(originalSubtype);
+        }
+    }
+    /**
+     * Update component dependencies comprehensively
+     */
+    updateComponentDependenciesWithRegistry(component) {
+        // Handle action elements with actionList (like assessment)
+        if (component.element === 'action' && component.property && component.property.actionList) {
+            for (const action of component.property.actionList) {
+                if (action.stateAction) {
+                    // Case 1: Direct OmniScript reference
+                    if (action.stateAction.type === stringContants_1.Constants.OmniScriptComponentName && action.stateAction.omniType) {
+                        this.updateOmniTypeNameWithRegistry(action.stateAction.omniType);
+                    }
+                    // Case 2: Flyout OmniScript reference
+                    else if (action.stateAction.type === 'Flyout' &&
+                        action.stateAction.flyoutType === stringContants_1.Constants.OmniScriptPluralName &&
+                        action.stateAction.osName) {
+                        this.updateOsNameWithRegistry(action.stateAction, 'osName');
                     }
                 }
-                if (state.omniscripts && Array.isArray(state.omniscripts)) {
-                    for (let osIdx = 0; osIdx < state.omniscripts.length; osIdx++) {
-                        state.omniscripts[osIdx].type = this.cleanName(state.omniscripts[osIdx].type);
-                        state.omniscripts[osIdx].subtype = this.cleanName(state.omniscripts[osIdx].subtype);
+            }
+        }
+        // Handle Custom LWC components (no cleaning needed typically)
+        if (component.element === 'customLwc' && component.property) {
+            // Note: Custom LWC names typically don't need cleaning
+        }
+        // Handle standard component actions (like assessment)
+        if (component.actions && Array.isArray(component.actions)) {
+            for (const action of component.actions) {
+                if (action.stateAction && action.stateAction.omniType) {
+                    this.updateOmniTypeNameWithRegistry(action.stateAction.omniType);
+                }
+            }
+        }
+        // Handle direct stateAction on component property (existing logic)
+        if (component.property && component.property.stateAction) {
+            if (component.property.stateAction.omniType) {
+                this.updateOmniTypeNameWithRegistry(component.property.stateAction.omniType);
+            }
+            if (component.property.stateAction.type === 'Flyout' &&
+                component.property.stateAction.flyoutType === 'OmniScripts' &&
+                component.property.stateAction.osName) {
+                this.updateOsNameWithRegistry(component.property.stateAction, 'osName');
+            }
+        }
+        // Handle childCardPreview elements (from old fixChildren method)
+        if (component.element === 'childCardPreview' && component.property) {
+            if (component.property.cardName) {
+                const originalCardName = component.property.cardName;
+                if (this.nameRegistry.hasFlexCardMapping(originalCardName)) {
+                    component.property.cardName = this.nameRegistry.getFlexCardCleanedName(originalCardName);
+                }
+                else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['FlexCard', originalCardName])}`);
+                    component.property.cardName = this.cleanName(originalCardName);
+                }
+            }
+        }
+        // Handle omni-flyout elements (missing from migration logic)
+        if (component.element === 'omni-flyout' && component.property && component.property.flyoutOmniScript) {
+            if (component.property.flyoutOmniScript.osName) {
+                const osName = component.property.flyoutOmniScript.osName;
+                if (typeof osName === 'string') {
+                    const parts = osName.split('/');
+                    if (parts.length >= 2) {
+                        // Construct full OmniScript name: Type_SubType_Language
+                        const originalOsRef = parts.join('_');
+                        if (this.nameRegistry.hasOmniScriptMapping(originalOsRef)) {
+                            // Registry has mapping - extract cleaned parts and convert back to / format
+                            const cleanedFullName = this.nameRegistry.getCleanedName(originalOsRef, 'OmniScript');
+                            const cleanedParts = cleanedFullName.split('_');
+                            if (cleanedParts.length >= 2) {
+                                component.property.flyoutOmniScript.osName = cleanedParts.join('/');
+                            }
+                        }
+                        else {
+                            // No registry mapping - use original fallback approach
+                            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['OmniScript', originalOsRef])}`);
+                            component.property.flyoutOmniScript.osName = parts.map((p) => this.cleanName(p)).join('/');
+                        }
                     }
                 }
             }
-            mappedObject[VlocityCard_1.default.Definition__c] = JSON.stringify(propertySet);
         }
-        mappedObject['attributes'] = {
-            type: CardMigrationTool.OMNIUICARD_NAME,
-            referenceId: cardRecord['Id'],
-        };
-        return mappedObject;
+        // Check child components recursively
+        if (component.children && Array.isArray(component.children)) {
+            for (const child of component.children) {
+                this.updateComponentDependenciesWithRegistry(child);
+            }
+        }
     }
-    fixChildren(children) {
-        for (let j = 0; j < children.length; j++) {
-            const child = children[j];
-            if (child.element === 'childCardPreview') {
-                child.property.cardName = this.cleanName(child.property.cardName);
+    /**
+     * Update omniType.Name using registry (handles Type/SubType/Language format)
+     */
+    updateOmniTypeNameWithRegistry(omniType) {
+        const originalName = omniType.Name || '';
+        const parts = originalName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            if (this.nameRegistry.hasOmniScriptMapping(fullOmniScriptName)) {
+                // Registry has mapping - extract cleaned parts and convert back to / format
+                const cleanedFullName = this.nameRegistry.getCleanedName(fullOmniScriptName, 'OmniScript');
+                const cleanedParts = cleanedFullName.split('_');
+                if (cleanedParts.length >= 3) {
+                    omniType.Name = cleanedParts.join('/');
+                }
+            }
+            else {
+                // No registry mapping - use original fallback approach
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['OmniScript', fullOmniScriptName])}`);
+                omniType.Name = parts.map((p) => this.cleanName(p)).join('/');
             }
-            else if (child.element === 'action') {
-                if (child.property && child.property.stateAction && child.property.stateAction.omniType) {
-                    const parts = (child.property.stateAction.omniType.Name || '').split('/');
-                    child.property.stateAction.omniType.Name = parts.map((p) => this.cleanName(p)).join('/');
+        }
+        else {
+            // Fallback for unexpected format
+            omniType.Name = parts.map((p) => this.cleanName(p)).join('/');
+        }
+    }
+    /**
+     * Update osName using registry (handles Type/SubType/Language format)
+     */
+    updateOsNameWithRegistry(stateAction, fieldName) {
+        const originalOsName = stateAction[fieldName];
+        const parts = originalOsName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            if (this.nameRegistry.hasOmniScriptMapping(fullOmniScriptName)) {
+                // Registry has mapping - extract cleaned parts and convert back to / format
+                const cleanedFullName = this.nameRegistry.getCleanedName(fullOmniScriptName, 'OmniScript');
+                const cleanedParts = cleanedFullName.split('_');
+                if (cleanedParts.length >= 3) {
+                    stateAction[fieldName] = cleanedParts.join('/');
                 }
             }
-            if (child.children && Array.isArray(child.children)) {
-                this.fixChildren(child.children);
+            else {
+                // No registry mapping - use original fallback approach
+                logger_1.Logger.logVerbose(this.messages.getMessage('componentMappingNotFound', ['OmniScript', fullOmniScriptName]));
+                stateAction[fieldName] = parts.map((p) => this.cleanName(p)).join('/');
             }
         }
+        else {
+            // Fallback for unexpected format
+            stateAction[fieldName] = parts.map((p) => this.cleanName(p)).join('/');
+        }
     }
     getCardFields() {
         return Object.keys(VlocityCard_1.default);
     }
+    /**
+     * Check if a FlexCard has dependencies on Angular OmniScripts
+     */
+    hasAngularOmniScriptDependencies(card) {
+        try {
+            const definition = JSON.parse(card[this.namespacePrefix + 'Definition__c'] || '{}');
+            if (definition && definition.states) {
+                for (const state of definition.states) {
+                    // Check direct OmniScript references in states
+                    if (state.omniscripts && Array.isArray(state.omniscripts)) {
+                        for (const os of state.omniscripts) {
+                            if (os.type && os.subtype) {
+                                const osRef = `${os.type}_${os.subtype}_${os.language || 'English'}`;
+                                if (this.nameRegistry.isAngularOmniScript(osRef)) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    // Check OmniScript references in component actions
+                    if (state.components) {
+                        for (const componentKey in state.components) {
+                            if (state.components.hasOwnProperty(componentKey)) {
+                                const component = state.components[componentKey];
+                                if (this.componentHasAngularOmniScriptDependency(component)) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger_1.Logger.error(`Error checking Angular dependencies for card ${card['Name']}: ${err.message}`);
+        }
+        return false;
+    }
+    /**
+     * Recursively check if a component has Angular Omniscript dependencies
+     */
+    componentHasAngularOmniScriptDependency(component) {
+        // Pattern 1: Handle action elements with actionList (like migration logic)
+        if (component.element === 'action' && component.property && component.property.actionList) {
+            for (const action of component.property.actionList) {
+                if (action.stateAction) {
+                    // Case 1: Direct OmniScript reference with type check
+                    if (action.stateAction.type === stringContants_1.Constants.OmniScriptComponentName && action.stateAction.omniType) {
+                        if (this.checkOmniTypeForAngular(action.stateAction.omniType)) {
+                            return true;
+                        }
+                    }
+                    // Case 1b: Direct OmniScript reference without type check (for test compatibility)
+                    else if (action.stateAction.omniType && !action.stateAction.type) {
+                        if (this.checkOmniTypeForAngular(action.stateAction.omniType)) {
+                            return true;
+                        }
+                    }
+                    // Case 2: Flyout OmniScript reference
+                    else if (action.stateAction.type === 'Flyout' &&
+                        action.stateAction.flyoutType === stringContants_1.Constants.OmniScriptPluralName &&
+                        action.stateAction.osName) {
+                        if (this.checkOsNameForAngular(action.stateAction.osName)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        // Pattern 2: Handle standard component actions (like migration logic)
+        if (component.actions && Array.isArray(component.actions)) {
+            for (const action of component.actions) {
+                if (action.stateAction && action.stateAction.omniType) {
+                    if (this.checkOmniTypeForAngular(action.stateAction.omniType)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        // Pattern 3: Handle direct stateAction on component property (like migration logic)
+        if (component.property && component.property.stateAction) {
+            if (component.property.stateAction.omniType) {
+                if (this.checkOmniTypeForAngular(component.property.stateAction.omniType)) {
+                    return true;
+                }
+            }
+            if (component.property.stateAction.type === 'Flyout' &&
+                component.property.stateAction.flyoutType === 'OmniScripts' &&
+                component.property.stateAction.osName) {
+                if (this.checkOsNameForAngular(component.property.stateAction.osName)) {
+                    return true;
+                }
+            }
+        }
+        // Pattern 4: Handle omni-flyout elements (for test compatibility)
+        if (component.element === 'omni-flyout' && component.property && component.property.flyoutOmniScript) {
+            if (component.property.flyoutOmniScript.osName) {
+                if (this.checkOsNameForAngular(component.property.flyoutOmniScript.osName)) {
+                    return true;
+                }
+            }
+        }
+        // Recursively check child components
+        if (component.children && Array.isArray(component.children)) {
+            for (const child of component.children) {
+                if (this.componentHasAngularOmniScriptDependency(child)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if an omniType references an Angular OmniScript
+     * Handles both string format and object with Name property
+     */
+    checkOmniTypeForAngular(omniType) {
+        if (!omniType) {
+            return false;
+        }
+        let omniTypeName;
+        // Handle both string omniType and object with Name property
+        if (typeof omniType === 'string') {
+            omniTypeName = omniType;
+        }
+        else if (omniType.Name && typeof omniType.Name === 'string') {
+            omniTypeName = omniType.Name;
+        }
+        else {
+            return false;
+        }
+        const parts = omniTypeName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            return this.nameRegistry.isAngularOmniScript(fullOmniScriptName);
+        }
+        return false;
+    }
+    /**
+     * Check if an osName string references an Angular OmniScript
+     * Handles Type/SubType/Language format in string
+     */
+    checkOsNameForAngular(osName) {
+        if (!osName || typeof osName !== 'string') {
+            return false;
+        }
+        const parts = osName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            return this.nameRegistry.isAngularOmniScript(fullOmniScriptName);
+        }
+        return false;
+    }
 }
 exports.CardMigrationTool = CardMigrationTool;
 CardMigrationTool.VLOCITYCARD_NAME = 'VlocityCard__c';
 CardMigrationTool.OMNIUICARD_NAME = 'OmniUiCard';
+CardMigrationTool.VERSION_PROP = 'Version__c';
 //# sourceMappingURL=flexcard.js.map