@testgorilla/tgo-coding-test 2.0.0 → 2.0.1-beta.1

package/fesm2022/shared/index.mjs

@@ -0,0 +1,834 @@
+import * as i0 from '@angular/core';
+import { signal, computed, Input, ViewEncapsulation, ChangeDetectionStrategy, Component, EventEmitter, inject, ElementRef, Output, HostBinding, Injectable, NgModule } from '@angular/core';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import Player from '@vimeo/player';
+import 'mixpanel-browser';
+import { Observable, throwError, EMPTY, of, delay } from 'rxjs';
+import { TRANSLOCO_SCOPE, TranslocoTestingModule, translate } from '@ngneat/transloco';
+import * as i1$1 from '@angular/common/http';
+import * as i2 from '@testgorilla/tgo-ui';
+import { catchError } from 'rxjs/operators';
+
+class AudioAnimationComponent {
+    volume = 0;
+    fakeData = false;
+    isAnimationRunning = false;
+    animationFrameId = null;
+    lastAnimationUpdate = performance.now();
+    volumeSignal = signal(this.volume);
+    barHeightsSignal = computed(() => this.getBarHeights(this.volumeSignal()));
+    constructor() {
+        this.startAnimation();
+    }
+    ngOnChanges() {
+        this.volumeSignal.set(this.normalizeRealVolume(this.volume));
+        if (this.fakeData) {
+            this.startAnimation();
+        }
+        else {
+            this.stopAnimation();
+        }
+    }
+    normalizeRealVolume(originalVolume) {
+        return Math.min(1, originalVolume * 10);
+    }
+    startAnimation() {
+        if (this.isAnimationRunning) {
+            return;
+        }
+        this.isAnimationRunning = true;
+        const animate = (timestamp) => {
+            if (!this.isAnimationRunning) {
+                return;
+            }
+            if (timestamp - this.lastAnimationUpdate > 200) {
+                this.lastAnimationUpdate = timestamp;
+                const newVolume = Math.random() * 0.8 + 0.2;
+                this.volumeSignal.set(newVolume);
+            }
+            this.animationFrameId = requestAnimationFrame(animate);
+        };
+        this.animationFrameId = requestAnimationFrame(animate);
+    }
+    stopAnimation() {
+        this.isAnimationRunning = false;
+        if (this.animationFrameId) {
+            cancelAnimationFrame(this.animationFrameId);
+            this.animationFrameId = null;
+        }
+    }
+    getBarHeights(volume) {
+        if (!this.fakeData && volume < 0.15) {
+            return {
+                'first-bar': `42%`,
+                'second-bar': `42%`,
+                'third-bar': `42%`,
+            };
+        }
+        let range;
+        this.fakeData
+            ? (range = this.getFakeVolumeRange(volume))
+            : (range = this.getRealVolumeRange(volume));
+        const randomHeight = this.getRandomHeight(range.min, range.max);
+        return {
+            'first-bar': `${randomHeight}%`,
+            'second-bar': `${randomHeight + 30}%`,
+            'third-bar': `${randomHeight}%`,
+        };
+    }
+    getFakeVolumeRange(volume) {
+        if (volume < 0.33) {
+            return { min: 60, max: 90 };
+        }
+        else if (volume < 0.66) {
+            return { min: 90, max: 120 };
+        }
+        else {
+            return { min: 120, max: 140 };
+        }
+    }
+    getRealVolumeRange(volume) {
+        if (volume < 0.45) {
+            return { min: 90, max: 90 };
+        }
+        else if (volume < 0.6) {
+            return { min: 110, max: 110 };
+        }
+        else if (volume < 0.75) {
+            return { min: 125, max: 125 };
+        }
+        else {
+            return { min: 140, max: 140 };
+        }
+    }
+    getRandomHeight(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    ngOnDestroy() {
+        this.stopAnimation();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: AudioAnimationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.17", type: AudioAnimationComponent, isStandalone: true, selector: "tgo-audio-animation", inputs: { volume: "volume", fakeData: "fakeData" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"audio-animation-wrapper\">\n  <section class=\"audio-animation-container\">\n    <div\n      class=\"sound-bar first-bar\"\n      [ngStyle]=\"{ height: barHeightsSignal()['first-bar'] }\"\n    ></div>\n    <div\n      class=\"sound-bar second-bar\"\n      [ngStyle]=\"{ height: barHeightsSignal()['second-bar'] }\"\n    ></div>\n    <div\n      class=\"sound-bar third-bar\"\n      [ngStyle]=\"{ height: barHeightsSignal()['third-bar'] }\"\n    ></div>\n  </section>\n</div>\n\n", styles: [".audio-animation-wrapper{display:flex;justify-content:center;align-items:center}.audio-animation-wrapper .audio-animation-container{display:flex;justify-content:space-between;align-items:center;width:32px;height:24px;background-color:#4285f4;border-radius:25px;padding:5px 6.5px;box-shadow:0 4px 10px #0000001a}.audio-animation-wrapper .audio-animation-container .sound-bar{width:4px;background-color:#fff;height:20%;transition:height .2s ease-in-out;clip-path:ellipse(45% 30% at 50% 50%)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: AudioAnimationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tgo-audio-animation', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [CommonModule], template: "<div class=\"audio-animation-wrapper\">\n  <section class=\"audio-animation-container\">\n    <div\n      class=\"sound-bar first-bar\"\n      [ngStyle]=\"{ height: barHeightsSignal()['first-bar'] }\"\n    ></div>\n    <div\n      class=\"sound-bar second-bar\"\n      [ngStyle]=\"{ height: barHeightsSignal()['second-bar'] }\"\n    ></div>\n    <div\n      class=\"sound-bar third-bar\"\n      [ngStyle]=\"{ height: barHeightsSignal()['third-bar'] }\"\n    ></div>\n  </section>\n</div>\n\n", styles: [".audio-animation-wrapper{display:flex;justify-content:center;align-items:center}.audio-animation-wrapper .audio-animation-container{display:flex;justify-content:space-between;align-items:center;width:32px;height:24px;background-color:#4285f4;border-radius:25px;padding:5px 6.5px;box-shadow:0 4px 10px #0000001a}.audio-animation-wrapper .audio-animation-container .sound-bar{width:4px;background-color:#fff;height:20%;transition:height .2s ease-in-out;clip-path:ellipse(45% 30% at 50% 50%)}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { volume: [{
+                type: Input
+            }], fakeData: [{
+                type: Input
+            }] } });
+
+class VimeoVideoComponent {
+    class = 'tgo-vimeo-video';
+    videoUrl = '';
+    isPlaying = false;
+    options = {
+        controls: false,
+        autoplay: false,
+        loop: false,
+        speed: true,
+        title: false,
+        byline: false,
+        quality: 'auto',
+        autopause: false,
+    };
+    videoEnded = new EventEmitter();
+    videoStarted = new EventEmitter();
+    vimeoPlayer;
+    elRef = inject(ElementRef);
+    async ngOnInit() {
+        await this.configureVimeoPlayer();
+    }
+    async ngOnDestroy() {
+        await this.removeVimeoPlayer();
+    }
+    async ngOnChanges(simpleChanges) {
+        if (this.vimeoPlayer) {
+            if (simpleChanges['videoUrl'] && this.videoUrl) {
+                await this.vimeoPlayer.loadVideo(this.videoUrl);
+                await this.playVideo();
+            }
+            if (simpleChanges['isPlaying']) {
+                if (this.isPlaying) {
+                    await this.vimeoPlayer.play();
+                }
+                else {
+                    await this.vimeoPlayer.pause();
+                }
+            }
+        }
+    }
+    async removeVimeoPlayer() {
+        if (this.vimeoPlayer) {
+            await this.vimeoPlayer.destroy();
+        }
+    }
+    async configureVimeoPlayer() {
+        const options = {
+            ...this.options,
+            url: this.videoUrl,
+        };
+        try {
+            await this.removeVimeoPlayer();
+            this.vimeoPlayer = new Player(this.elRef.nativeElement, options);
+            this.vimeoPlayer.on('ended', () => {
+                this.videoEnded.emit();
+                this.isPlaying = false;
+                this.vimeoPlayer?.pause();
+            });
+            this.vimeoPlayer.on('playing', () => {
+                this.videoStarted.emit();
+            });
+            this.vimeoPlayer.on('pause', (event) => {
+                if (this.isPlaying && event.percent < 1) {
+                    this.vimeoPlayer?.play();
+                }
+            });
+            await this.playVideo();
+        }
+        catch (error) {
+            await this.removeVimeoPlayer();
+            throw error;
+        }
+    }
+    async playVideo() {
+        if (this.vimeoPlayer && this.isPlaying) {
+            await this.vimeoPlayer.play();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: VimeoVideoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.17", type: VimeoVideoComponent, isStandalone: true, selector: "tgo-vimeo-video", inputs: { videoUrl: "videoUrl", isPlaying: "isPlaying", options: "options" }, outputs: { videoEnded: "videoEnded", videoStarted: "videoStarted" }, host: { properties: { "class": "this.class" } }, usesOnChanges: true, ngImport: i0, template: '', isInline: true, styles: [".tgo-vimeo-video iframe{position:absolute;top:0;left:0;width:100%;height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: VimeoVideoComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tgo-vimeo-video', template: '', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, standalone: true, styles: [".tgo-vimeo-video iframe{position:absolute;top:0;left:0;width:100%;height:100%}\n"] }]
+        }], propDecorators: { class: [{
+                type: HostBinding
+            }], videoUrl: [{
+                type: Input
+            }], isPlaying: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], videoEnded: [{
+                type: Output
+            }], videoStarted: [{
+                type: Output
+            }] } });
+
+const ROOT_TRANSLATIONS_SCOPE = 'TEST';
+
+class MediaService {
+    mediaRecorder = null;
+    selectedMediaDevices;
+    isRecording = signal(false);
+    stopRecording() {
+        this.mediaRecorder?.stop();
+    }
+    getMediaStream(data) {
+        return navigator.mediaDevices.getUserMedia(this.getMediaStreamConstraints(data));
+    }
+    recordAudio() {
+        let checkPermissionPromise;
+        return new Observable((observer) => {
+            void this.getMediaStream({ video: false, audio: true })
+                .then((stream) => {
+                this.mediaRecorder = new MediaRecorder(stream);
+                this.mediaRecorder.start();
+                this.isRecording.set(true);
+                const audioChunks = [];
+                this.mediaRecorder.ondataavailable = (event) => {
+                    audioChunks.push(event.data);
+                };
+                this.mediaRecorder.addEventListener('stop', () => {
+                    const audioBlob = new Blob(audioChunks, {
+                        type: 'audio/mp3',
+                    });
+                    observer.next({ type: 'complete', file: audioBlob });
+                    this.isRecording.set(false);
+                    observer.complete();
+                });
+                this.mediaRecorder.onerror = (error) => {
+                    observer.error(error);
+                    observer.complete();
+                };
+                const audioContext = new AudioContext();
+                const mediaStreamAudioSourceNode = audioContext.createMediaStreamSource(stream);
+                const analyserNode = audioContext.createAnalyser();
+                mediaStreamAudioSourceNode.connect(analyserNode);
+                const pcmData = new Float32Array(analyserNode.fftSize);
+                const onFrame = () => {
+                    analyserNode.getFloatTimeDomainData(pcmData);
+                    let sumSquares = 0.0;
+                    for (const amplitude of pcmData) {
+                        sumSquares += amplitude * amplitude;
+                    }
+                    if (sumSquares > 0) {
+                        observer.next({
+                            type: 'volume',
+                            value: Math.sqrt(sumSquares / pcmData.length),
+                        });
+                    }
+                    else {
+                        if (!checkPermissionPromise) {
+                            checkPermissionPromise = this.checkPermission({
+                                video: false,
+                                audio: true,
+                            });
+                            checkPermissionPromise
+                                .then((hasPermission) => {
+                                if (!hasPermission) {
+                                    observer.error(new Error('Permission denied'));
+                                    observer.complete();
+                                }
+                            })
+                                .finally(() => {
+                                checkPermissionPromise = null;
+                            });
+                        }
+                    }
+                    if (!observer.closed) {
+                        window.requestAnimationFrame(onFrame);
+                    }
+                };
+                window.requestAnimationFrame(onFrame);
+            })
+                .catch((error) => {
+                observer.error(error);
+                observer.complete();
+            });
+        });
+    }
+    async playAudio(url) {
+        const audio = new Audio(url);
+        await audio.play();
+        return new Promise((resolve, reject) => {
+            audio.onended = () => {
+                resolve();
+            };
+            audio.onerror = (event) => reject(event);
+        });
+    }
+    setSelectedMediaDevices(data) {
+        this.selectedMediaDevices = data;
+    }
+    async checkPermission(data) {
+        try {
+            await this.getMediaStream(data);
+            return true;
+        }
+        catch (err) {
+            console.error(err);
+            return false;
+        }
+    }
+    getMediaStreamConstraints(data) {
+        const audioDeviceID = this.selectedMediaDevices?.audioDeviceId;
+        const videoDeviceID = this.selectedMediaDevices?.videoDeviceId;
+        return {
+            audio: data.audio && audioDeviceID
+                ? { deviceId: { exact: audioDeviceID } }
+                : data.audio,
+            video: data.video && videoDeviceID
+                ? { deviceId: { exact: videoDeviceID } }
+                : data.video,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MediaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MediaService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MediaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var THEME_VARS;
+(function (THEME_VARS) {
+    THEME_VARS["COMPANY_COLOR"] = "--color-primary-50";
+})(THEME_VARS || (THEME_VARS = {}));
+class ThemeService {
+    BRAND_PINK_COLOR = '#D410AA';
+    getCompanyColor() {
+        return (this.getCSSVariableValue(THEME_VARS.COMPANY_COLOR) ||
+            this.BRAND_PINK_COLOR);
+    }
+    getCSSVariableValue(variableName) {
+        return getComputedStyle(document.documentElement)
+            .getPropertyValue(variableName)
+            .trim();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ThemeService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * The util is based on this issue https://github.com/jsverse/transloco/issues/608#issuecomment-1416113493
+ *
+ * Transloco can't have several forRoot modules. so the only way for now to decouple translations as a separate file and context
+ * from the shell (TAS in this case) is to use TRANSLOCO_SCOPE
+ */
+class TranslocoLazyModuleUtils {
+    static createInlineLoader(languages, loaderFn) {
+        const translocoInlineLoader = {};
+        languages.forEach((language) => {
+            translocoInlineLoader[language] = () => loaderFn(language);
+        });
+        return translocoInlineLoader;
+    }
+    static getScopeProvider(scope, languages, alias, loaderFn) {
+        return {
+            provide: TRANSLOCO_SCOPE,
+            useValue: {
+                scope,
+                alias,
+                loader: this.createInlineLoader(languages, loaderFn),
+            },
+        };
+    }
+}
+
+//Languages available in the app as enum
+var Language;
+(function (Language) {
+    Language["en"] = "en";
+    Language["es"] = "es";
+    Language["nl"] = "nl";
+    Language["fr"] = "fr";
+    Language["de"] = "de";
+    Language["it-it"] = "it-it";
+    Language["ja-jp"] = "ja-jp";
+    Language["pt-br"] = "pt-br";
+    Language["da-dk"] = "da-dk";
+    Language["nb-no"] = "nb-no";
+    Language["pl-pl"] = "pl-pl";
+    Language["sv-se"] = "sv-se";
+})(Language || (Language = {}));
+//This function retrieves all languages from the enum. It is used to initialize transloco
+const getAvailableLangs = () => Object.values(Language);
+
+const getTranslocoModule = (options = {}) => TranslocoTestingModule.forRoot({
+    translocoConfig: {
+        reRenderOnLangChange: false,
+        availableLangs: ['en'],
+        defaultLang: 'en',
+    },
+    preloadLangs: true,
+    ...options,
+});
+
+class ApiService {
+    httpClient;
+    snackbarService;
+    invitationUUID = '';
+    contentLanguage = '';
+    ROOT_TRANSLATIONS_SCOPE = '';
+    baseUrl = '';
+    constructor(httpClient, snackbarService) {
+        this.httpClient = httpClient;
+        this.snackbarService = snackbarService;
+    }
+    setParams(invitationUUID, contentLanguage, translationScope, baseUrl) {
+        this.invitationUUID = invitationUUID;
+        this.contentLanguage = contentLanguage;
+        this.ROOT_TRANSLATIONS_SCOPE = translationScope;
+        this.baseUrl = baseUrl;
+    }
+    getInvitationUUID() {
+        return this.invitationUUID;
+    }
+    get(url, options = {}, errorCallback = this.handleError.bind(this)) {
+        return this.httpClient
+            .get(`${this.baseUrl}${url}`, this.buildHeaders(options))
+            .pipe(catchError((error) => errorCallback(error)));
+    }
+    post(url, data, options = {}, errorCallback = this.handleError.bind(this), isStandaloneUrl = false) {
+        return this.httpClient
+            .post(isStandaloneUrl ? url : `${this.baseUrl}${url}`, data, this.buildHeaders(options))
+            .pipe(catchError((error) => errorCallback(error)));
+    }
+    put(url, data, options = {}, errorCallback = this.handleError.bind(this)) {
+        return this.httpClient
+            .put(`${this.baseUrl}${url}`, data, this.buildHeaders(options))
+            .pipe(catchError((error) => errorCallback(error)));
+    }
+    patch(url, data, options = {}, errorCallback = this.handleError.bind(this)) {
+        return this.httpClient
+            .patch(`${this.baseUrl}${url}`, data, this.buildHeaders(options))
+            .pipe(catchError((error) => errorCallback(error)));
+    }
+    delete(url, errorCallback = this.handleError.bind(this)) {
+        return this.httpClient
+            .delete(`${this.baseUrl}${url}`, this.buildHeaders({}))
+            .pipe(catchError((error) => errorCallback(error)));
+    }
+    handleError(errorObj) {
+        const { error } = errorObj;
+        if (error?.errors?.length > 0) {
+            return throwError(() => error.errors);
+        }
+        else {
+            console.error(errorObj.message);
+            this.snackbarService.error(this.processGenericServerError());
+            return EMPTY;
+        }
+    }
+    processGenericServerError() {
+        return translate(`${this.ROOT_TRANSLATIONS_SCOPE}.ERRORS.SYSTEM_ERROR`);
+    }
+    buildHeaders(options) {
+        if (typeof window.crypto.randomUUID === 'function') {
+            options = {
+                ...options,
+                'X-REQUEST-ID': window.crypto.randomUUID(),
+                'X-INVITATION-UUID': this.invitationUUID,
+            };
+        }
+        const passedAuthorizationHeader = options['Authorization'];
+        const headers = {
+            headers: {
+                ...options,
+                Authorization: passedAuthorizationHeader
+                    ? passedAuthorizationHeader
+                    : `TokenCandidature ${this.invitationUUID?.replace(/-/g, '')}`,
+            },
+        };
+        if (this.contentLanguage) {
+            headers.headers['Accept-Language'] = this.contentLanguage;
+        }
+        return headers;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ApiService, deps: [{ token: i1$1.HttpClient }, { token: i2.SnackbarService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ApiService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }, { type: i2.SnackbarService }] });
+
+/**
+ * MockedApiService provides fake API responses for demo/development purposes.
+ * This service mimics the real ApiService interface but returns mock data instead
+ * of making actual HTTP calls.
+ *
+ * Usage: Provide this service in place of ApiService in your demo application:
+ * ```
+ * { provide: ApiService, useClass: MockedApiService }
+ * ```
+ */
+class MockedApiService {
+    invitationUUID = 'demo-uuid-12345';
+    contentLanguage = 'en';
+    ROOT_TRANSLATIONS_SCOPE = '';
+    // Simulate network delay (in ms) - set to 0 for instant responses
+    MOCK_DELAY = 500;
+    setParams(invitationUUID, contentLanguage, translationScope, baseUrl) {
+        this.invitationUUID = invitationUUID;
+        this.contentLanguage = contentLanguage;
+        this.ROOT_TRANSLATIONS_SCOPE = translationScope;
+        console.log('[MockedApiService] Params set:', {
+            invitationUUID,
+            contentLanguage,
+            translationScope,
+            baseUrl,
+        });
+    }
+    getInvitationUUID() {
+        return this.invitationUUID;
+    }
+    get(url, options = {}, errorCallback) {
+        console.log('[MockedApiService] GET:', url, options);
+        return of(this.getMockResponse(url, 'GET')).pipe(delay(this.MOCK_DELAY));
+    }
+    post(url, data, options = {}, errorCallback, isStandaloneUrl = false) {
+        console.log('[MockedApiService] POST:', url, data, options);
+        return of(this.getMockResponse(url, 'POST', data)).pipe(delay(this.MOCK_DELAY));
+    }
+    put(url, data, options = {}, errorCallback) {
+        console.log('[MockedApiService] PUT:', url, data, options);
+        return of(this.getMockResponse(url, 'PUT', data)).pipe(delay(this.MOCK_DELAY));
+    }
+    patch(url, data, options = {}, errorCallback) {
+        console.log('[MockedApiService] PATCH:', url, data, options);
+        return of(this.getMockResponse(url, 'PATCH', data)).pipe(delay(this.MOCK_DELAY));
+    }
+    delete(url, errorCallback) {
+        console.log('[MockedApiService] DELETE:', url);
+        return of({}).pipe(delay(this.MOCK_DELAY));
+    }
+    /**
+     * Returns mock responses based on the URL pattern
+     */
+    getMockResponse(url, method, data) {
+        // CodeRunner API - Run Tests
+        if (url.includes('/api/attempts/public/')) {
+            return this.getMockCoderunnerAttemptResponse(data);
+        }
+        if (url.includes('/api/attempts/preview/')) {
+            return this.getMockCoderunnerAttemptResponse(data);
+        }
+        if (url.includes('/api/attempts/')) {
+            return this.getMockCoderunnerAttemptResponse(data);
+        }
+        // Code Events
+        if (url.includes('/api/code-events/')) {
+            return {
+                id: Math.floor(Math.random() * 10000),
+                created_at: new Date().toISOString(),
+            };
+        }
+        // Programming Languages
+        if (url.includes('programming-languages')) {
+            return []; // Mock all languages
+        }
+        // Default response
+        console.warn(`[MockedApiService] No mock defined for ${method} ${url}`);
+        return { success: true, data: null };
+    }
+    /**
+     * Returns a mock coderunner attempt response with test results
+     */
+    getMockCoderunnerAttemptResponse(data) {
+        const requestData = data;
+        const testcases = requestData?.testcases || [];
+        // Generate mock results for each test case
+        const results = testcases.map((testcase, index) => {
+            // Make first test pass, others random for variety
+            const passed = index === 0 ? true : Math.random() > 0.3;
+            return {
+                name: testcase.name || `Test Case ${index + 1}`,
+                passed,
+                expected: testcase.solution || testcase.expected_output || 'Expected output',
+                actual: passed
+                    ? testcase.solution || testcase.expected_output || 'Expected output'
+                    : 'Different output',
+                input: testcase.input || '',
+                error: passed ? null : 'AssertionError: Output does not match expected',
+                execution_time: Math.random() * 100,
+                memory_used: Math.floor(Math.random() * 1000000),
+                points: passed ? (testcase.points || 10) : 0,
+            };
+        });
+        const totalPoints = results.reduce((sum, r) => sum + r.points, 0);
+        const maxPoints = testcases.reduce((sum, tc) => sum + (tc.points || 10), 0);
+        return {
+            id: Math.floor(Math.random() * 100000),
+            uuid: crypto.randomUUID(),
+            created_at: new Date().toISOString(),
+            language: requestData?.language || 'python-3.10.0',
+            code: requestData?.code || '',
+            status: 'completed',
+            results,
+            score: maxPoints > 0 ? (totalPoints / maxPoints) * 100 : 0,
+            total_points: totalPoints,
+            max_points: maxPoints,
+            execution_time: results.reduce((sum, r) => sum + r.execution_time, 0),
+            compilation_error: null,
+            runtime_error: null,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MockedApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MockedApiService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MockedApiService, decorators: [{
+            type: Injectable
+        }] });
+
+class EnvironmentService {
+    get isMobile() {
+        return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: EnvironmentService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable
+        }] });
+
+class MixpanelService {
+    mixpanel = null;
+    track(eventName, properties = {}) {
+        if (this.mixpanel) {
+            return this.sendTrackEvent(eventName, properties);
+        }
+        if (window.mixpanel) {
+            this.mixpanel = window.mixpanel;
+            return this.sendTrackEvent(eventName, properties);
+        }
+        console.error('Mixpanel is not initialized or not available');
+    }
+    sendTrackEvent(eventName, properties = {}) {
+        try {
+            this.mixpanel.track(eventName, properties);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MixpanelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MixpanelService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: MixpanelService, decorators: [{
+            type: Injectable
+        }] });
+
+const mockAssessment = {
+    uuid: 'fa67cd96-2a4c-490a-9a44-b11f759f228a',
+    locale: 'en',
+    is_snapshots_enabled: true,
+    has_video_question: false,
+    allow_non_native_speakers: true,
+    allow_other_conditions: true,
+    general_settings: {
+        id: 2157,
+        owner_profile_id: 271652,
+        company_name: 'x',
+        company_color: '#46a997',
+        company_logo: '',
+        company_redirect_url: null,
+        has_requested_demographic_details: true,
+        has_requested_feedback: true,
+        original_modified: '2024-01-16T20:30:04.054308Z',
+    },
+    sharing_results: true,
+};
+const mockQuestion = {
+    id: 747282,
+    text: '<p>Charlie was a flight attendant _______ seven years.</p>',
+    type: 'code',
+    context: {
+        intro_text: null,
+        answers: [
+            {
+                id: 578594,
+                text: '<p>during</p>',
+                answer_uuid: 'cf98b452-2704-44fa-adce-d5d93ad7c643',
+            },
+            {
+                id: 578596,
+                text: '<p>through</p>',
+                answer_uuid: '8e848dc4-a0cf-4c8d-b8d0-42b0fc85b19f',
+            },
+            {
+                id: 578595,
+                text: '<p>after</p>',
+                answer_uuid: '1e97f320-7d22-4dec-8555-1aa8228df131',
+            },
+            {
+                id: 578593,
+                text: '<p>for</p>',
+                answer_uuid: 'ccc648cc-435b-460a-89e8-432d13574e1e',
+            },
+        ],
+        initial_code: null,
+        code_language: null,
+        typing_test_type: null,
+        typing_test_config: null,
+        typing_test_mode: {
+            numbers: false,
+            punctuation: false,
+            funbox: 'none',
+            sentences: false,
+        },
+        long_answer_list: false,
+        max_items: 100,
+        min_items: 0,
+        duration: null,
+        attempts: 0,
+    },
+};
+const mockTestResultRead = {
+    id: 123,
+    test: {
+        id: 1,
+        name: 'test-name',
+        duration: 100,
+        algorithm: 'testAlgorithm',
+    },
+    locale: 'en-EN',
+    order: 1,
+    is_preview_mode: true,
+};
+const mockSQLTestCases = [
+    {
+        category: 'Test Category 1',
+        id: 1,
+        initial_sql: 'Test Initial SQL',
+        name: 'Test Name 1',
+        post_sql: 'Test Post SQL 1',
+        pre_sql: 'Test Pre SQL 1',
+        result: 'Test Result 1',
+    },
+    {
+        category: 'Test Category 2',
+        id: 2,
+        initial_sql: 'Test Initial SQL',
+        name: 'Test Name 2',
+        post_sql: 'Test Post SQL 2',
+        pre_sql: 'Test Pre SQL 2',
+        result: 'Test Result 2',
+    },
+];
+const mockTestCases = [
+    {
+        name: 'Test Case 1',
+        input: 'Test Input 1',
+        solution: 'Test Solution 1',
+        points: 10,
+    },
+    {
+        name: 'Test Case 2',
+        input: 'Test Input 2',
+        solution: 'Test Solution 2',
+        points: 20,
+    },
+];
+
+// Mock modules
+const ButtonComponentModule = NgModule({
+    imports: [CommonModule],
+    declarations: [],
+    exports: [],
+})(class {
+});
+const IconComponentModule = NgModule({
+    imports: [CommonModule],
+    declarations: [],
+    exports: [],
+})(class {
+});
+const CardComponentModule = NgModule({
+    imports: [CommonModule],
+    declarations: [],
+    exports: [],
+})(class {
+});
+const DialogComponentModule = NgModule({
+    imports: [CommonModule],
+    declarations: [],
+    exports: [],
+})(class {
+});
+// Mock DialogService
+class DialogService {
+    open = jest.fn();
+}
+// Mock SnackbarService
+class SnackbarService {
+    error = jest.fn();
+}
+// Export all other potential exports as empty objects
+const QuillViewComponent = class {
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ApiService, AudioAnimationComponent, ButtonComponentModule, CardComponentModule, DialogComponentModule, DialogService, EnvironmentService, IconComponentModule, Language, MediaService, MixpanelService, MockedApiService, QuillViewComponent, ROOT_TRANSLATIONS_SCOPE, SnackbarService, ThemeService, TranslocoLazyModuleUtils, VimeoVideoComponent, getAvailableLangs, getTranslocoModule, mockAssessment, mockQuestion, mockSQLTestCases, mockTestCases, mockTestResultRead };
+//# sourceMappingURL=tgo-coding-test-shared.mjs.map