tm-extractor 0.0.1

package/dist/index.js

@@ -0,0 +1,1475 @@
+import * as pdfjs from 'pdfjs-dist';
+
+/**
+ * TMA format configurations for different PDF page counts
+ */
+const TMA_FORMATS = {
+    "49": {
+        pages: [9, 11, 13],
+        scmPage: 12,
+        format: "49-page",
+    },
+    "54": {
+        pages: [11, 13, 15],
+        scmPage: 14,
+        format: "54-page",
+    },
+    "46": {
+        pages: [12, 14, 16],
+        scmPage: 15,
+        format: "46-page",
+    },
+    "6": {
+        pages: [2, 4, 6],
+        scmPage: 5,
+        format: "6-page",
+    },
+    "22": {
+        pages: [2, 4, 6],
+        scmPage: 5,
+        format: "22-page",
+    },
+};
+/**
+ * Talent extraction regex patterns for different formats
+ */
+const TALENT_REGEX_PATTERNS = {
+    // format49: /([A-Z-]+\.?)\s+(\d+)\./g,
+    // default: /^([1-9]|[12][0-9]|3[0-4])\s+([A-Z-]+)/gm,
+    // pdfParse: /([1-9]|[12][0-9]|3[0-4])([A-Z]+)/g
+    format49: /([A-Z-]+\.?)\s+(\d+)\./g,
+    default: /(\d+)\s+([A-Z-]+)/g,
+    pdfParse: /(\d+)([A-Z]+)/g,
+};
+/**
+ * Strength extraction regex patterns for different formats
+ */
+const STRENGTH_REGEX_PATTERNS = {
+    format49: /([A-Z]+)\s+(\d+)(?:\s+|$)/g,
+    default: /\d+\.\s*([\w-]+)/g,
+};
+/**
+ * Personal branding extraction regex patterns for different formats
+ */
+const PERSONAL_BRANDING_REGEX_PATTERNS = {
+    format49: /(QUALITY\s+CONTROLLER|[A-Z]{3,})\s*[‐-]?\s*(-?\d+(?:\.\d+)?)/g,
+    default: /([A-Z]+(?:\s+[A-Z]+)*)\s+Anda/g,
+};
+/**
+ * Valid talent number range (1-34)
+ */
+const TALENT_RANGE = { min: 1, max: 34 };
+/**
+ * Maximum number of personal branding items to extract
+ */
+const PERSONAL_BRANDING_LIMIT = 5;
+
+/**
+ * Detects TMA format based on page count
+ */
+function detectTmaFormat(pageCount) {
+    // Handle invalid page counts
+    if (!pageCount || typeof pageCount !== 'number' || pageCount <= 0) {
+        return 'unknown';
+    }
+    const formatKey = pageCount.toString();
+    return TMA_FORMATS[formatKey]?.format || 'unknown';
+}
+/**
+ * Gets all supported page counts
+ */
+function getSupportedPageCounts() {
+    return Object.keys(TMA_FORMATS).map(key => parseInt(key));
+}
+/**
+ * Gets format information for a given page count
+ */
+function getFormatInfo(pageCount) {
+    const formatKey = pageCount.toString();
+    return TMA_FORMATS[formatKey] || null;
+}
+/**
+ * Validates if a page count is supported and returns format details
+ */
+function validateAndGetFormat(pageCount) {
+    if (pageCount === 5) {
+        return {
+            isValid: false,
+            format: 'unknown',
+            error: 'Page count 5 is explicitly not supported'
+        };
+    }
+    const formatInfo = getFormatInfo(pageCount);
+    if (!formatInfo) {
+        return {
+            isValid: false,
+            format: 'unknown',
+            error: `Unsupported page count: ${pageCount}. Supported formats: ${getSupportedPageCounts().join(', ')}`
+        };
+    }
+    return {
+        isValid: true,
+        format: formatInfo.format,
+        pages: formatInfo.pages,
+        scmPage: formatInfo.scmPage
+    };
+}
+
+/**
+ * Custom error class for TMA extraction operations
+ */
+class TmaExtractionError extends Error {
+    constructor(message, code, originalError) {
+        super(message);
+        this.code = code;
+        this.originalError = originalError;
+        this.name = 'TmaExtractionError';
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, TmaExtractionError);
+        }
+    }
+}
+/**
+ * Error codes used throughout the package
+ */
+const ERROR_CODES_BASE = {
+    // File validation errors
+    INVALID_FILE_TYPE: 'INVALID_FILE_TYPE',
+    NO_FILES: 'NO_FILES',
+    TOO_MANY_FILES: 'TOO_MANY_FILES',
+    FILE_TOO_LARGE: 'FILE_TOO_LARGE',
+    // PDF processing errors
+    PDF_PROCESSING_ERROR: 'PDF_PROCESSING_ERROR',
+    PAGE_TEXT_EXTRACTION_ERROR: 'PAGE_TEXT_EXTRACTION_ERROR',
+    INVALID_PAGE_NUMBERS: 'INVALID_PAGE_NUMBERS',
+    INVALID_PAGE_NUMBER: 'INVALID_PAGE_NUMBER',
+    // Format errors
+    UNSUPPORTED_FORMAT: 'UNSUPPORTED_FORMAT',
+    // Extraction errors
+    TALENT_EXTRACTION_ERROR: 'TALENT_EXTRACTION_ERROR',
+    STRENGTH_EXTRACTION_ERROR: 'STRENGTH_EXTRACTION_ERROR',
+    TYPOLOGY_EXTRACTION_ERROR: 'TYPOLOGY_EXTRACTION_ERROR',
+    BRANDING_EXTRACTION_ERROR: 'BRANDING_EXTRACTION_ERROR',
+    // Validation errors
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    NO_VALID_RESULTS: 'NO_VALID_RESULTS',
+    INSUFFICIENT_VALID_FILES: 'INSUFFICIENT_VALID_FILES',
+    // Configuration errors
+    WORKER_CONFIGURATION_ERROR: 'WORKER_CONFIGURATION_ERROR',
+    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+    // Server side error
+    SERVER_SIDE_ERROR: 'SERVER_SIDE_ERROR'
+};
+const ERROR_CODES = Object.freeze(ERROR_CODES_BASE);
+/**
+ * Creates a TmaExtractionError with predefined error code
+ */
+function createError(code, message, originalError) {
+    return new TmaExtractionError(message, ERROR_CODES[code], originalError);
+}
+/**
+ * Checks if an error is a TmaExtractionError
+ */
+function isTmaExtractionError(error) {
+    return error instanceof TmaExtractionError;
+}
+/**
+ * Handles and wraps unknown errors in TmaExtractionError
+ */
+function wrapError(error, defaultCode = 'PDF_PROCESSING_ERROR', defaultMessage = 'An unexpected error occurred') {
+    if (isTmaExtractionError(error)) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return createError(defaultCode, error.message, error);
+    }
+    return createError(defaultCode, defaultMessage);
+}
+
+/**
+ * PDF Processing class that wraps PDF.js functionality for TMA extraction
+ */
+class PdfProcessor {
+    constructor(config) {
+        this.workerSrc = config?.workerSrc;
+        this.configurePdfWorker();
+    }
+    /**
+     * Configures PDF.js worker source
+     */
+    configurePdfWorker() {
+        if (this.workerSrc && this.workerSrc !== "auto") {
+            pdfjs.GlobalWorkerOptions.workerSrc = this.workerSrc;
+        }
+        else if (typeof window !== "undefined") {
+            // Browser environment - use default worker
+            pdfjs.GlobalWorkerOptions.workerSrc = new URL("pdfjs-dist/build/pdf.worker.min.mjs", import.meta.url).toString();
+        }
+    }
+    /**
+     * Gets the total number of pages in a PDF file
+     */
+    async getPageCount(file) {
+        try {
+            const arrayBuffer = await file.arrayBuffer();
+            const loadingTask = pdfjs.getDocument(arrayBuffer);
+            const pdfDoc = await loadingTask.promise;
+            return pdfDoc.numPages;
+        }
+        catch (error) {
+            throw new TmaExtractionError("Failed to get PDF page count", "PDF_PROCESSING_ERROR", error);
+        }
+    }
+    /**
+     * Detects TMA format based on page count
+     */
+    detectFormat(pageCount) {
+        return detectTmaFormat(pageCount);
+    }
+    /**
+     * Gets page numbers for extraction based on page count
+     */
+    getPageNumbers(pageCount) {
+        const formatKey = pageCount.toString();
+        const format = TMA_FORMATS[formatKey];
+        if (!format) {
+            throw new TmaExtractionError(`Unsupported TMA format: ${pageCount} pages`, "UNSUPPORTED_FORMAT");
+        }
+        return format.pages;
+    }
+    /**
+     * Gets SCM page number based on page count
+     */
+    getScmPageNumber(pageCount) {
+        const formatKey = pageCount.toString();
+        const format = TMA_FORMATS[formatKey];
+        if (!format) {
+            throw new TmaExtractionError(`Unsupported TMA format for SCM: ${pageCount} pages`, "UNSUPPORTED_FORMAT");
+        }
+        return format.scmPage;
+    }
+    /**
+     * Extracts text content from a single PDF page
+     */
+    async getPageText(page) {
+        try {
+            const content = await page.getTextContent();
+            return content.items.map((item) => item.str).join(" ");
+        }
+        catch (error) {
+            throw new TmaExtractionError("Failed to extract text from PDF page", "PAGE_TEXT_EXTRACTION_ERROR", error);
+        }
+    }
+    /**
+     * Extracts text content from specific PDF pages
+     */
+    async extractPageTexts(file, pageNumbers) {
+        try {
+            const arrayBuffer = await file.arrayBuffer();
+            const loadingTask = pdfjs.getDocument(arrayBuffer);
+            const pdfDoc = await loadingTask.promise;
+            // Validate page numbers
+            const maxPage = pdfDoc.numPages;
+            const invalidPages = pageNumbers.filter((num) => num > maxPage || num < 1);
+            if (invalidPages.length > 0) {
+                throw new TmaExtractionError(`Invalid page numbers: ${invalidPages.join(", ")} (PDF has ${maxPage} pages)`, "INVALID_PAGE_NUMBERS");
+            }
+            // Get specific pages
+            const pages = await Promise.all(pageNumbers.map((pageNum) => pdfDoc.getPage(pageNum)));
+            const [talentPage, strengthPage, typologyPage] = pages;
+            return {
+                talentOrder: await this.getPageText(talentPage),
+                strength: await this.getPageText(strengthPage),
+                typologyAndBranding: await this.getPageText(typologyPage),
+            };
+        }
+        catch (error) {
+            if (error instanceof TmaExtractionError) {
+                throw error;
+            }
+            throw new TmaExtractionError("Failed to extract page texts from PDF", "PDF_PROCESSING_ERROR", error);
+        }
+    }
+    /**
+     * Gets a specific PDF page for external processing (e.g., SCM)
+     */
+    async getPage(file, pageNumber) {
+        try {
+            const arrayBuffer = await file.arrayBuffer();
+            const loadingTask = pdfjs.getDocument(arrayBuffer);
+            const pdfDoc = await loadingTask.promise;
+            if (pageNumber > pdfDoc.numPages || pageNumber < 1) {
+                throw new TmaExtractionError(`Invalid page number: ${pageNumber} (PDF has ${pdfDoc.numPages} pages)`, "INVALID_PAGE_NUMBER");
+            }
+            return await pdfDoc.getPage(pageNumber);
+        }
+        catch (error) {
+            if (error instanceof TmaExtractionError) {
+                throw error;
+            }
+            throw new TmaExtractionError(`Failed to get PDF page ${pageNumber}`, "PDF_PROCESSING_ERROR", error);
+        }
+    }
+    /**
+     * Validates if a file is a valid PDF
+     */
+    validatePdfFile(file) {
+        if (!file) {
+            return { isValid: false, error: "No file provided" };
+        }
+        if (file.type !== "application/pdf") {
+            return { isValid: false, error: "File must be a PDF" };
+        }
+        if (file.size === 0) {
+            return { isValid: false, error: "File is empty" };
+        }
+        // Basic size check (max 50MB)
+        if (file.size > 50 * 1024 * 1024) {
+            return { isValid: false, error: "File size exceeds 50MB limit" };
+        }
+        return { isValid: true };
+    }
+}
+
+/**
+ * Data transformation class that implements filteredExtractedData logic
+ * Removes unnecessary fields and metadata from extracted TMA data
+ */
+class DataTransformer {
+    /**
+     * Removes the 'sign' field from talents array
+     */
+    static removeTalentSign(talents) {
+        return talents.map(({ number, tema }) => ({
+            number,
+            tema
+        }));
+    }
+    /**
+     * Removes SCM metadata while keeping activity data
+     * Filters out detectionConfidence and metadata according to filtered output spec
+     */
+    static removeScmMetadata(scmData) {
+        if (!scmData) {
+            return scmData;
+        }
+        if (!scmData.activities) {
+            return {
+                activities: []
+            };
+        }
+        return {
+            activities: scmData.activities.map((activity) => {
+                const { detectionConfidence, ...cleanedActivity } = activity;
+                return cleanedActivity;
+            })
+            // Note: metadata field is completely removed
+        };
+    }
+    /**
+     * Cleans talent data by removing unnecessary fields
+     * Implements the filteredExtractedData logic from TMARawExtractor.vue
+     */
+    static cleanTalentData(rawData) {
+        const cleanedData = {
+            name: rawData.name,
+            talents: this.removeTalentSign(rawData.talents),
+            strength: rawData.strength,
+            typology: rawData.typology,
+            personalbranding: rawData.personalbranding
+        };
+        // Only include SCM if it exists and clean it
+        if (rawData.scm) {
+            cleanedData.scm = this.removeScmMetadata(rawData.scm);
+        }
+        return cleanedData;
+    }
+    /**
+     * Transforms single person result to match filtered output format
+     */
+    static transformSinglePersonResult(result) {
+        // Remove top14Talents, top7Talents, low14Talents from person object
+        const { top14Talents, top7Talents, low14Talents, ...cleanedPerson } = result.person;
+        return {
+            person: this.cleanTalentData(cleanedPerson)
+        };
+    }
+    /**
+     * Validates cleaned data structure
+     */
+    static validateCleanedData(data) {
+        const errors = [];
+        // Check required fields
+        if (!data.name || data.name.trim().length === 0) {
+            errors.push('Person name is required');
+        }
+        if (!data.talents || data.talents.length === 0) {
+            errors.push('Talents array is required and cannot be empty');
+        }
+        if (!data.strength || data.strength.length === 0) {
+            errors.push('Strength array is required and cannot be empty');
+        }
+        if (!data.typology || data.typology.length === 0) {
+            errors.push('Typology array is required and cannot be empty');
+        }
+        if (!data.personalbranding || data.personalbranding.length === 0) {
+            errors.push('Personal branding array is required and cannot be empty');
+        }
+        // Validate talent structure (should not have 'sign' field)
+        if (data.talents) {
+            const talentsWithSign = data.talents.filter((talent) => 'sign' in talent);
+            if (talentsWithSign.length > 0) {
+                errors.push(`Found ${talentsWithSign.length} talents with 'sign' field (should be removed)`);
+            }
+            // Check for required fields in talents
+            const invalidTalents = data.talents.filter(t => typeof t.number !== 'number' || !t.tema || t.tema.trim().length === 0);
+            if (invalidTalents.length > 0) {
+                errors.push(`Found ${invalidTalents.length} talents with missing number or tema`);
+            }
+        }
+        // Validate SCM structure if present
+        if (data.scm) {
+            if (data.scm.metadata) {
+                errors.push('SCM metadata should be removed from cleaned data');
+            }
+            if (data.scm.activities) {
+                const activitiesWithConfidence = data.scm.activities.filter((activity) => 'detectionConfidence' in activity);
+                if (activitiesWithConfidence.length > 0) {
+                    errors.push(`Found ${activitiesWithConfidence.length} SCM activities with detectionConfidence (should be removed)`);
+                }
+            }
+        }
+        return { isValid: errors.length === 0, errors };
+    }
+    /**
+     * Gets summary statistics of cleaned data
+     */
+    static getDataSummary(data) {
+        return {
+            totalTalents: data.talents?.length || 0,
+            totalStrengths: data.strength?.length || 0,
+            totalTypologies: data.typology?.length || 0,
+            totalPersonalBranding: data.personalbranding?.length || 0,
+            totalScmActivities: data.scm?.activities?.length || null,
+            hasScmData: !!data.scm
+        };
+    }
+}
+
+/**
+ * Validates talent number is within valid range (1-34)
+ */
+function isValidTalentNumber(number) {
+    return number >= TALENT_RANGE.min && number <= TALENT_RANGE.max;
+}
+/**
+ * Extracts talent order for 49-page format
+ */
+function extractTalentOrderFormat49(text) {
+    const matches = [...text.matchAll(TALENT_REGEX_PATTERNS.format49)];
+    return matches
+        .map((match) => ({
+        number: parseInt(match[2]),
+        tema: match[1].replace(/\.$/, ''),
+        sign: 'false'
+    }))
+        .filter((talent) => isValidTalentNumber(talent.number))
+        .sort((a, b) => a.number - b.number);
+}
+/**
+ * Extracts talent order for default formats (54, 46, 6 page)
+ */
+function extractTalentOrderDefault(text, isPdfParse = false) {
+    const pattern = isPdfParse ? TALENT_REGEX_PATTERNS.pdfParse : TALENT_REGEX_PATTERNS.default;
+    const matches = [...text.matchAll(pattern)];
+    const result = matches
+        .map((match) => ({
+        number: parseInt(match[1]),
+        tema: match[2],
+        sign: 'false'
+    }))
+        .filter((talent) => isValidTalentNumber(talent.number))
+        .sort((a, b) => a.number - b.number);
+    return result;
+}
+/**
+ * Extracts talent order from text based on TMA format
+ */
+function extractTalentOrder(text, isPdfParse = false, pageCount = 0) {
+    const format = detectTmaFormat(pageCount);
+    // Handle unknown format early to prevent extraction attempts
+    if (format === 'unknown') {
+        return [];
+    }
+    if (format === '49-page') {
+        return extractTalentOrderFormat49(text);
+    }
+    return extractTalentOrderDefault(text, isPdfParse);
+}
+/**
+ * Extracts name from talent order text based on format
+ */
+function extractName(text, pageCount) {
+    const format = detectTmaFormat(pageCount);
+    let pattern = /URUTAN BAKAT\s+([A-Z\s.']+?)(?=\d)/;
+    if (format === '54-page') {
+        pattern = /URUTAN BAKAT\s+([A-Z\s.''-]+?)(?=\n\d)/;
+    }
+    else if (format === '49-page') {
+        pattern = /URUTAN BAKAT\s+([A-Z\s.']+?)(?=\n[A-Z])/;
+    }
+    const nameMatch = text.match(pattern);
+    return nameMatch ? nameMatch[1]?.trim() : '';
+}
+
+/**
+ * Extracts strength data for 49-page format
+ */
+function extractStrengthFormat49(text) {
+    const strengthLines = text.match(STRENGTH_REGEX_PATTERNS.format49);
+    return (strengthLines?.map((line) => {
+        const [name, number] = line.trim().split(/\s+/);
+        return {
+            number: parseInt(number),
+            name: name.trim()
+        };
+    }) || []);
+}
+/**
+ * Extracts strength data for default formats (54, 46, 6 page)
+ */
+function extractStrengthDefault(text) {
+    const strengthLines = text.match(STRENGTH_REGEX_PATTERNS.default);
+    return (strengthLines?.map((line) => {
+        const [number, name] = line.split('.');
+        return {
+            number: parseInt(number),
+            name: name.trim()
+        };
+    }) || []);
+}
+/**
+ * Extracts strength data from text based on TMA format
+ */
+function extractStrength(text, pageCount = 0) {
+    const format = detectTmaFormat(pageCount);
+    if (format === '49-page') {
+        return extractStrengthFormat49(text);
+    }
+    return extractStrengthDefault(text);
+}
+
+/**
+ * Fixed mapping of all 30 typologies with their standardized categories
+ * This ensures consistent typology identification across all TMA formats
+ */
+const TYPOLOGY_DEFINITIONS = [
+    { id: 1, name: 'ARRANGER', category: 'HEADMAN' },
+    { id: 2, name: 'SELLER', category: 'HEADMAN' },
+    { id: 3, name: 'COMMANDER', category: 'HEADMAN' },
+    { id: 4, name: 'MEDIATOR', category: 'HEADMAN' },
+    { id: 5, name: 'SELECTOR', category: 'HEADMAN' },
+    { id: 6, name: 'AMBASADOR', category: 'NETWORKING' },
+    { id: 7, name: 'COMMUNICATOR', category: 'NETWORKING' },
+    { id: 8, name: 'EDUCATOR', category: 'NETWORKING' },
+    { id: 9, name: 'MOTIVATOR', category: 'NETWORKING' },
+    { id: 10, name: 'CARETAKER', category: 'SERVICING' },
+    { id: 11, name: 'SERVER', category: 'SERVICING' },
+    { id: 12, name: 'ANALYST', category: 'THINKING' },
+    { id: 13, name: 'TREASURER', category: 'THINKING' },
+    { id: 14, name: 'RESTORER', category: 'REASONING' },
+    { id: 15, name: 'EVALUATOR', category: 'REASONING' },
+    { id: 16, name: 'EXPLORER', category: 'REASONING' },
+    { id: 17, name: 'DESIGNER', category: 'GENERATING IDEA' },
+    { id: 18, name: 'CREATOR', category: 'GENERATING IDEA' },
+    { id: 19, name: 'SYNTHESIZER', category: 'GENERATING IDEA' },
+    { id: 20, name: 'MARKETER', category: 'GENERATING IDEA' },
+    { id: 21, name: 'STRATEGIST', category: 'GENERATING IDEA' },
+    { id: 22, name: 'VISIONARY', category: 'GENERATING IDEA' },
+    { id: 23, name: 'JOURNALIST', category: 'ELEMENTARY' },
+    { id: 24, name: 'INTERPRETER', category: 'ELEMENTARY' },
+    { id: 25, name: 'ADMINISTRATOR', category: 'ELEMENTARY' },
+    { id: 26, name: 'SAFEKEEPER', category: 'TECHNICAL' },
+    { id: 27, name: 'PRODUCER', category: 'TECHNICAL' },
+    { id: 28, name: 'QUALITY CONTROLLER', category: 'TECHNICAL' },
+    { id: 29, name: 'DISTRIBUTOR', category: 'TECHNICAL' },
+    { id: 30, name: 'OPERATOR', category: 'TECHNICAL' }
+];
+
+/**
+ * Creates a dash-separated label from typology name
+ */
+function createTypologyLabel(name) {
+    return name.toLowerCase().replace(/\s+/g, '-');
+}
+/**
+ * Extracts score for a specific typology from text
+ */
+function extractTypologyScore(text, typologyName) {
+    // Escape special characters for regex
+    const escapedName = typologyName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Create regex pattern to find typology name followed by score
+    const pattern = new RegExp(`${escapedName}\\s+(-?\\d+(?:\\.\\d+)?)`, 'i');
+    const match = text.match(pattern);
+    if (match && match[1]) {
+        const score = parseFloat(match[1]);
+        return isNaN(score) ? null : score;
+    }
+    return null;
+}
+/**
+ * Extracts all 30 typologies with their scores from text
+ */
+function extractTypology(text) {
+    const typologies = [];
+    // Loop through all 30 predefined typologies
+    for (const definition of TYPOLOGY_DEFINITIONS) {
+        const score = extractTypologyScore(text, definition.name);
+        // Only include typologies that have scores found in the text
+        if (score !== null) {
+            typologies.push({
+                id: definition.id,
+                name: definition.name,
+                label: createTypologyLabel(definition.name),
+                category: definition.category,
+                score: score
+            });
+        }
+    }
+    // Sort by id to maintain consistent order
+    return typologies.sort((a, b) => a.id - b.id);
+}
+
+/**
+ * Extracts personal branding for 49-page format
+ */
+function extractPersonalBrandingFormat49(text) {
+    const temp = [];
+    let match;
+    while ((match = PERSONAL_BRANDING_REGEX_PATTERNS.format49.exec(text)) !== null) {
+        const id = match[1].replace(/\s+/g, ' ').trim();
+        const score = parseFloat(match[2]);
+        if (id.length > 2 && !isNaN(score)) {
+            temp.push({ id, score });
+        }
+    }
+    // Keep unique entries with highest score
+    const uniqueMap = new Map();
+    temp.forEach(({ id, score }) => {
+        if (!uniqueMap.has(id) || uniqueMap.get(id) < score) {
+            uniqueMap.set(id, score);
+        }
+    });
+    // Sort positives and negatives separately
+    const arr = Array.from(uniqueMap.entries()).map(([id, score]) => ({ id, score }));
+    const positives = arr.filter((item) => item.score >= 0).sort((a, b) => b.score - a.score);
+    const negatives = arr.filter((item) => item.score < 0).sort((a, b) => a.score - b.score);
+    // Take top 5 from combined list
+    const top5 = [...positives, ...negatives].slice(0, PERSONAL_BRANDING_LIMIT);
+    return top5.map((item) => ({ id: item.id }));
+}
+/**
+ * Extracts personal branding for default formats
+ */
+function extractPersonalBrandingDefault(text) {
+    const personalBrandingValues = text.match(PERSONAL_BRANDING_REGEX_PATTERNS.default);
+    if (!personalBrandingValues)
+        return [];
+    return personalBrandingValues
+        .map((match) => match.replace(/\s+Anda$/, ''))
+        .map((value) => value.replace(/PERSONAL BRANDING\s+/, ''))
+        .filter((value) => value && value !== 'PERSONAL BRANDING')
+        .slice(0, PERSONAL_BRANDING_LIMIT)
+        .map((value) => ({ id: value.trim() }));
+}
+/**
+ * Extracts personal branding data based on TMA format
+ */
+function extractPersonalBranding(text, pageCount = 0) {
+    const format = detectTmaFormat(pageCount);
+    if (format === '49-page') {
+        return extractPersonalBrandingFormat49(text);
+    }
+    return extractPersonalBrandingDefault(text);
+}
+
+/**
+ * SCM (Strength Cluster Map) Activities Definitions
+ * Pre-defined list of all 114 activities with their typology and cluster information
+ * Framework-independent constants for tma-extractor package
+ */
+const SCM_ACTIVITIES_DEFINITIONS = [
+    // TOP AREA (24 activities, dari kiri ke kanan)
+    { id: 'RELATING', typology: 'AMBASSADOR', cluster: 'NETWORKING', hasPsp: true, area: 'top', position: 0 },
+    { id: 'REPRESENTING', typology: 'AMBASSADOR', cluster: 'NETWORKING', hasPsp: true, area: 'top', position: 1 },
+    { id: 'COMMUNICATING', typology: 'COMMUNICATOR', cluster: 'NETWORKING', hasPsp: true, area: 'top', position: 2 },
+    { id: 'CORRESPONDING', typology: 'COMMUNICATOR', cluster: 'NETWORKING', hasPsp: true, area: 'top', position: 3 },
+    { id: 'ENTERTAINING', typology: 'COMMUNICATOR', cluster: 'NETWORKING', hasPsp: true, area: 'top', position: 4 },
+    { id: 'PRESENTING', typology: 'COMMUNICATOR', cluster: 'NETWORKING', hasPsp: true, area: 'top', position: 5 },
+    { id: 'COOPERATING', typology: 'ARRANGER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 6 },
+    { id: 'COORDINATING', typology: 'ARRANGER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 7 },
+    { id: 'DISPATCHING', typology: 'ARRANGER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 8 },
+    { id: 'MEDIATING', typology: 'MEDIATOR', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 9 },
+    { id: 'NEGOTIATING', typology: 'MEDIATOR', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 10 },
+    { id: 'PURCHASING', typology: 'MEDIATOR', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 11 },
+    { id: 'COLLECTING', typology: 'COMMANDER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 12 },
+    { id: 'CONTROLLING', typology: 'COMMANDER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 13 },
+    { id: 'INTERROGATING', typology: 'COMMANDER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 14 },
+    { id: 'BROKERING', typology: 'SELLER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 15 },
+    { id: 'INFLUENCING', typology: 'SELLER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 16 },
+    { id: 'SELLING', typology: 'SELLER', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 17 },
+    { id: 'RECRUITING', typology: 'SELECTOR', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 18 },
+    { id: 'INTERVIEWING', typology: 'SELECTOR', cluster: 'HEADMAN', hasPsp: true, area: 'top', position: 19 },
+    { id: 'CARING', typology: 'CARETAKER', cluster: 'SERVICING', hasPsp: true, area: 'top', position: 20 },
+    { id: 'COUNSELING', typology: 'CARETAKER', cluster: 'SERVICING', hasPsp: true, area: 'top', position: 21 },
+    { id: 'SPIRITUALIZING', typology: 'CARETAKER', cluster: 'SERVICING', hasPsp: true, area: 'top', position: 22 },
+    { id: 'THERAPIES', typology: 'CARETAKER', cluster: 'SERVICING', hasPsp: true, area: 'top', position: 23 },
+    // LEFT AREA (33 activities, dari atas ke bawah) - pattern: NAME-PSS-PSP
+    { id: 'LIAISING', typology: 'AMBASSADOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 0 },
+    { id: 'GUIDING', typology: 'MOTIVATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 1 },
+    { id: 'MOTIVATING', typology: 'MOTIVATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 2 },
+    { id: 'SUPPORTING', typology: 'MOTIVATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 3 },
+    { id: 'ADVISING', typology: 'EDUCATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 4 },
+    { id: 'COACHING', typology: 'EDUCATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 5 },
+    { id: 'CONSULTING', typology: 'EDUCATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 6 },
+    { id: 'MENTORING', typology: 'EDUCATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 7 },
+    { id: 'TEACHING', typology: 'EDUCATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 8 },
+    { id: 'TRAINING', typology: 'EDUCATOR', cluster: 'NETWORKING', hasPsp: true, area: 'left', position: 9 },
+    { id: 'ANALYSING', typology: 'ANALYST', cluster: 'THINKING', hasPsp: true, area: 'left', position: 10 },
+    { id: 'BOOKEEPING', typology: 'ANALYST', cluster: 'THINKING', hasPsp: true, area: 'left', position: 11 },
+    { id: 'PROGRAMMING', typology: 'ANALYST', cluster: 'THINKING', hasPsp: true, area: 'left', position: 12 },
+    { id: 'BUDGETING', typology: 'TREASURER', cluster: 'THINKING', hasPsp: true, area: 'left', position: 13 },
+    { id: 'CASHIERING', typology: 'TREASURER', cluster: 'THINKING', hasPsp: true, area: 'left', position: 14 },
+    { id: 'COSTING', typology: 'TREASURER', cluster: 'THINKING', hasPsp: true, area: 'left', position: 15 },
+    { id: 'ESTIMATING', typology: 'TREASURER', cluster: 'THINKING', hasPsp: true, area: 'left', position: 16 },
+    { id: 'AUDITING', typology: 'EVALUATOR', cluster: 'REASONING', hasPsp: true, area: 'left', position: 17 },
+    { id: 'EVALUATING', typology: 'EVALUATOR', cluster: 'REASONING', hasPsp: true, area: 'left', position: 18 },
+    { id: 'INSPECTING', typology: 'EVALUATOR', cluster: 'REASONING', hasPsp: true, area: 'left', position: 19 },
+    { id: 'INVESTIGATING', typology: 'EVALUATOR', cluster: 'REASONING', hasPsp: true, area: 'left', position: 20 },
+    { id: 'REVIEWING', typology: 'EVALUATOR', cluster: 'REASONING', hasPsp: true, area: 'left', position: 21 },
+    { id: 'VERIFYING', typology: 'EVALUATOR', cluster: 'REASONING', hasPsp: true, area: 'left', position: 22 },
+    { id: 'DIAGNOSING', typology: 'RESTORER', cluster: 'REASONING', hasPsp: true, area: 'left', position: 23 },
+    { id: 'IDENTIFYING', typology: 'RESTORER', cluster: 'REASONING', hasPsp: true, area: 'left', position: 24 },
+    { id: 'RESTORING', typology: 'RESTORER', cluster: 'REASONING', hasPsp: true, area: 'left', position: 25 },
+    { id: 'APPRAISING', typology: 'EXPLORER', cluster: 'REASONING', hasPsp: true, area: 'left', position: 26 },
+    { id: 'OBSERVING', typology: 'EXPLORER', cluster: 'REASONING', hasPsp: true, area: 'left', position: 27 },
+    { id: 'RESEARCHING', typology: 'EXPLORER', cluster: 'REASONING', hasPsp: true, area: 'left', position: 28 },
+    { id: 'SURVEYING', typology: 'EXPLORER', cluster: 'REASONING', hasPsp: true, area: 'left', position: 29 },
+    { id: 'CONCEPTUALIZING', typology: 'JOURNALIST', cluster: 'ELEMENTARY', hasPsp: true, area: 'left', position: 30 },
+    { id: 'EDITING', typology: 'JOURNALIST', cluster: 'ELEMENTARY', hasPsp: true, area: 'left', position: 31 },
+    { id: 'REDACTING', typology: 'JOURNALIST', cluster: 'ELEMENTARY', hasPsp: true, area: 'left', position: 32 },
+    // RIGHT AREA (33 activities, dari atas ke bawah) - pattern: PSS-PSP-NAME
+    { id: 'VOLUNTEERING', typology: 'CARETAKER', cluster: 'SERVICING', hasPsp: true, area: 'right', position: 0 },
+    { id: 'ASSISTING', typology: 'SERVER', cluster: 'SERVICING', hasPsp: true, area: 'right', position: 1 },
+    { id: 'GREETING', typology: 'SERVER', cluster: 'SERVICING', hasPsp: true, area: 'right', position: 2 },
+    { id: 'INFORMING', typology: 'SERVER', cluster: 'SERVICING', hasPsp: true, area: 'right', position: 3 },
+    { id: 'SERVING', typology: 'SERVER', cluster: 'SERVICING', hasPsp: true, area: 'right', position: 4 },
+    { id: 'DESIGNING', typology: 'DESIGNER', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 5 },
+    { id: 'DRAFTING', typology: 'DESIGNER', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 6 },
+    { id: 'ANIMATING', typology: 'CREATOR', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 7 },
+    { id: 'CREATING', typology: 'CREATOR', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 8 },
+    { id: 'IDEATING', typology: 'CREATOR', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 9 },
+    { id: 'SYNTHESIZING', typology: 'SYNTHESIZER', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 10 },
+    { id: 'ADVERTISING', typology: 'MARKETER', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 11 },
+    { id: 'DEVELOPING', typology: 'MARKETER', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 12 },
+    { id: 'MARKETING', typology: 'MARKETER', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 13 },
+    { id: 'PUBLICIZING', typology: 'MARKETER', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 14 },
+    { id: 'PLANNING', typology: 'STRATEGIST', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 15 },
+    { id: 'STRATEGIZING', typology: 'STRATEGIST', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 16 },
+    { id: 'VISIONING', typology: 'VISIONARY', cluster: 'GENERATING IDEA', hasPsp: true, area: 'right', position: 17 },
+    // 15 activities without PSP (hasPsp: false)
+    { id: 'ACTING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 18 },
+    { id: 'BEAUTIFYING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 19 },
+    { id: 'CONSERVING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 20 },
+    { id: 'COOKING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 21 },
+    { id: 'DANCING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 22 },
+    { id: 'DRAMATIZING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 23 },
+    { id: 'MODELLING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 24 },
+    { id: 'MUSICAL ART', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 25 },
+    { id: 'SINGING', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 26 },
+    { id: 'VISUAL ART', typology: '-', cluster: 'GENERATING IDEA', hasPsp: false, area: 'right', position: 27 },
+    { id: 'MANUAL SKILL', typology: '-', cluster: 'TECHNICAL', hasPsp: false, area: 'right', position: 28 },
+    { id: 'PHYSICAL SKILL', typology: '-', cluster: 'TECHNICAL', hasPsp: false, area: 'right', position: 29 },
+    { id: 'PLANTING', typology: '-', cluster: 'TECHNICAL', hasPsp: false, area: 'right', position: 30 },
+    { id: 'SPORT', typology: '-', cluster: 'TECHNICAL', hasPsp: false, area: 'right', position: 31 },
+    { id: 'TENDING ANIMAL', typology: '-', cluster: 'TECHNICAL', hasPsp: false, area: 'right', position: 32 },
+    // BOTTOM AREA (24 activities, dari kiri ke kanan) - pattern: PSS-PSP-NAME
+    { id: 'REPORTING', typology: 'JOURNALIST', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 0 },
+    { id: 'WRITING', typology: 'JOURNALIST', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 1 },
+    { id: 'INTERPRETING', typology: 'INTERPRETER', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 2 },
+    { id: 'TRANSCRIBING', typology: 'INTERPRETER', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 3 },
+    { id: 'TRANSLATING', typology: 'INTERPRETER', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 4 },
+    { id: 'COMPLIANCING', typology: 'ADMINISTRATOR', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 5 },
+    { id: 'FILING', typology: 'ADMINISTRATOR', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 6 },
+    { id: 'HOUSEKEEPING', typology: 'ADMINISTRATOR', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 7 },
+    { id: 'ORGANISING', typology: 'ADMINISTRATOR', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 8 },
+    { id: 'SCHEDULING', typology: 'ADMINISTRATOR', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 9 },
+    { id: 'TYPEWRITING', typology: 'ADMINISTRATOR', cluster: 'ELEMENTARY', hasPsp: true, area: 'bottom', position: 10 },
+    { id: 'ASSEMBLING', typology: 'PRODUCER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 11 },
+    { id: 'BUILDING', typology: 'PRODUCER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 12 },
+    { id: 'INSTALLING', typology: 'PRODUCER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 13 },
+    { id: 'PRODUCING', typology: 'PRODUCER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 14 },
+    { id: 'MONITORING', typology: 'SAFEKEEPER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 15 },
+    { id: 'SAFEKEEPING', typology: 'SAFEKEEPER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 16 },
+    { id: 'SECURING', typology: 'SAFEKEEPER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 17 },
+    { id: 'FINISHING', typology: 'QUALITY-CONTROLLER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 18 },
+    { id: 'TESTING', typology: 'QUALITY-CONTROLLER', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 19 },
+    { id: 'DELIVERING', typology: 'DISTRIBUTOR', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 20 },
+    { id: 'DISTRIBUTING', typology: 'DISTRIBUTOR', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 21 },
+    { id: 'MAINTAINING', typology: 'OPERATOR', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 22 },
+    { id: 'OPERATING', typology: 'OPERATOR', cluster: 'TECHNICAL', hasPsp: true, area: 'bottom', position: 23 },
+];
+// Helper Map for quick lookup
+const SCM_ACTIVITIES_MAP = new Map(SCM_ACTIVITIES_DEFINITIONS.map((activity) => [activity.id, activity]));
+function getActivityByPosition(area, position) {
+    return SCM_ACTIVITIES_DEFINITIONS.find((activity) => activity.area === area && activity.position === position);
+}
+// Validation constants
+const SCM_VALIDATION = {
+    TOTAL_ACTIVITIES: 114,
+    ACTIVITIES_WITH_PSP: 99,
+    ACTIVITIES_WITHOUT_PSP: 15,
+    EXPECTED_COUNTS: {
+        left: 33,
+        right: 33,
+        top: 24,
+        bottom: 24
+    }
+};
+
+/**
+ * SCM (Strength Cluster Map) Extractor
+ * Framework-independent extraction of 114 activities with PSP/PSS color detection
+ * Integrates PDF.js for rendering and Tesseract.js for OCR
+ */
+class ScmExtractor {
+    constructor() {
+        this.tesseractWorker = null; // eslint-disable-line @typescript-eslint/no-explicit-any
+    }
+    /**
+     * Extract SCM data from a PDF page
+     */
+    async extractScmData(pdfPage) {
+        // eslint-disable-line @typescript-eslint/no-explicit-any
+        const startTime = Date.now();
+        try {
+            // 1. Detect ID presence using PDF.js text extraction
+            const scmHasId = await this.detectScmHasId(pdfPage);
+            const scmAreaConfigs = this.getScmAreaConfigs(scmHasId);
+            console.log(`🆔 SCM ID Detection: ${scmHasId ? 'ID Present' : 'No ID'}`);
+            // 2. Render page to canvas
+            const canvas = await this.renderPageToCanvas(pdfPage);
+            // 3. Extract from all 4 areas
+            const [leftActivities, rightActivities, topActivities, bottomActivities] = await Promise.all([
+                this.extractAreaActivities(canvas, 'left', scmAreaConfigs),
+                this.extractAreaActivities(canvas, 'right', scmAreaConfigs),
+                this.extractAreaActivities(canvas, 'top', scmAreaConfigs),
+                this.extractAreaActivities(canvas, 'bottom', scmAreaConfigs)
+            ]);
+            const allDetected = [
+                ...leftActivities,
+                ...rightActivities,
+                ...topActivities,
+                ...bottomActivities
+            ];
+            // 4. Map to complete definitions
+            const mappedActivities = this.mapDetectedToDefinitions(allDetected);
+            // 5. Calculate statistics
+            const detectedCount = allDetected.length;
+            const unmappedActivities = allDetected
+                .filter((d) => !SCM_ACTIVITIES_MAP.has(d.activityName))
+                .map((d) => d.activityName);
+            const totalConfidence = mappedActivities.reduce((sum, activity) => sum + activity.detectionConfidence, 0);
+            const averageConfidence = mappedActivities.length > 0 ? totalConfidence / mappedActivities.length : 0;
+            const extractionTime = Date.now() - startTime;
+            return {
+                activities: mappedActivities,
+                metadata: {
+                    totalActivities: SCM_VALIDATION.TOTAL_ACTIVITIES,
+                    detectedActivities: detectedCount,
+                    unmappedActivities,
+                    averageConfidence,
+                    extractionTime
+                }
+            };
+        }
+        catch (error) {
+            console.error('SCM extraction failed:', error);
+            return null;
+        }
+    }
+    /**
+     * Detect if SCM page has ID below the name using PDF.js text extraction
+     */
+    async detectScmHasId(pdfPage) {
+        // eslint-disable-line @typescript-eslint/no-explicit-any
+        try {
+            const textContent = await pdfPage.getTextContent();
+            const textItems = textContent.items;
+            const viewport = pdfPage.getViewport({ scale: 1.0 });
+            const pageHeight = viewport.height;
+            const idSearchArea = pageHeight * 0.15; // Search in upper 15% of page
+            for (const item of textItems) {
+                if (item.transform && item.transform[5] > pageHeight - idSearchArea) {
+                    const text = item.str?.trim();
+                    if (text && /^\d+$/.test(text) && text.length >= 3) {
+                        console.log(`🔍 ID Detection: Found ID "${text}" at position (${Math.round(item.transform[4])}, ${Math.round(item.transform[5])})`);
+                        return true;
+                    }
+                }
+            }
+            console.log('🔍 ID Detection: No numeric ID found in upper area');
+            return false;
+        }
+        catch (error) {
+            console.warn('PDF.js ID detection failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Get area configurations based on whether ID is present
+     */
+    getScmAreaConfigs(scmHasId) {
+        const topStartY = scmHasId ? 0.16 : 0.148;
+        const topEndY = scmHasId ? 0.258 : 0.246;
+        const bottomStartY = scmHasId ? 0.66 : 0.652;
+        const bottomEndY = scmHasId ? 0.758 : 0.746;
+        const leftRightStartY = scmHasId ? 0.256 : 0.244;
+        const leftRightEndY = scmHasId ? 0.662 : 0.65;
+        return {
+            left: {
+                startX: 0.065,
+                endX: 0.278,
+                startY: leftRightStartY,
+                endY: leftRightEndY,
+                expectedCount: 33,
+                pattern: 'NAME-PSS-PSP',
+                orientation: 'horizontal'
+            },
+            right: {
+                startX: 0.76,
+                endX: 0.92,
+                startY: leftRightStartY,
+                endY: leftRightEndY,
+                expectedCount: 33,
+                pattern: 'PSS-PSP-NAME',
+                orientation: 'horizontal'
+            },
+            top: {
+                startX: 0.255,
+                endX: 0.785,
+                startY: topStartY,
+                endY: topEndY,
+                expectedCount: 24,
+                pattern: 'NAME-PSS-PSP',
+                orientation: 'vertical'
+            },
+            bottom: {
+                startX: 0.255,
+                endX: 0.785,
+                startY: bottomStartY,
+                endY: bottomEndY,
+                expectedCount: 24,
+                pattern: 'PSS-PSP-NAME',
+                orientation: 'vertical'
+            }
+        };
+    }
+    /**
+     * Render PDF page to high-resolution canvas
+     */
+    async renderPageToCanvas(pdfPage) {
+        // eslint-disable-line @typescript-eslint/no-explicit-any
+        const scale = 2.0; // Higher resolution for better OCR
+        const viewport = pdfPage.getViewport({ scale });
+        const canvas = document.createElement('canvas');
+        canvas.width = viewport.width;
+        canvas.height = viewport.height;
+        const context = canvas.getContext('2d');
+        if (!context) {
+            throw new Error('Could not get canvas context');
+        }
+        const renderTask = pdfPage.render({
+            canvasContext: context,
+            viewport: viewport
+        });
+        await renderTask.promise;
+        return canvas;
+    }
+    /**
+     * Detect color at specific coordinates using Canvas API
+     */
+    detectColorAt(canvas, point) {
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return 'white';
+        const sampleSize = 10;
+        const imageData = ctx.getImageData(Math.max(0, point.x - sampleSize / 2), Math.max(0, point.y - sampleSize / 2), sampleSize, sampleSize);
+        let totalR = 0, totalG = 0, totalB = 0;
+        const pixelCount = sampleSize * sampleSize;
+        for (let i = 0; i < imageData.data.length; i += 4) {
+            totalR += imageData.data[i];
+            totalG += imageData.data[i + 1];
+            totalB += imageData.data[i + 2];
+        }
+        const avgR = Math.round(totalR / pixelCount);
+        const avgG = Math.round(totalG / pixelCount);
+        const avgB = Math.round(totalB / pixelCount);
+        return this.mapRgbToScmColor(avgR, avgG, avgB);
+    }
+    /**
+     * Map RGB values to SCM color using exact hex color matching
+     */
+    mapRgbToScmColor(r, g, b) {
+        const colors = {
+            black: { r: 0, g: 0, b: 0 },
+            gray: { r: 125, g: 125, b: 125 },
+            white: { r: 255, g: 255, b: 255 },
+            yellow: { r: 255, g: 255, b: 51 },
+            red: { r: 255, g: 0, b: 0 }
+        };
+        let minDistance = Infinity;
+        let closestColor = 'white';
+        const tolerance = 30;
+        for (const [colorName, colorRgb] of Object.entries(colors)) {
+            const distance = Math.sqrt(Math.pow(r - colorRgb.r, 2) + Math.pow(g - colorRgb.g, 2) + Math.pow(b - colorRgb.b, 2));
+            if (distance <= tolerance && distance < minDistance) {
+                minDistance = distance;
+                closestColor = colorName;
+            }
+        }
+        if (minDistance > tolerance) {
+            minDistance = Infinity;
+            for (const [colorName, colorRgb] of Object.entries(colors)) {
+                const distance = Math.sqrt(Math.pow(r - colorRgb.r, 2) + Math.pow(g - colorRgb.g, 2) + Math.pow(b - colorRgb.b, 2));
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    closestColor = colorName;
+                }
+            }
+        }
+        return closestColor;
+    }
+    /**
+     * Extract activities from a specific area using pre-defined positions
+     */
+    async extractAreaActivities(canvas, area, scmAreaConfigs // eslint-disable-line @typescript-eslint/no-explicit-any
+    ) {
+        const config = scmAreaConfigs[area];
+        const activities = [];
+        for (let i = 0; i < config.expectedCount; i++) {
+            try {
+                const expectedActivity = getActivityByPosition(area, i);
+                if (!expectedActivity) {
+                    console.warn(`No activity defined for ${area} area position ${i}`);
+                    continue;
+                }
+                const coords = this.calculateActivityCoordinates(canvas, area, i, scmAreaConfigs);
+                // Extract activity name using Tesseract OCR
+                const detectedName = await this.extractActivityName(canvas, coords.name, area);
+                if (expectedActivity.id !== detectedName) {
+                    console.log(`🚀 ~ ${area}[${i}] Expected: ${expectedActivity.id}, Detected: "${detectedName}"`);
+                }
+                // Detect colors
+                const pssColor = this.detectColorAt(canvas, coords.pss);
+                const pspColor = expectedActivity.hasPsp ? this.detectColorAt(canvas, coords.psp) : null;
+                // Calculate confidence
+                const confidence = this.calculateDetectionConfidence(detectedName, expectedActivity.id, pssColor, pspColor);
+                activities.push({
+                    activityName: expectedActivity.id,
+                    psp: pspColor,
+                    pss: pssColor,
+                    area,
+                    position: i,
+                    confidence
+                });
+            }
+            catch (error) {
+                console.warn(`Failed to extract activity at ${area} position ${i}:`, error);
+            }
+        }
+        return activities;
+    }
+    /**
+     * Calculate activity coordinates based on area and position
+     */
+    calculateActivityCoordinates(canvas, area, index, scmAreaConfigs // eslint-disable-line @typescript-eslint/no-explicit-any
+    ) {
+        const config = scmAreaConfigs[area];
+        const canvasWidth = canvas.width;
+        const canvasHeight = canvas.height;
+        const regionX = config.startX * canvasWidth;
+        const regionY = config.startY * canvasHeight;
+        const regionWidth = (config.endX - config.startX) * canvasWidth;
+        const regionHeight = (config.endY - config.startY) * canvasHeight;
+        if (area === 'left' || area === 'right') {
+            const itemHeight = regionHeight / config.expectedCount;
+            const rowY = regionY + index * itemHeight;
+            const centerY = rowY + itemHeight / 2;
+            if (area === 'left') {
+                const nameWidth = regionWidth * 0.5;
+                return {
+                    name: {
+                        x: regionX + regionWidth * 0.28,
+                        y: centerY - 8,
+                        width: nameWidth,
+                        height: itemHeight * 0.9
+                    },
+                    pss: { x: regionX + regionWidth * 0.84, y: centerY },
+                    psp: { x: regionX + regionWidth * 0.94, y: centerY }
+                };
+            }
+            else {
+                const nameWidth = regionWidth * 0.7;
+                return {
+                    pss: { x: regionX + regionWidth * 0.09, y: centerY },
+                    psp: { x: regionX + regionWidth * 0.22, y: centerY },
+                    name: {
+                        x: regionX + regionWidth * 0.28,
+                        y: rowY + itemHeight * 0.28,
+                        width: nameWidth,
+                        height: itemHeight * 0.8
+                    }
+                };
+            }
+        }
+        else {
+            const itemWidth = regionWidth / config.expectedCount;
+            const colX = regionX + index * itemWidth;
+            const centerX = colX + itemWidth / 2;
+            if (area === 'top') {
+                return {
+                    name: {
+                        x: colX + itemWidth * 0.1,
+                        y: regionY + regionHeight * 0.03,
+                        width: itemWidth * 0.8,
+                        height: regionHeight * 0.75
+                    },
+                    pss: { x: centerX, y: regionY + regionHeight * 0.82 },
+                    psp: { x: centerX + itemWidth * 0.05, y: regionY + regionHeight * 0.95 }
+                };
+            }
+            else {
+                return {
+                    psp: { x: centerX, y: regionY + regionHeight * 0.075 },
+                    pss: { x: centerX, y: regionY + regionHeight * 0.2 },
+                    name: {
+                        x: colX + itemWidth * 0.1,
+                        y: regionY + regionHeight * 0.24,
+                        width: itemWidth * 0.8,
+                        height: regionHeight * 0.8
+                    }
+                };
+            }
+        }
+    }
+    /**
+     * Extract activity name using Tesseract OCR from canvas region
+     */
+    async extractActivityName(canvas, region, area) {
+        try {
+            const worker = await this.initializeTesseract();
+            const tempCanvas = document.createElement('canvas');
+            tempCanvas.width = region.width;
+            tempCanvas.height = region.height;
+            const tempCtx = tempCanvas.getContext('2d');
+            if (!tempCtx)
+                return '';
+            tempCtx.drawImage(canvas, region.x, region.y, region.width, region.height, 0, 0, region.width, region.height);
+            // Handle vertical text rotation for top/bottom areas
+            if (area === 'top' || area === 'bottom') {
+                const rotatedCanvas = document.createElement('canvas');
+                const rotatedCtx = rotatedCanvas.getContext('2d');
+                if (!rotatedCtx)
+                    return '';
+                rotatedCanvas.width = region.height;
+                rotatedCanvas.height = region.width;
+                rotatedCtx.translate(region.height / 2, region.width / 2);
+                rotatedCtx.rotate(Math.PI / 2);
+                rotatedCtx.drawImage(tempCanvas, -region.width / 2, -region.height / 2, region.width, region.height);
+                tempCanvas.width = rotatedCanvas.width;
+                tempCanvas.height = rotatedCanvas.height;
+                tempCtx.clearRect(0, 0, tempCanvas.width, tempCanvas.height);
+                tempCtx.drawImage(rotatedCanvas, 0, 0);
+            }
+            // Enhance image for OCR
+            tempCtx.filter = 'contrast(150%) brightness(100%)';
+            tempCtx.drawImage(tempCanvas, 0, 0);
+            // Configure OCR
+            const Tesseract = await import('tesseract.js');
+            await worker.setParameters({
+                tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ',
+                tessedit_pageseg_mode: area === 'top' || area === 'bottom'
+                    ? Tesseract.PSM.SINGLE_LINE
+                    : Tesseract.PSM.SINGLE_BLOCK,
+                preserve_interword_spaces: '1'
+            });
+            const { data: { text } } = await worker.recognize(tempCanvas);
+            const cleanedText = this.normalizeActivityName(text);
+            const bestMatch = this.findBestActivityMatch(cleanedText);
+            return bestMatch || cleanedText;
+        }
+        catch (error) {
+            console.warn('OCR extraction failed:', error);
+            return '';
+        }
+    }
+    /**
+     * Initialize Tesseract worker for OCR
+     */
+    async initializeTesseract() {
+        if (!this.tesseractWorker) {
+            const Tesseract = await import('tesseract.js');
+            this.tesseractWorker = await Tesseract.createWorker('eng');
+            await this.tesseractWorker.setParameters({
+                tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ',
+                tessedit_pageseg_mode: Tesseract.PSM.SINGLE_BLOCK,
+                preserve_interword_spaces: '1'
+            });
+        }
+        return this.tesseractWorker;
+    }
+    /**
+     * Normalize activity name for matching
+     */
+    normalizeActivityName(text) {
+        return text
+            .toUpperCase()
+            .trim()
+            .replace(/[^A-Z\s]/g, '')
+            .replace(/\s+/g, ' ')
+            .replace(/\s*$/, '');
+    }
+    /**
+     * Find best matching activity from pre-defined list
+     */
+    findBestActivityMatch(detectedName) {
+        const normalized = this.normalizeActivityName(detectedName);
+        if (!normalized)
+            return null;
+        // Exact match first
+        for (const [activityId] of SCM_ACTIVITIES_MAP) {
+            if (this.normalizeActivityName(activityId) === normalized) {
+                return activityId;
+            }
+        }
+        // Fuzzy matching for partial matches
+        for (const [activityId] of SCM_ACTIVITIES_MAP) {
+            const activityNormalized = this.normalizeActivityName(activityId);
+            if (activityNormalized.includes(normalized) || normalized.includes(activityNormalized)) {
+                return activityId;
+            }
+        }
+        return null;
+    }
+    /**
+     * Calculate detection confidence score
+     */
+    calculateDetectionConfidence(detected, matched, pss, psp) {
+        let confidence = 0.3; // Base confidence
+        // Text matching confidence
+        const detectedNorm = this.normalizeActivityName(detected);
+        const matchedNorm = this.normalizeActivityName(matched);
+        if (detectedNorm === matchedNorm) {
+            confidence += 0.5;
+        }
+        else if (detectedNorm.length > 0) {
+            if (detectedNorm.includes(matchedNorm) || matchedNorm.includes(detectedNorm)) {
+                confidence += 0.3;
+            }
+            else if (detectedNorm.length > 3) {
+                const words1 = detectedNorm.split(' ').filter((w) => w.length > 2);
+                const words2 = matchedNorm.split(' ').filter((w) => w.length > 2);
+                const commonWords = words1.filter((w) => words2.includes(w));
+                if (commonWords.length > 0) {
+                    confidence += 0.2;
+                }
+                else {
+                    confidence += 0.1;
+                }
+            }
+        }
+        // Color detection confidence
+        if (pss !== 'white')
+            confidence += 0.15;
+        if (psp && psp !== 'white')
+            confidence += 0.15;
+        return Math.min(1.0, confidence);
+    }
+    /**
+     * Map detected activities to definitions
+     */
+    mapDetectedToDefinitions(detected) {
+        const mapped = [];
+        for (const [activityId, definition] of SCM_ACTIVITIES_MAP) {
+            const detectedMatch = detected.find((d) => d.activityName === activityId);
+            if (detectedMatch) {
+                mapped.push({
+                    id: definition.id,
+                    typology: definition.typology,
+                    cluster: definition.cluster,
+                    psp: definition.hasPsp ? detectedMatch.psp : null,
+                    pss: detectedMatch.pss,
+                    detectionConfidence: detectedMatch.confidence
+                });
+            }
+            else {
+                mapped.push({
+                    id: definition.id,
+                    typology: definition.typology,
+                    cluster: definition.cluster,
+                    psp: definition.hasPsp ? 'white' : null,
+                    pss: 'white',
+                    detectionConfidence: 0
+                });
+            }
+        }
+        return mapped;
+    }
+    /**
+     * Cleanup Tesseract worker
+     */
+    async cleanup() {
+        if (this.tesseractWorker) {
+            await this.tesseractWorker.terminate();
+            this.tesseractWorker = null;
+        }
+    }
+}
+
+/**
+ * TMA data type definitions for the extractor package
+ * Based on the original useExtractTMA.ts interfaces
+ */
+const DEFAULT_CONFIG = {
+    includeSCM: true, // Include SCM by default as per Phase 2 requirements
+    workerSrc: "auto",
+    tesseractWorkerSrc: "auto",
+    debug: false,
+    timeoutMs: 30000,
+};
+
+/**
+ * Main TMA extractor class that orchestrates the extraction process
+ */
+class TmaExtractor {
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.pdfProcessor = new PdfProcessor(this.config);
+        this.scmExtractor = new ScmExtractor();
+    }
+    /**
+     * Validates input file
+     */
+    validateFile(file) {
+        const validation = this.pdfProcessor.validatePdfFile(file);
+        if (!validation.isValid) {
+            throw createError("INVALID_FILE_TYPE", validation.error || "Invalid file");
+        }
+    }
+    /**
+     * Extracts all talent data from page texts
+     */
+    extractTalentData(pageTexts, pageCount) {
+        try {
+            const name = extractName(pageTexts.talentOrder, pageCount);
+            const talents = extractTalentOrder(pageTexts.talentOrder, false, pageCount);
+            const strength = extractStrength(pageTexts.strength, pageCount);
+            const typology = extractTypology(pageTexts.typologyAndBranding);
+            const personalbranding = extractPersonalBranding(pageTexts.typologyAndBranding, pageCount);
+            return {
+                name,
+                talents,
+                strength,
+                typology,
+                personalbranding,
+            };
+        }
+        catch (error) {
+            throw wrapError(error, "TALENT_EXTRACTION_ERROR", "Failed to extract talent data");
+        }
+    }
+    /**
+     * Processes a single PDF file and extracts TMA data
+     */
+    async extractFromPdf(file) {
+        // Validate input file
+        this.validateFile(file);
+        try {
+            // Get page count and validate format
+            const pageCount = await this.pdfProcessor.getPageCount(file);
+            const formatValidation = validateAndGetFormat(pageCount);
+            if (!formatValidation.isValid) {
+                throw createError("UNSUPPORTED_FORMAT", formatValidation.error);
+            }
+            // Extract page texts
+            const pageNumbers = formatValidation.pages;
+            const pageTexts = await this.pdfProcessor.extractPageTexts(file, pageNumbers);
+            // Extract talent data
+            const talentData = this.extractTalentData(pageTexts, pageCount);
+            // Add SCM extraction if requested (Phase 2 feature)
+            if (this.config.includeSCM) {
+                try {
+                    this.logDebug("Starting SCM extraction...");
+                    // Get SCM page number based on TMA format
+                    const scmPageNumber = this.pdfProcessor.getScmPageNumber(pageCount);
+                    this.logDebug(`SCM page number for ${pageCount}-page TMA: ${scmPageNumber}`);
+                    const scmPage = await this.pdfProcessor.getPage(file, scmPageNumber);
+                    if (scmPage) {
+                        const scmData = await this.scmExtractor.extractScmData(scmPage);
+                        if (scmData) {
+                            talentData.scm = scmData;
+                            this.logDebug(`SCM extraction successful: ${scmData.activities.length} activities extracted`);
+                        }
+                        else {
+                            this.logDebug("SCM extraction returned null, continuing without SCM data");
+                        }
+                    }
+                    else {
+                        this.logDebug("No SCM page found, continuing without SCM data");
+                    }
+                }
+                catch (error) {
+                    this.logDebug("SCM extraction failed, continuing without SCM data: " + error);
+                    // Continue without SCM data - don't break the main extraction
+                }
+            }
+            // Transform to cleaned format
+            const singlePersonResult = {
+                person: {
+                    ...talentData,
+                    top14Talents: talentData.talents.slice(0, 14).map((t) => t.tema),
+                    top7Talents: talentData.talents.slice(0, 7).map((t) => t.tema),
+                    low14Talents: talentData.talents.slice(-14).map((t) => t.tema),
+                },
+            };
+            return DataTransformer.transformSinglePersonResult(singlePersonResult);
+        }
+        catch (error) {
+            if (error instanceof TmaExtractionError) {
+                throw error;
+            }
+            throw wrapError(error, "PDF_PROCESSING_ERROR", "Failed to process PDF file");
+        }
+    }
+    /**
+     * Logs debug messages if debug mode is enabled
+     */
+    logDebug(message) {
+        if (this.config.debug) {
+            console.log(`[TMA-Extractor] ${message}`);
+        }
+    }
+}
+/**
+ * Main package export function
+ * Simple API that creates an extractor instance and processes the file
+ */
+async function tmaExtractor(file, config = {}) {
+    const extractor = new TmaExtractor(config);
+    return await extractor.extractFromPdf(file);
+}
+
+export { DEFAULT_CONFIG, TmaExtractionError, TmaExtractor, tmaExtractor as default };
+//# sourceMappingURL=index.js.map