@testgorilla/tgo-coding-test 0.0.1 → 1.0.0

package/esm2022/lib/services/storage.service.mjs

@@ -0,0 +1,624 @@
+import { Injectable } from '@angular/core';
+import { LocalStorageService } from 'ngx-webstorage';
+import { filter } from 'rxjs';
+import { AssessmentIdPreview } from '../models/lat-languages';
+import { ConfigurationsService } from './configurations.service';
+import { LibCodingTestService } from './lib-coding-test.service';
+import { timeToMs } from '../utils/time-to-ms.util';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-webstorage";
+import * as i2 from "./lib-coding-test.service";
+import * as i3 from "./configurations.service";
+export class StorageCodingService {
+    storage;
+    libCodingTestService;
+    configurationsService;
+    CURRENT_STORAGE_VERSION = 2;
+    autoSavedData = {
+        version: this.CURRENT_STORAGE_VERSION,
+        config: {},
+        isFullscreen: false,
+        assessments: {},
+        lastModified: Date.now(),
+    };
+    key = 'savedData';
+    assessmentId;
+    questionId;
+    language;
+    codeSaveEnabled;
+    testCasesSaveEnabled;
+    isLAT;
+    currentMode;
+    isPreview;
+    codeChangeSubscription;
+    configSubscription;
+    isFullscreenSubscription;
+    currentLanguageSubscription;
+    isCodeComponentAlive = filter(() => !this.configurationsService.getCodeComponentDestroyed());
+    // Maximum age of entire storage data in days
+    MAX_STORAGE_AGE_DAYS = 7;
+    // Maximum age for assessment inner data in days
+    MAX_QUESTION_DATA_AGE_DAYS = 1;
+    // Maximum number of assessments to keep
+    MAX_ASSESSMENTS = 10;
+    // The default question ID used for migrated v1 data
+    DEFAULT_MIGRATION_QUESTION_ID = 'default-question';
+    // todo: remove
+    // storage = {
+    //   retrieve: (key: string) => {
+    //     return {} as any;
+    //   },
+    //   store: (key: string, value: any) => {
+    //     return {} as any;
+    //   },
+    //   clear: (key: string) => {
+    //     return {} as any;
+    //   },
+    // };
+    constructor(
+    // todo
+    storage, libCodingTestService, configurationsService) {
+        this.storage = storage;
+        this.libCodingTestService = libCodingTestService;
+        this.configurationsService = configurationsService;
+        // Perform safety check on localStorage data
+        this.performStorageSafetyCheck();
+    }
+    /**
+     * Performs a safety check on localStorage data.
+     * This is called at service initialization to ensure data integrity.
+     */
+    performStorageSafetyCheck() {
+        try {
+            const savedData = this.storage.retrieve(this.key);
+            // If no data, nothing to check
+            if (!savedData) {
+                return;
+            }
+            // Check storage format and migrate if needed
+            if (!('version' in savedData)) {
+                // It's v1 format, so we'll migrate it when it's actually needed
+                // No need to do anything right now
+            }
+            else {
+                // It's v2 format, so we can perform cleanup right away
+                this.autoSavedData = savedData;
+            }
+        }
+        catch (error) {
+            // If any error occurs during safety check, reset storage to avoid issues
+            console.error('Error during storage safety check, resetting storage:', error);
+            this.autoSavedData = {
+                version: this.CURRENT_STORAGE_VERSION,
+                config: {},
+                isFullscreen: false,
+                assessments: {},
+                lastModified: Date.now(),
+            };
+            this.storeData();
+        }
+    }
+    initializeSaving() {
+        if (!this.codeChangeSubscription) {
+            this.codeChangeSubscription = this.libCodingTestService.codeChange$
+                .pipe(this.isCodeComponentAlive)
+                .subscribe((code) => {
+                if (this.codeSaveEnabled && this.assessmentId && this.questionId) {
+                    this.ensureDataStructure();
+                    const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
+                    const targetTestData = this.isPreview ? questionData.preview : questionData.actual;
+                    targetTestData.code[this.language] = code;
+                    this.updateLastModified(targetTestData);
+                    this.storeData();
+                }
+            });
+        }
+        if (!this.configSubscription) {
+            this.configSubscription = this.configurationsService.config$
+                .pipe(this.isCodeComponentAlive)
+                .subscribe((config) => {
+                this.autoSavedData.config = { ...config };
+                this.updateLastModified(this.autoSavedData);
+                this.storeData();
+            });
+        }
+        if (!this.isFullscreenSubscription) {
+            this.isFullscreenSubscription = this.libCodingTestService.isFullscreen$
+                .pipe(this.isCodeComponentAlive)
+                .subscribe((isFullscreen) => {
+                this.autoSavedData.isFullscreen = isFullscreen;
+                this.updateLastModified(this.autoSavedData);
+                this.storeData();
+            });
+        }
+        if (!this.currentLanguageSubscription && this.isLAT) {
+            this.currentLanguageSubscription = this.libCodingTestService.currentLanguage$
+                .pipe(this.isCodeComponentAlive)
+                .subscribe((language) => {
+                this.autoSavedData.lastLanguageLAT = {
+                    value: language,
+                    version: this.libCodingTestService.getVersion(),
+                };
+                this.updateLastModified(this.autoSavedData);
+                this.storeData();
+            });
+        }
+    }
+    setupAutoSavedData(language, assessmentId, questionId, codeSaveEnabled, testCasesSaveEnabled, isLAT, mode) {
+        this.language = language;
+        this.assessmentId = assessmentId;
+        this.questionId = questionId;
+        this.codeSaveEnabled = codeSaveEnabled;
+        this.testCasesSaveEnabled = testCasesSaveEnabled;
+        this.isLAT = isLAT;
+        this.currentMode = mode;
+        this.isPreview = mode === "preview" /* Modes.Preview */ || mode === "non-assessment-preview" /* Modes.NonAssessmentPreview */;
+        // Get saved data
+        const savedData = this.storage.retrieve(this.key);
+        // Handle migration if needed
+        if (savedData) {
+            // Check if it's v1 schema (no version field)
+            if (!('version' in savedData)) {
+                this.migrateFromV1ToV2(savedData);
+            }
+            else {
+                this.autoSavedData = savedData;
+            }
+            // Apply loaded config and fullscreen setting
+            this.configurationsService.setConfig(this.autoSavedData.config);
+            this.libCodingTestService.setFullscreen(this.autoSavedData.isFullscreen);
+        }
+    }
+    migrateFromV1ToV2(v1Data) {
+        // Create a new v2 data structure
+        const v2Data = {
+            version: this.CURRENT_STORAGE_VERSION,
+            config: v1Data.config,
+            isFullscreen: v1Data.isFullscreen,
+            lastLanguageLAT: v1Data.lastLanguageLAT,
+            assessments: {},
+            lastModified: Date.now(),
+        };
+        // Migrate assessment data
+        // In v1, assessments were directly mapped to TestData
+        // In v2, we need to organize by questionId
+        for (const [assessmentId, testData] of Object.entries(v1Data.assessments)) {
+            if (assessmentId === AssessmentIdPreview) {
+                continue;
+            }
+            // We use a consistent default questionId for migration to ensure backward compatibility
+            const defaultQuestionId = this.DEFAULT_MIGRATION_QUESTION_ID;
+            // Initialize the assessment entry if it doesn't exist
+            if (!v2Data.assessments[assessmentId]) {
+                v2Data.assessments[assessmentId] = {};
+            }
+            // Create question data with the migrated test data
+            const questionData = {};
+            questionData.actual = {
+                ...testData,
+                lastModified: Date.now(),
+            };
+            // Set last modified time for the question data
+            questionData.lastModified = Date.now();
+            // Add to the v2 structure
+            v2Data.assessments[assessmentId][defaultQuestionId] = questionData;
+        }
+        // Update our instance with migrated data
+        this.autoSavedData = { ...v2Data };
+        // Save the migrated data
+        this.storeData();
+    }
+    ensureDataStructure() {
+        // Make sure assessment exists
+        if (!this.autoSavedData.assessments[this.assessmentId]) {
+            this.autoSavedData.assessments[this.assessmentId] = {};
+        }
+        // Make sure question exists
+        if (!this.autoSavedData.assessments[this.assessmentId][this.questionId]) {
+            this.autoSavedData.assessments[this.assessmentId][this.questionId] = {
+                lastModified: Date.now(),
+            };
+        }
+        const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
+        // Ensure preview or actual exists based on current mode
+        if (this.isPreview && !questionData.preview) {
+            questionData.preview = {
+                code: {},
+                testCasesLAT: [],
+                lastModified: Date.now(),
+            };
+        }
+        else if (!this.isPreview && !questionData.actual) {
+            questionData.actual = {
+                code: {},
+                testCasesLAT: [],
+                lastModified: Date.now(),
+            };
+        }
+    }
+    updateLastModified(data) {
+        const now = Date.now();
+        data.lastModified = now;
+        // If updating a TestData, also update its parent QuestionData
+        if ('code' in data && this.assessmentId && this.questionId) {
+            this.autoSavedData.assessments[this.assessmentId][this.questionId].lastModified = now;
+        }
+        // Always update root timestamp regardless of the object being modified
+        this.autoSavedData.lastModified = now;
+    }
+    /**
+     * Cleanup with a temporary age threshold
+     * @param maxAgeDays Maximum age in days for data to be considered valid
+     */
+    cleanupWithReducedThreshold(maxAgeDays) {
+        // Call the unified cleanup method with more aggressive parameters
+        this.cleanupStorageData({
+            storageAgeMultiplier: 2, // More aggressive multiplier
+            customStorageAgeDays: maxAgeDays, // Use the provided custom age
+            minQuestionDataAgeDays: 0.5, // 12 hours minimum
+            assessmentLimitMultiplier: 0.5, // Half the normal assessment limit
+        });
+    }
+    /**
+     * Unified method to clean up localStorage data with configurable intensity
+     * @param options Cleanup options to control the aggressiveness of the cleanup
+     */
+    cleanupStorageData(options) {
+        const now = Date.now();
+        // Determine the storage age threshold
+        const storageAgeDays = options.customStorageAgeDays ?? this.MAX_STORAGE_AGE_DAYS;
+        const storageAgeThreshold = timeToMs(storageAgeDays); // Convert days to milliseconds
+        const multiplier = options.storageAgeMultiplier ?? 1;
+        // Check if the entire storage is too old and needs cleanup
+        if (this.autoSavedData.lastModified && now - this.autoSavedData.lastModified > storageAgeThreshold * multiplier) {
+            // If the entire storage is very old, just reset everything
+            this.autoSavedData = {
+                version: this.CURRENT_STORAGE_VERSION,
+                config: this.autoSavedData.config, // Keep the config settings
+                isFullscreen: this.autoSavedData.isFullscreen, // Keep fullscreen setting
+                assessments: {},
+                lastModified: now,
+            };
+            this.storeData();
+            return;
+        }
+        const assessmentMetadata = [];
+        // Determine the question data age threshold
+        let questionDataAgeThreshold;
+        if (options.useStandardQuestionDataAge) {
+            // Use the standard threshold for normal cleanup
+            questionDataAgeThreshold = timeToMs(this.MAX_QUESTION_DATA_AGE_DAYS);
+        }
+        else {
+            // For maintenance/aggressive cleanup, use a custom threshold
+            const minAgeHours = (options.minQuestionDataAgeDays ?? 0.5) * 24; // Convert days to hours
+            questionDataAgeThreshold = Math.max(timeToMs(this.MAX_QUESTION_DATA_AGE_DAYS), // Standard age in milliseconds
+            timeToMs(minAgeHours, 'hours') // Minimum age in milliseconds
+            );
+        }
+        // Collect assessments with their latest modification times
+        for (const [assessmentId, questions] of Object.entries(this.autoSavedData.assessments)) {
+            let assessmentLastModified = 0;
+            // Check all questions in this assessment
+            let hasValidQuestions = false;
+            for (const [questionId, questionData] of Object.entries(questions)) {
+                // Skip if undefined
+                if (!questionData) {
+                    continue;
+                }
+                // Get the latest modification time from preview and actual
+                const previewTime = questionData.preview?.lastModified || 0;
+                const actualTime = questionData.actual?.lastModified || 0;
+                const questionLastModified = Math.max(previewTime, actualTime, questionData.lastModified || 0);
+                // Check if data is too old - using configured threshold
+                const isPreviewTooOld = previewTime > 0 && now - previewTime > questionDataAgeThreshold;
+                const isActualTooOld = actualTime > 0 && now - actualTime > questionDataAgeThreshold;
+                // Clean up old data within the question
+                if (isPreviewTooOld && questionData.preview) {
+                    delete questionData.preview;
+                }
+                if (isActualTooOld && questionData.actual) {
+                    delete questionData.actual;
+                }
+                // If neither preview nor actual exists, remove the question
+                if (!questionData.preview && !questionData.actual) {
+                    delete questions[questionId];
+                }
+                else {
+                    hasValidQuestions = true;
+                    assessmentLastModified = Math.max(assessmentLastModified, questionLastModified);
+                }
+            }
+            // If no valid questions, remove the assessment
+            if (!hasValidQuestions) {
+                delete this.autoSavedData.assessments[assessmentId];
+            }
+            else {
+                // Add to our list for potential size-based cleanup
+                assessmentMetadata.push({
+                    id: assessmentId,
+                    lastModified: assessmentLastModified,
+                });
+            }
+        }
+        // Determine the assessment limit based on the multiplier
+        const limitMultiplier = options.assessmentLimitMultiplier ?? 1;
+        const assessmentLimit = Math.ceil(this.MAX_ASSESSMENTS * limitMultiplier);
+        // If we have too many assessments, remove the oldest ones
+        if (assessmentMetadata.length > assessmentLimit) {
+            // Sort by lastModified (most recent first)
+            assessmentMetadata.sort((a, b) => b.lastModified - a.lastModified);
+            // Remove oldest assessments that exceed our limit
+            for (let i = assessmentLimit; i < assessmentMetadata.length; i++) {
+                delete this.autoSavedData.assessments[assessmentMetadata[i].id];
+            }
+        }
+        // Save the cleaned data
+        this.storeData();
+    }
+    changeLanguage(language) {
+        this.language = language;
+    }
+    /**
+     * Gets data from v1 schema format
+     * Used for backward compatibility when retrieving data
+     */
+    getDataFromV1Schema(retrievedData) {
+        // For v1, we need to handle the case where we don't have questionId
+        // We're now using questionId in the app, but stored data might still be in v1 format
+        // For preview data, the assessment ID would be AssessmentIdPreview
+        if (this.assessmentId === AssessmentIdPreview) {
+            if (this.isPreview) {
+                // For preview mode on preview assessment, get the code directly
+                const code = retrievedData.assessments[this.assessmentId]?.code;
+                if (code && this.language in code) {
+                    return code[this.language];
+                }
+            }
+            // We don't expect actual/non-preview data for AssessmentIdPreview
+            return null;
+        }
+        else {
+            // For regular assessments, v1 only had code in the "actual" section
+            if (!this.isPreview) {
+                const code = retrievedData.assessments[this.assessmentId]?.code;
+                if (code && this.language in code) {
+                    return code[this.language];
+                }
+            }
+            // We don't have preview data for regular assessments in v1
+            return null;
+        }
+    }
+    getSavedCode() {
+        const retrievedData = this.retrieveData();
+        if (!retrievedData) {
+            return null;
+        }
+        // Check if using v2 schema
+        if ('version' in retrievedData) {
+            // Handle v2 schema
+            const v2Data = retrievedData;
+            const assessmentData = v2Data.assessments[this.assessmentId];
+            if (!assessmentData) {
+                return null;
+            }
+            // First try with provided questionId
+            if (this.questionId && assessmentData[this.questionId]) {
+                const questionData = assessmentData[this.questionId];
+                const testData = this.isPreview ? questionData.preview : questionData.actual;
+                if (testData?.code && this.language in testData.code) {
+                    return testData.code[this.language];
+                }
+            }
+            if (this.questionId !== this.DEFAULT_MIGRATION_QUESTION_ID &&
+                assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID]) {
+                const questionData = assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID];
+                const testData = this.isPreview ? questionData.preview : questionData.actual;
+                if (testData?.code && this.language in testData.code) {
+                    return testData.code[this.language];
+                }
+            }
+            return null;
+        }
+        else {
+            // Handle v1 schema for backward compatibility
+            return this.getDataFromV1Schema(retrievedData);
+        }
+    }
+    getLastLanguageLAT() {
+        const retrievedData = this.retrieveData();
+        if (!retrievedData) {
+            return null;
+        }
+        return retrievedData.lastLanguageLAT || null;
+    }
+    getSavedTestCases() {
+        const retrievedData = this.retrieveData();
+        if (!retrievedData) {
+            return null;
+        }
+        // Check if using v2 schema
+        if ('version' in retrievedData) {
+            // Handle v2 schema
+            const v2Data = retrievedData;
+            const assessmentData = v2Data.assessments[this.assessmentId];
+            if (!assessmentData) {
+                return null;
+            }
+            // First try with provided questionId
+            if (this.questionId && assessmentData[this.questionId]) {
+                const questionData = assessmentData[this.questionId];
+                const testData = this.isPreview ? questionData.preview : questionData.actual;
+                if (testData?.testCasesLAT) {
+                    return testData.testCasesLAT;
+                }
+            }
+            // If not found and questionId != DEFAULT_MIGRATION_QUESTION_ID,
+            // also try with the default migration ID as a fallback
+            if (this.questionId !== this.DEFAULT_MIGRATION_QUESTION_ID &&
+                assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID]) {
+                const questionData = assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID];
+                const testData = this.isPreview ? questionData.preview : questionData.actual;
+                if (testData?.testCasesLAT) {
+                    return testData.testCasesLAT;
+                }
+            }
+            return null;
+        }
+        else {
+            // Handle v1 schema test cases (test cases were only in the actual mode)
+            const v1Data = retrievedData;
+            if (!this.isPreview && v1Data.assessments[this.assessmentId]?.testCasesLAT) {
+                return v1Data.assessments[this.assessmentId].testCasesLAT;
+            }
+            return null;
+        }
+    }
+    getSavedConfig() {
+        const retrievedData = this.retrieveData();
+        return retrievedData?.config ? { ...retrievedData.config } : null;
+    }
+    getSavedFullScreenMode() {
+        const retrievedData = this.retrieveData();
+        return retrievedData?.isFullscreen !== undefined ? retrievedData.isFullscreen : null;
+    }
+    clearSavedCode() {
+        this.ensureDataStructure();
+        const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
+        const targetTestData = this.isPreview ? [questionData.preview] : [questionData.preview, questionData.actual];
+        let hasChanged = false;
+        targetTestData.forEach(testData => {
+            if (testData) {
+                testData.code = {};
+                this.updateLastModified(testData);
+                hasChanged = true;
+            }
+        });
+        if (hasChanged) {
+            this.storeData();
+        }
+    }
+    clearLastLang() {
+        this.autoSavedData.lastLanguageLAT = null;
+        this.updateLastModified(this.autoSavedData);
+        this.storeData();
+    }
+    clearSavedTestCases() {
+        this.ensureDataStructure();
+        const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
+        const targetTestData = this.isPreview ? questionData.preview : questionData.actual;
+        if (targetTestData) {
+            const hasNoCode = !Object.keys(targetTestData.code ?? {}).length;
+            if (this.isPreview) {
+                targetTestData.testCasesLAT = [];
+                this.updateLastModified(targetTestData);
+            }
+            else if (hasNoCode) {
+                const allQuestions = this.autoSavedData.assessments[this.assessmentId];
+                delete allQuestions[this.questionId];
+                this.autoSavedData.assessments[this.assessmentId] = { ...allQuestions };
+                this.updateLastModified(this.autoSavedData);
+            }
+            this.storeData();
+        }
+    }
+    updateVersion(version) {
+        if (this.autoSavedData.lastLanguageLAT) {
+            this.autoSavedData.lastLanguageLAT.version = version;
+            this.updateLastModified(this.autoSavedData);
+            this.storeData();
+        }
+    }
+    updateTestCases(testCases) {
+        if (this.assessmentId && this.questionId && this.testCasesSaveEnabled) {
+            this.ensureDataStructure();
+            const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
+            const targetTestData = this.isPreview ? questionData.preview : questionData.actual;
+            if (targetTestData) {
+                targetTestData.testCasesLAT = testCases;
+                this.updateLastModified(targetTestData);
+                this.storeData();
+            }
+        }
+    }
+    storeData() {
+        this.storage.store(this.key, this.autoSavedData);
+    }
+    retrieveData() {
+        return this.storage.retrieve(this.key);
+    }
+    /**
+     * Manually triggers data cleanup and migration.
+     * Useful for handling large localStorage or migration when needed.
+     * This can be called from application startup or after major events.
+     */
+    performMaintenanceAndCleanup() {
+        // Get current data
+        const savedData = this.storage.retrieve(this.key);
+        // If no data, nothing to do
+        if (!savedData) {
+            return;
+        }
+        // Check if migration needed
+        if (!('version' in savedData)) {
+            this.migrateFromV1ToV2(savedData);
+        }
+        else {
+            // Already migrated, just perform cleanup
+            this.autoSavedData = savedData;
+            // Perform a more aggressive cleanup for manual maintenance
+            // by temporarily modifying the cleanup thresholds
+            const originalMaxAge = this.MAX_STORAGE_AGE_DAYS;
+            const halfAge = Math.floor(originalMaxAge / 2); // Cut threshold in half
+            // Create a custom cleanup function with reduced threshold
+            this.cleanupWithReducedThreshold(halfAge);
+        }
+        // Verify localStorage size is manageable
+        try {
+            const serializedData = JSON.stringify(this.autoSavedData);
+            const sizeInKB = Math.round(serializedData.length / 1024);
+            // If data is too large (over 2MB), perform more aggressive cleanup
+            if (sizeInKB > 2048) {
+                console.warn(`Local storage data is large (${sizeInKB}KB), performing deep cleanup`);
+                // Use extremely aggressive cleanup settings
+                this.cleanupStorageData({
+                    storageAgeMultiplier: 0.5, // Even more aggressive - half the normal age
+                    minQuestionDataAgeDays: 0.25, // 6 hours minimum
+                    assessmentLimitMultiplier: 0.2, // Keep only 20% of assessments
+                });
+                // If still too large, keep only a few most recent assessments
+                const newSerializedData = JSON.stringify(this.autoSavedData);
+                const newSizeInKB = Math.round(newSerializedData.length / 1024);
+                if (newSizeInKB > 1024) {
+                    // Keep only recent assessments
+                    const assessments = this.autoSavedData.assessments;
+                    // Find the newest timestamp in each assessment
+                    const getNewestTimestamp = (obj) => Object.values(obj).reduce((max, questionData) => Math.max(max, questionData?.lastModified || 0), 0);
+                    const entries = Object.entries(assessments).sort(([, a], [, b]) => getNewestTimestamp(b) -
+                        getNewestTimestamp(a));
+                    // Keep only the 5 most recent assessments
+                    const keepCount = Math.min(5, entries.length);
+                    this.autoSavedData.assessments = {};
+                    for (let i = 0; i < keepCount; i++) {
+                        const [id, data] = entries[i];
+                        this.autoSavedData.assessments[id] = data;
+                    }
+                    this.storeData();
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error checking localStorage size', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageCodingService, deps: [{ token: i1.LocalStorageService }, { token: i2.LibCodingTestService }, { token: i3.ConfigurationsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageCodingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageCodingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.LocalStorageService }, { type: i2.LibCodingTestService }, { type: i3.ConfigurationsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.service.js","sourceRoot":"","sources":["../../../../../../packages/tgo-coding-test/src/lib/services/storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { LocalStorageService } from 'ngx-webstorage';\nimport { filter, Subscription } from 'rxjs';\nimport { CodeEditorLanguages } from '../components/code-editor/helpers/code-editor-helper.model';\nimport { AutoSavedData, AutoSavedDataV1, AutoSavedDataV2, QuestionData, TestData } from '../models/auto-saved-data';\nimport { Config } from '../models/configs';\nimport { AssessmentIdPreview } from '../models/lat-languages';\nimport { Modes } from '../models/mode';\nimport { CustomTestCase, ExampleTestCase } from '../models/test-cases';\nimport { ConfigurationsService } from './configurations.service';\nimport { LibCodingTestService } from './lib-coding-test.service';\nimport { timeToMs } from '../utils/time-to-ms.util';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StorageCodingService {\n  private readonly CURRENT_STORAGE_VERSION = 2;\n  private autoSavedData: AutoSavedData = {\n    version: this.CURRENT_STORAGE_VERSION,\n    config: {} as Config,\n    isFullscreen: false,\n    assessments: {},\n    lastModified: Date.now(),\n  };\n  private readonly key = 'savedData';\n  private assessmentId: string;\n  private questionId: string;\n  private language: CodeEditorLanguages;\n  private codeSaveEnabled: boolean;\n  private testCasesSaveEnabled: boolean;\n  private isLAT: boolean;\n  private currentMode: Modes;\n  private isPreview: boolean;\n  private codeChangeSubscription: Subscription;\n  private configSubscription: Subscription;\n  private isFullscreenSubscription: Subscription;\n  private currentLanguageSubscription: Subscription;\n  private isCodeComponentAlive = filter(() => !this.configurationsService.getCodeComponentDestroyed());\n\n  // Maximum age of entire storage data in days\n  private readonly MAX_STORAGE_AGE_DAYS = 7;\n  // Maximum age for assessment inner data in days\n  private readonly MAX_QUESTION_DATA_AGE_DAYS = 1;\n  // Maximum number of assessments to keep\n  private readonly MAX_ASSESSMENTS = 10;\n  // The default question ID used for migrated v1 data\n  private readonly DEFAULT_MIGRATION_QUESTION_ID = 'default-question';\n\n  // todo: remove\n  // storage = {\n  //   retrieve: (key: string) => {\n  //     return {} as any;\n  //   },\n  //   store: (key: string, value: any) => {\n  //     return {} as any;\n  //   },\n  //   clear: (key: string) => {\n  //     return {} as any;\n  //   },\n  // };\n\n  constructor(\n    // todo\n    private storage: LocalStorageService,\n    private libCodingTestService: LibCodingTestService,\n    private configurationsService: ConfigurationsService\n  ) {\n    // Perform safety check on localStorage data\n    this.performStorageSafetyCheck();\n  }\n\n  /**\n   * Performs a safety check on localStorage data.\n   * This is called at service initialization to ensure data integrity.\n   */\n  private performStorageSafetyCheck(): void {\n    try {\n      const savedData = this.storage.retrieve(this.key);\n\n      // If no data, nothing to check\n      if (!savedData) {\n        return;\n      }\n\n      // Check storage format and migrate if needed\n      if (!('version' in savedData)) {\n        // It's v1 format, so we'll migrate it when it's actually needed\n        // No need to do anything right now\n      } else {\n        // It's v2 format, so we can perform cleanup right away\n        this.autoSavedData = savedData as AutoSavedData;\n      }\n    } catch (error) {\n      // If any error occurs during safety check, reset storage to avoid issues\n      console.error('Error during storage safety check, resetting storage:', error);\n      this.autoSavedData = {\n        version: this.CURRENT_STORAGE_VERSION,\n        config: {} as Config,\n        isFullscreen: false,\n        assessments: {},\n        lastModified: Date.now(),\n      };\n      this.storeData();\n    }\n  }\n\n  initializeSaving(): void {\n    if (!this.codeChangeSubscription) {\n      this.codeChangeSubscription = this.libCodingTestService.codeChange$\n        .pipe(this.isCodeComponentAlive)\n        .subscribe((code: string) => {\n          if (this.codeSaveEnabled && this.assessmentId && this.questionId) {\n            this.ensureDataStructure();\n            const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];\n            const targetTestData = this.isPreview ? questionData.preview : questionData.actual;\n            targetTestData.code[this.language] = code!;\n            this.updateLastModified(targetTestData);\n            this.storeData();\n          }\n        });\n    }\n\n    if (!this.configSubscription) {\n      this.configSubscription = this.configurationsService.config$\n        .pipe(this.isCodeComponentAlive)\n        .subscribe((config: Config) => {\n          this.autoSavedData.config = { ...config };\n          this.updateLastModified(this.autoSavedData);\n          this.storeData();\n        });\n    }\n\n    if (!this.isFullscreenSubscription) {\n      this.isFullscreenSubscription = this.libCodingTestService.isFullscreen$\n        .pipe(this.isCodeComponentAlive)\n        .subscribe((isFullscreen: boolean) => {\n          this.autoSavedData.isFullscreen = isFullscreen;\n          this.updateLastModified(this.autoSavedData);\n          this.storeData();\n        });\n    }\n\n    if (!this.currentLanguageSubscription && this.isLAT) {\n      this.currentLanguageSubscription = this.libCodingTestService.currentLanguage$\n        .pipe(this.isCodeComponentAlive)\n        .subscribe((language: CodeEditorLanguages) => {\n          this.autoSavedData.lastLanguageLAT = {\n            value: language,\n            version: this.libCodingTestService.getVersion(),\n          };\n          this.updateLastModified(this.autoSavedData);\n          this.storeData();\n        });\n    }\n  }\n\n  setupAutoSavedData(\n    language: CodeEditorLanguages,\n    assessmentId: string,\n    questionId: string,\n    codeSaveEnabled: boolean,\n    testCasesSaveEnabled: boolean,\n    isLAT: boolean,\n    mode: Modes\n  ) {\n    this.language = language;\n    this.assessmentId = assessmentId;\n    this.questionId = questionId;\n    this.codeSaveEnabled = codeSaveEnabled;\n    this.testCasesSaveEnabled = testCasesSaveEnabled;\n    this.isLAT = isLAT;\n    this.currentMode = mode;\n    this.isPreview = mode === Modes.Preview || mode === Modes.NonAssessmentPreview;\n\n    // Get saved data\n    const savedData = this.storage.retrieve(this.key);\n\n    // Handle migration if needed\n    if (savedData) {\n      // Check if it's v1 schema (no version field)\n      if (!('version' in savedData)) {\n        this.migrateFromV1ToV2(savedData as AutoSavedDataV1);\n      } else {\n        this.autoSavedData = savedData as AutoSavedData;\n      }\n\n      // Apply loaded config and fullscreen setting\n      this.configurationsService.setConfig(this.autoSavedData.config);\n      this.libCodingTestService.setFullscreen(this.autoSavedData.isFullscreen);\n    }\n  }\n\n  private migrateFromV1ToV2(v1Data: AutoSavedDataV1): void {\n    // Create a new v2 data structure\n    const v2Data: AutoSavedDataV2 = {\n      version: this.CURRENT_STORAGE_VERSION,\n      config: v1Data.config,\n      isFullscreen: v1Data.isFullscreen,\n      lastLanguageLAT: v1Data.lastLanguageLAT,\n      assessments: {},\n      lastModified: Date.now(),\n    };\n\n    // Migrate assessment data\n    // In v1, assessments were directly mapped to TestData\n    // In v2, we need to organize by questionId\n    for (const [assessmentId, testData] of Object.entries(v1Data.assessments)) {\n      if (assessmentId === AssessmentIdPreview) {\n        continue;\n      }\n\n      // We use a consistent default questionId for migration to ensure backward compatibility\n      const defaultQuestionId = this.DEFAULT_MIGRATION_QUESTION_ID;\n\n      // Initialize the assessment entry if it doesn't exist\n      if (!v2Data.assessments[assessmentId]) {\n        v2Data.assessments[assessmentId] = {};\n      }\n\n      // Create question data with the migrated test data\n      const questionData: QuestionData = {};\n\n      questionData.actual = {\n        ...testData,\n        lastModified: Date.now(),\n      };\n\n      // Set last modified time for the question data\n      questionData.lastModified = Date.now();\n\n      // Add to the v2 structure\n      v2Data.assessments[assessmentId][defaultQuestionId] = questionData;\n    }\n\n    // Update our instance with migrated data\n    this.autoSavedData = { ...v2Data };\n\n    // Save the migrated data\n    this.storeData();\n  }\n\n  private ensureDataStructure(): void {\n    // Make sure assessment exists\n    if (!this.autoSavedData.assessments[this.assessmentId]) {\n      this.autoSavedData.assessments[this.assessmentId] = {};\n    }\n\n    // Make sure question exists\n    if (!this.autoSavedData.assessments[this.assessmentId][this.questionId]) {\n      this.autoSavedData.assessments[this.assessmentId][this.questionId] = {\n        lastModified: Date.now(),\n      };\n    }\n\n    const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];\n\n    // Ensure preview or actual exists based on current mode\n    if (this.isPreview && !questionData.preview) {\n      questionData.preview = {\n        code: {},\n        testCasesLAT: [],\n        lastModified: Date.now(),\n      };\n    } else if (!this.isPreview && !questionData.actual) {\n      questionData.actual = {\n        code: {},\n        testCasesLAT: [],\n        lastModified: Date.now(),\n      };\n    }\n  }\n\n  private updateLastModified(data: TestData | QuestionData | AutoSavedData): void {\n    const now = Date.now();\n    data.lastModified = now;\n\n    // If updating a TestData, also update its parent QuestionData\n    if ('code' in data && this.assessmentId && this.questionId) {\n      this.autoSavedData.assessments[this.assessmentId][this.questionId].lastModified = now;\n    }\n\n    // Always update root timestamp regardless of the object being modified\n    this.autoSavedData.lastModified = now;\n  }\n\n  /**\n   * Cleanup with a temporary age threshold\n   * @param maxAgeDays Maximum age in days for data to be considered valid\n   */\n  private cleanupWithReducedThreshold(maxAgeDays: number): void {\n    // Call the unified cleanup method with more aggressive parameters\n    this.cleanupStorageData({\n      storageAgeMultiplier: 2, // More aggressive multiplier\n      customStorageAgeDays: maxAgeDays, // Use the provided custom age\n      minQuestionDataAgeDays: 0.5, // 12 hours minimum\n      assessmentLimitMultiplier: 0.5, // Half the normal assessment limit\n    });\n  }\n\n  /**\n   * Unified method to clean up localStorage data with configurable intensity\n   * @param options Cleanup options to control the aggressiveness of the cleanup\n   */\n  private cleanupStorageData(options: {\n    storageAgeMultiplier?: number; // Multiplier for storage age threshold (default: 1)\n    customStorageAgeDays?: number; // Custom storage age in days (overrides MAX_STORAGE_AGE_DAYS if provided)\n    useStandardQuestionDataAge?: boolean; // Whether to use standard question data age (default: false)\n    minQuestionDataAgeDays?: number; // Minimum age for question data in days (default: 0.5 - 12 hours)\n    assessmentLimitMultiplier?: number; // Multiplier for maximum assessments (default: 1)\n  }): void {\n    const now = Date.now();\n\n    // Determine the storage age threshold\n    const storageAgeDays = options.customStorageAgeDays ?? this.MAX_STORAGE_AGE_DAYS;\n    const storageAgeThreshold = timeToMs(storageAgeDays); // Convert days to milliseconds\n    const multiplier = options.storageAgeMultiplier ?? 1;\n\n    // Check if the entire storage is too old and needs cleanup\n    if (this.autoSavedData.lastModified && now - this.autoSavedData.lastModified > storageAgeThreshold * multiplier) {\n      // If the entire storage is very old, just reset everything\n      this.autoSavedData = {\n        version: this.CURRENT_STORAGE_VERSION,\n        config: this.autoSavedData.config, // Keep the config settings\n        isFullscreen: this.autoSavedData.isFullscreen, // Keep fullscreen setting\n        assessments: {},\n        lastModified: now,\n      };\n      this.storeData();\n      return;\n    }\n\n    // Structure for collecting assessment data with metadata\n    interface AssessmentMetadata {\n      id: string;\n      lastModified: number;\n    }\n\n    const assessmentMetadata: AssessmentMetadata[] = [];\n\n    // Determine the question data age threshold\n    let questionDataAgeThreshold: number;\n    if (options.useStandardQuestionDataAge) {\n      // Use the standard threshold for normal cleanup\n      questionDataAgeThreshold = timeToMs(this.MAX_QUESTION_DATA_AGE_DAYS);\n    } else {\n      // For maintenance/aggressive cleanup, use a custom threshold\n      const minAgeHours = (options.minQuestionDataAgeDays ?? 0.5) * 24; // Convert days to hours\n      questionDataAgeThreshold = Math.max(\n        timeToMs(this.MAX_QUESTION_DATA_AGE_DAYS), // Standard age in milliseconds\n        timeToMs(minAgeHours, 'hours') // Minimum age in milliseconds\n      );\n    }\n\n    // Collect assessments with their latest modification times\n    for (const [assessmentId, questions] of Object.entries(this.autoSavedData.assessments)) {\n      let assessmentLastModified = 0;\n\n      // Check all questions in this assessment\n      let hasValidQuestions = false;\n\n      for (const [questionId, questionData] of Object.entries(questions)) {\n        // Skip if undefined\n        if (!questionData) {\n          continue;\n        }\n\n        // Get the latest modification time from preview and actual\n        const previewTime = questionData.preview?.lastModified || 0;\n        const actualTime = questionData.actual?.lastModified || 0;\n        const questionLastModified = Math.max(previewTime, actualTime, questionData.lastModified || 0);\n\n        // Check if data is too old - using configured threshold\n        const isPreviewTooOld = previewTime > 0 && now - previewTime > questionDataAgeThreshold;\n        const isActualTooOld = actualTime > 0 && now - actualTime > questionDataAgeThreshold;\n\n        // Clean up old data within the question\n        if (isPreviewTooOld && questionData.preview) {\n          delete questionData.preview;\n        }\n\n        if (isActualTooOld && questionData.actual) {\n          delete questionData.actual;\n        }\n\n        // If neither preview nor actual exists, remove the question\n        if (!questionData.preview && !questionData.actual) {\n          delete questions[questionId];\n        } else {\n          hasValidQuestions = true;\n          assessmentLastModified = Math.max(assessmentLastModified, questionLastModified);\n        }\n      }\n\n      // If no valid questions, remove the assessment\n      if (!hasValidQuestions) {\n        delete this.autoSavedData.assessments[assessmentId];\n      } else {\n        // Add to our list for potential size-based cleanup\n        assessmentMetadata.push({\n          id: assessmentId,\n          lastModified: assessmentLastModified,\n        });\n      }\n    }\n\n    // Determine the assessment limit based on the multiplier\n    const limitMultiplier = options.assessmentLimitMultiplier ?? 1;\n    const assessmentLimit = Math.ceil(this.MAX_ASSESSMENTS * limitMultiplier);\n\n    // If we have too many assessments, remove the oldest ones\n    if (assessmentMetadata.length > assessmentLimit) {\n      // Sort by lastModified (most recent first)\n      assessmentMetadata.sort((a, b) => b.lastModified - a.lastModified);\n\n      // Remove oldest assessments that exceed our limit\n      for (let i = assessmentLimit; i < assessmentMetadata.length; i++) {\n        delete this.autoSavedData.assessments[assessmentMetadata[i].id];\n      }\n    }\n\n    // Save the cleaned data\n    this.storeData();\n  }\n\n  changeLanguage(language: CodeEditorLanguages) {\n    this.language = language;\n  }\n\n  /**\n   * Gets data from v1 schema format\n   * Used for backward compatibility when retrieving data\n   */\n  private getDataFromV1Schema(retrievedData: AutoSavedDataV1): string | (ExampleTestCase | CustomTestCase)[] | null | undefined {\n    // For v1, we need to handle the case where we don't have questionId\n    // We're now using questionId in the app, but stored data might still be in v1 format\n\n    // For preview data, the assessment ID would be AssessmentIdPreview\n    if (this.assessmentId === AssessmentIdPreview) {\n      if (this.isPreview) {\n        // For preview mode on preview assessment, get the code directly\n        const code = retrievedData.assessments[this.assessmentId]?.code;\n        if (code && this.language in code) {\n          return code[this.language];\n        }\n      }\n      // We don't expect actual/non-preview data for AssessmentIdPreview\n      return null;\n    } else {\n      // For regular assessments, v1 only had code in the \"actual\" section\n      if (!this.isPreview) {\n        const code = retrievedData.assessments[this.assessmentId]?.code;\n        if (code && this.language in code) {\n          return code[this.language];\n        }\n      }\n      // We don't have preview data for regular assessments in v1\n      return null;\n    }\n  }\n\n  getSavedCode(): string | null | undefined {\n    const retrievedData = this.retrieveData();\n    if (!retrievedData) {\n      return null;\n    }\n\n    // Check if using v2 schema\n    if ('version' in retrievedData) {\n      // Handle v2 schema\n      const v2Data = retrievedData;\n      const assessmentData = v2Data.assessments[this.assessmentId];\n\n      if (!assessmentData) {\n        return null;\n      }\n\n      // First try with provided questionId\n      if (this.questionId && assessmentData[this.questionId]) {\n        const questionData = assessmentData[this.questionId];\n        const testData = this.isPreview ? questionData.preview : questionData.actual;\n        if (testData?.code && this.language in testData.code) {\n          return testData.code[this.language];\n        }\n      }\n\n      if (\n        this.questionId !== this.DEFAULT_MIGRATION_QUESTION_ID &&\n        assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID]\n      ) {\n        const questionData = assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID];\n        const testData = this.isPreview ? questionData.preview : questionData.actual;\n        if (testData?.code && this.language in testData.code) {\n          return testData.code[this.language];\n        }\n      }\n\n      return null;\n    } else {\n      // Handle v1 schema for backward compatibility\n      return this.getDataFromV1Schema(retrievedData) as string;\n    }\n  }\n\n  getLastLanguageLAT(): {\n    value: CodeEditorLanguages;\n    version: string;\n  } | null {\n    const retrievedData = this.retrieveData();\n    if (!retrievedData) {\n      return null;\n    }\n\n    return retrievedData.lastLanguageLAT || null;\n  }\n\n  getSavedTestCases(): (ExampleTestCase | CustomTestCase)[] | null | undefined {\n    const retrievedData = this.retrieveData();\n    if (!retrievedData) {\n      return null;\n    }\n\n    // Check if using v2 schema\n    if ('version' in retrievedData) {\n      // Handle v2 schema\n      const v2Data = retrievedData;\n      const assessmentData = v2Data.assessments[this.assessmentId];\n\n      if (!assessmentData) {\n        return null;\n      }\n\n      // First try with provided questionId\n      if (this.questionId && assessmentData[this.questionId]) {\n        const questionData = assessmentData[this.questionId];\n        const testData = this.isPreview ? questionData.preview : questionData.actual;\n        if (testData?.testCasesLAT) {\n          return testData.testCasesLAT;\n        }\n      }\n\n      // If not found and questionId != DEFAULT_MIGRATION_QUESTION_ID,\n      // also try with the default migration ID as a fallback\n      if (\n        this.questionId !== this.DEFAULT_MIGRATION_QUESTION_ID &&\n        assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID]\n      ) {\n        const questionData = assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID];\n        const testData = this.isPreview ? questionData.preview : questionData.actual;\n        if (testData?.testCasesLAT) {\n          return testData.testCasesLAT;\n        }\n      }\n\n      return null;\n    } else {\n      // Handle v1 schema test cases (test cases were only in the actual mode)\n      const v1Data = retrievedData;\n      if (!this.isPreview && v1Data.assessments[this.assessmentId]?.testCasesLAT) {\n        return v1Data.assessments[this.assessmentId].testCasesLAT;\n      }\n      return null;\n    }\n  }\n\n  getSavedConfig(): Config | null {\n    const retrievedData = this.retrieveData();\n    return retrievedData?.config ? { ...retrievedData.config } : null;\n  }\n\n  getSavedFullScreenMode(): boolean | null {\n    const retrievedData = this.retrieveData();\n    return retrievedData?.isFullscreen !== undefined ? retrievedData.isFullscreen : null;\n  }\n\n  clearSavedCode(): void {\n    this.ensureDataStructure();\n    const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];\n    const targetTestData = this.isPreview ? [questionData.preview] : [questionData.preview, questionData.actual];\n\n    let hasChanged = false;\n    targetTestData.forEach(testData => {\n      if (testData) {\n        testData.code = {};\n        this.updateLastModified(testData);\n        hasChanged = true;\n      }\n    });\n    if (hasChanged) {\n      this.storeData();\n    }\n  }\n\n  clearLastLang(): void {\n    this.autoSavedData.lastLanguageLAT = null;\n    this.updateLastModified(this.autoSavedData);\n    this.storeData();\n  }\n\n  clearSavedTestCases(): void {\n    this.ensureDataStructure();\n    const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];\n    const targetTestData = this.isPreview ? questionData.preview : questionData.actual;\n\n    if (targetTestData) {\n      const hasNoCode = !Object.keys(targetTestData.code ?? {}).length;\n\n      if (this.isPreview) {\n        targetTestData.testCasesLAT = [];\n        this.updateLastModified(targetTestData);\n      } else if (hasNoCode) {\n        const allQuestions = this.autoSavedData.assessments[this.assessmentId];\n        delete allQuestions[this.questionId];\n        this.autoSavedData.assessments[this.assessmentId] = { ...allQuestions };\n        this.updateLastModified(this.autoSavedData);\n      }\n      this.storeData();\n    }\n  }\n\n  updateVersion(version: string): void {\n    if (this.autoSavedData.lastLanguageLAT) {\n      this.autoSavedData.lastLanguageLAT.version = version;\n      this.updateLastModified(this.autoSavedData);\n      this.storeData();\n    }\n  }\n\n  updateTestCases(testCases: (ExampleTestCase | CustomTestCase)[]) {\n    if (this.assessmentId && this.questionId && this.testCasesSaveEnabled) {\n      this.ensureDataStructure();\n      const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];\n      const targetTestData = this.isPreview ? questionData.preview : questionData.actual;\n\n      if (targetTestData) {\n        targetTestData.testCasesLAT = testCases;\n        this.updateLastModified(targetTestData);\n        this.storeData();\n      }\n    }\n  }\n\n  private storeData(): void {\n    this.storage.store(this.key, this.autoSavedData);\n  }\n\n  private retrieveData(): AutoSavedData | AutoSavedDataV1 {\n    return this.storage.retrieve(this.key) as AutoSavedData | AutoSavedDataV1;\n  }\n\n  /**\n   * Manually triggers data cleanup and migration.\n   * Useful for handling large localStorage or migration when needed.\n   * This can be called from application startup or after major events.\n   */\n  performMaintenanceAndCleanup(): void {\n    // Get current data\n    const savedData = this.storage.retrieve(this.key);\n\n    // If no data, nothing to do\n    if (!savedData) {\n      return;\n    }\n\n    // Check if migration needed\n    if (!('version' in savedData)) {\n      this.migrateFromV1ToV2(savedData as AutoSavedDataV1);\n    } else {\n      // Already migrated, just perform cleanup\n      this.autoSavedData = savedData as AutoSavedData;\n\n      // Perform a more aggressive cleanup for manual maintenance\n      // by temporarily modifying the cleanup thresholds\n      const originalMaxAge = this.MAX_STORAGE_AGE_DAYS;\n      const halfAge = Math.floor(originalMaxAge / 2); // Cut threshold in half\n\n      // Create a custom cleanup function with reduced threshold\n      this.cleanupWithReducedThreshold(halfAge);\n    }\n\n    // Verify localStorage size is manageable\n    try {\n      const serializedData = JSON.stringify(this.autoSavedData);\n      const sizeInKB = Math.round(serializedData.length / 1024);\n\n      // If data is too large (over 2MB), perform more aggressive cleanup\n      if (sizeInKB > 2048) {\n        console.warn(`Local storage data is large (${sizeInKB}KB), performing deep cleanup`);\n\n        // Use extremely aggressive cleanup settings\n        this.cleanupStorageData({\n          storageAgeMultiplier: 0.5, // Even more aggressive - half the normal age\n          minQuestionDataAgeDays: 0.25, // 6 hours minimum\n          assessmentLimitMultiplier: 0.2, // Keep only 20% of assessments\n        });\n\n        // If still too large, keep only a few most recent assessments\n        const newSerializedData = JSON.stringify(this.autoSavedData);\n        const newSizeInKB = Math.round(newSerializedData.length / 1024);\n\n        if (newSizeInKB > 1024) {\n          // Keep only recent assessments\n          const assessments = this.autoSavedData.assessments;\n          // Find the newest timestamp in each assessment\n          const getNewestTimestamp = (obj: Record<string, QuestionData>) =>\n            Object.values(obj).reduce((max, questionData) => Math.max(max, questionData?.lastModified || 0), 0);\n          const entries = Object.entries(assessments).sort(\n            ([, a], [, b]) =>\n              getNewestTimestamp(b as Record<string, QuestionData>) -\n              getNewestTimestamp(a as Record<string, QuestionData>)\n          );\n\n          // Keep only the 5 most recent assessments\n          const keepCount = Math.min(5, entries.length);\n          this.autoSavedData.assessments = {};\n\n          for (let i = 0; i < keepCount; i++) {\n            const [id, data] = entries[i];\n            this.autoSavedData.assessments[id] = data as Record<string, QuestionData>;\n          }\n\n          this.storeData();\n        }\n      }\n    } catch (error) {\n      console.error('Error checking localStorage size', error);\n    }\n  }\n}\n"]}