@testgorilla/tgo-coding-test 0.0.1 → 1.0.0

package/esm2022/shared/lib/services/api/api.service.mjs

@@ -0,0 +1,97 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { translate } from '@ngneat/transloco';
+import { SnackbarService } from '@testgorilla/tgo-ui';
+import { EMPTY, throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@testgorilla/tgo-ui";
+export 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: "18.2.13", ngImport: i0, type: ApiService, deps: [{ token: i1.HttpClient }, { token: i2.SnackbarService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.SnackbarService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../../../../packages/tgo-coding-test/src/shared/lib/services/api/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { translate } from '@ngneat/transloco';\nimport { SnackbarService } from '@testgorilla/tgo-ui';\nimport { EMPTY, Observable, throwError } from 'rxjs';\nimport { catchError } from 'rxjs/operators';\n\n@Injectable()\nexport class ApiService {\n  private invitationUUID = '';\n  private contentLanguage = '';\n  private ROOT_TRANSLATIONS_SCOPE = '';\n  private baseUrl = '';\n\n  constructor(\n    private httpClient: HttpClient,\n    private snackbarService: SnackbarService\n  ) {}\n\n  setParams(\n    invitationUUID: string,\n    contentLanguage: string,\n    translationScope: string,\n    baseUrl: string\n  ): void {\n    this.invitationUUID = invitationUUID;\n    this.contentLanguage = contentLanguage;\n    this.ROOT_TRANSLATIONS_SCOPE = translationScope;\n    this.baseUrl = baseUrl;\n  }\n\n  getInvitationUUID(): string {\n    return this.invitationUUID;\n  }\n\n  get<T>(\n    url: string,\n    options = {},\n    errorCallback = this.handleError.bind(this)\n  ): Observable<T> {\n    return this.httpClient\n      .get<T>(\n        `${this.baseUrl}${url}`,\n        this.buildHeaders(options)\n      )\n      .pipe(catchError((error: HttpErrorResponse) => errorCallback(error))) as Observable<T>;\n  }\n\n  post<T>(\n    url: string,\n    data: object,\n    options = {},\n    errorCallback = this.handleError.bind(this),\n    isStandaloneUrl = false\n  ): Observable<T> {\n    return this.httpClient\n      .post<T>(\n        isStandaloneUrl ? url : `${this.baseUrl}${url}`,\n        data,\n        this.buildHeaders(options)\n      )\n      .pipe(catchError((error: HttpErrorResponse) => errorCallback(error))) as Observable<T>;\n  }\n\n  put<T>(\n    url: string,\n    data: object,\n    options = {},\n    errorCallback = this.handleError.bind(this)\n  ): Observable<T> {\n    return this.httpClient\n      .put<T>(\n        `${this.baseUrl}${url}`,\n        data,\n        this.buildHeaders(options)\n      )\n      .pipe(catchError((error: HttpErrorResponse) => errorCallback(error))) as Observable<T>;\n  }\n\n  patch<T>(\n    url: string,\n    data: object,\n    options = {},\n    errorCallback = this.handleError.bind(this)\n  ): Observable<T> {\n    return this.httpClient\n      .patch<T>(\n        `${this.baseUrl}${url}`,\n        data,\n        this.buildHeaders(options)\n      )\n      .pipe(catchError((error: HttpErrorResponse) => errorCallback(error))) as Observable<T>;\n  }\n\n  delete(\n    url: string,\n    errorCallback = this.handleError.bind(this)\n  ): Observable<object> {\n    return this.httpClient\n      .delete(\n        `${this.baseUrl}${url}`,\n        this.buildHeaders({})\n      )\n      .pipe(catchError((error: HttpErrorResponse) => errorCallback(error))) as Observable<object>;\n  }\n\n  private handleError(errorObj: HttpErrorResponse): Observable<never> {\n    const { error } = errorObj;\n    if (error?.errors?.length > 0) {\n      return throwError(() => error.errors);\n    } else {\n      console.error(errorObj.message);\n      this.snackbarService.error(this.processGenericServerError());\n\n      return EMPTY;\n    }\n  }\n\n  private processGenericServerError(): string {\n    return translate(`${this.ROOT_TRANSLATIONS_SCOPE}.ERRORS.SYSTEM_ERROR`);\n  }\n\n  private buildHeaders(options: object): object {\n    if (typeof window.crypto.randomUUID === 'function') {\n      options = {\n        ...options,\n        'X-REQUEST-ID': window.crypto.randomUUID(),\n        'X-INVITATION-UUID': this.invitationUUID,\n      };\n    }\n\n    const passedAuthorizationHeader = (options as { [key: string]: any })[\n      'Authorization'\n    ];\n    const headers: { headers: { [header: string]: string } } = {\n      headers: {\n        ...options,\n        Authorization: passedAuthorizationHeader\n          ? passedAuthorizationHeader\n          : `TokenCandidature ${this.invitationUUID?.replace(/-/g, '')}`,\n      },\n    };\n\n    if (this.contentLanguage) {\n      headers.headers['Accept-Language'] = this.contentLanguage;\n    }\n\n    return headers;\n  }\n}\n"]}

package/esm2022/shared/lib/services/api/mocked-api.service.mjs

@@ -0,0 +1,131 @@
+import { Injectable } from '@angular/core';
+import { of, delay } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * 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 }
+ * ```
+ */
+export 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: "18.2.13", ngImport: i0, type: MockedApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MockedApiService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MockedApiService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mocked-api.service.js","sourceRoot":"","sources":["../../../../../../../../packages/tgo-coding-test/src/shared/lib/services/api/mocked-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, of, delay } from 'rxjs';\n\n/**\n * MockedApiService provides fake API responses for demo/development purposes.\n * This service mimics the real ApiService interface but returns mock data instead\n * of making actual HTTP calls.\n *\n * Usage: Provide this service in place of ApiService in your demo application:\n * ```\n * { provide: ApiService, useClass: MockedApiService }\n * ```\n */\n@Injectable()\nexport class MockedApiService {\n  private invitationUUID = 'demo-uuid-12345';\n  private contentLanguage = 'en';\n  private ROOT_TRANSLATIONS_SCOPE = '';\n\n  // Simulate network delay (in ms) - set to 0 for instant responses\n  private readonly MOCK_DELAY = 500;\n\n  setParams(\n    invitationUUID: string,\n    contentLanguage: string,\n    translationScope: string,\n    baseUrl: string\n  ): void {\n    this.invitationUUID = invitationUUID;\n    this.contentLanguage = contentLanguage;\n    this.ROOT_TRANSLATIONS_SCOPE = translationScope;\n    console.log('[MockedApiService] Params set:', {\n      invitationUUID,\n      contentLanguage,\n      translationScope,\n      baseUrl,\n    });\n  }\n\n  getInvitationUUID(): string {\n    return this.invitationUUID;\n  }\n\n  get<T>(\n    url: string,\n    options = {},\n    errorCallback?: (error: any) => Observable<never>\n  ): Observable<T> {\n    console.log('[MockedApiService] GET:', url, options);\n    return of(this.getMockResponse<T>(url, 'GET') as T).pipe(\n      delay(this.MOCK_DELAY)\n    );\n  }\n\n  post<T>(\n    url: string,\n    data: object,\n    options = {},\n    errorCallback?: (error: any) => Observable<never>,\n    isStandaloneUrl = false\n  ): Observable<T> {\n    console.log('[MockedApiService] POST:', url, data, options);\n    return of(this.getMockResponse<T>(url, 'POST', data) as T).pipe(\n      delay(this.MOCK_DELAY)\n    );\n  }\n\n  put<T>(\n    url: string,\n    data: object,\n    options = {},\n    errorCallback?: (error: any) => Observable<never>\n  ): Observable<T> {\n    console.log('[MockedApiService] PUT:', url, data, options);\n    return of(this.getMockResponse<T>(url, 'PUT', data) as T).pipe(\n      delay(this.MOCK_DELAY)\n    );\n  }\n\n  patch<T>(\n    url: string,\n    data: object,\n    options = {},\n    errorCallback?: (error: any) => Observable<never>\n  ): Observable<T> {\n    console.log('[MockedApiService] PATCH:', url, data, options);\n    return of(this.getMockResponse<T>(url, 'PATCH', data) as T).pipe(\n      delay(this.MOCK_DELAY)\n    );\n  }\n\n  delete(\n    url: string,\n    errorCallback?: (error: any) => Observable<never>\n  ): Observable<object> {\n    console.log('[MockedApiService] DELETE:', url);\n    return of({}).pipe(delay(this.MOCK_DELAY));\n  }\n\n  /**\n   * Returns mock responses based on the URL pattern\n   */\n  private getMockResponse<T>(url: string, method: string, data?: object): T | object {\n    // CodeRunner API - Run Tests\n    if (url.includes('/api/attempts/public/')) {\n      return this.getMockCoderunnerAttemptResponse(data);\n    }\n\n    if (url.includes('/api/attempts/preview/')) {\n      return this.getMockCoderunnerAttemptResponse(data);\n    }\n\n    if (url.includes('/api/attempts/')) {\n      return this.getMockCoderunnerAttemptResponse(data);\n    }\n\n    // Code Events\n    if (url.includes('/api/code-events/')) {\n      return {\n        id: Math.floor(Math.random() * 10000),\n        created_at: new Date().toISOString(),\n      };\n    }\n\n    // Programming Languages\n    if (url.includes('programming-languages')) {\n      return []; // Mock all languages\n    }\n\n    // Default response\n    console.warn(`[MockedApiService] No mock defined for ${method} ${url}`);\n    return { success: true, data: null };\n  }\n\n  /**\n   * Returns a mock coderunner attempt response with test results\n   */\n  private getMockCoderunnerAttemptResponse(data?: object): object {\n    const requestData = data as any;\n    const testcases = requestData?.testcases || [];\n\n    // Generate mock results for each test case\n    const results = testcases.map((testcase: any, index: number) => {\n      // Make first test pass, others random for variety\n      const passed = index === 0 ? true : Math.random() > 0.3;\n\n      return {\n        name: testcase.name || `Test Case ${index + 1}`,\n        passed,\n        expected: testcase.solution || testcase.expected_output || 'Expected output',\n        actual: passed\n          ? testcase.solution || testcase.expected_output || 'Expected output'\n          : 'Different output',\n        input: testcase.input || '',\n        error: passed ? null : 'AssertionError: Output does not match expected',\n        execution_time: Math.random() * 100,\n        memory_used: Math.floor(Math.random() * 1000000),\n        points: passed ? (testcase.points || 10) : 0,\n      };\n    });\n\n    const totalPoints = results.reduce((sum: number, r: any) => sum + r.points, 0);\n    const maxPoints = testcases.reduce(\n      (sum: number, tc: any) => sum + (tc.points || 10),\n      0\n    );\n\n    return {\n      id: Math.floor(Math.random() * 100000),\n      uuid: crypto.randomUUID(),\n      created_at: new Date().toISOString(),\n      language: requestData?.language || 'python-3.10.0',\n      code: requestData?.code || '',\n      status: 'completed',\n      results,\n      score: maxPoints > 0 ? (totalPoints / maxPoints) * 100 : 0,\n      total_points: totalPoints,\n      max_points: maxPoints,\n      execution_time: results.reduce((sum: number, r: any) => sum + r.execution_time, 0),\n      compilation_error: null,\n      runtime_error: null,\n    };\n  }\n}\n"]}

package/esm2022/shared/lib/services/environment/environment.service.mjs

@@ -0,0 +1,13 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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: "18.2.13", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3Rnby1jb2RpbmctdGVzdC9zcmMvc2hhcmVkL2xpYi9zZXJ2aWNlcy9lbnZpcm9ubWVudC9lbnZpcm9ubWVudC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRzNDLE1BQU0sT0FBTyxrQkFBa0I7SUFDN0IsSUFBSSxRQUFRO1FBQ1YsT0FBTyxnRUFBZ0UsQ0FBQyxJQUFJLENBQzFFLFNBQVMsQ0FBQyxTQUFTLENBQ3BCLENBQUM7SUFDSixDQUFDO3dHQUxVLGtCQUFrQjs0R0FBbEIsa0JBQWtCOzs0RkFBbEIsa0JBQWtCO2tCQUQ5QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgRW52aXJvbm1lbnRTZXJ2aWNlIHtcbiAgZ2V0IGlzTW9iaWxlKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiAvQW5kcm9pZHx3ZWJPU3xpUGhvbmV8aVBhZHxpUG9kfEJsYWNrQmVycnl8SUVNb2JpbGV8T3BlcmEgTWluaS9pLnRlc3QoXG4gICAgICBuYXZpZ2F0b3IudXNlckFnZW50XG4gICAgKTtcbiAgfVxufVxuIl19

package/esm2022/shared/lib/services/index.mjs

@@ -0,0 +1,10 @@
+export * from './media/media.service';
+export * from './theme/theme.service';
+export * from './localization/transloco-lazy-module-utils';
+export * from './localization/languages.model';
+export * from './localization/transloco-testing.module';
+export * from './api/api.service';
+export * from './api/mocked-api.service';
+export * from './environment/environment.service';
+export * from './mixpanel/mixpanel.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy90Z28tY29kaW5nLXRlc3Qvc3JjL3NoYXJlZC9saWIvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNENBQTRDLENBQUM7QUFDM0QsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21lZGlhL21lZGlhLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90aGVtZS90aGVtZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbG9jYWxpemF0aW9uL3RyYW5zbG9jby1sYXp5LW1vZHVsZS11dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2xvY2FsaXphdGlvbi9sYW5ndWFnZXMubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2NhbGl6YXRpb24vdHJhbnNsb2NvLXRlc3RpbmcubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vYXBpL2FwaS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vYXBpL21vY2tlZC1hcGkuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Vudmlyb25tZW50L2Vudmlyb25tZW50LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9taXhwYW5lbC9taXhwYW5lbC5zZXJ2aWNlJzsiXX0=

package/esm2022/shared/lib/services/localization/languages.model.mjs

@@ -0,0 +1,19 @@
+//Languages available in the app as enum
+export 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
+export const getAvailableLangs = () => Object.values(Language);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2VzLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvdGdvLWNvZGluZy10ZXN0L3NyYy9zaGFyZWQvbGliL3NlcnZpY2VzL2xvY2FsaXphdGlvbi9sYW5ndWFnZXMubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0NBQXdDO0FBQ3hDLE1BQU0sQ0FBTixJQUFZLFFBYVg7QUFiRCxXQUFZLFFBQVE7SUFDbEIscUJBQVMsQ0FBQTtJQUNULHFCQUFTLENBQUE7SUFDVCxxQkFBUyxDQUFBO0lBQ1QscUJBQVMsQ0FBQTtJQUNULHFCQUFTLENBQUE7SUFDVCwyQkFBaUIsQ0FBQTtJQUNqQiwyQkFBaUIsQ0FBQTtJQUNqQiwyQkFBaUIsQ0FBQTtJQUNqQiwyQkFBaUIsQ0FBQTtJQUNqQiwyQkFBaUIsQ0FBQTtJQUNqQiwyQkFBaUIsQ0FBQTtJQUNqQiwyQkFBaUIsQ0FBQTtBQUNuQixDQUFDLEVBYlcsUUFBUSxLQUFSLFFBQVEsUUFhbkI7QUFFRCx5RkFBeUY7QUFDekYsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsR0FBRyxFQUFFLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vTGFuZ3VhZ2VzIGF2YWlsYWJsZSBpbiB0aGUgYXBwIGFzIGVudW1cbmV4cG9ydCBlbnVtIExhbmd1YWdlIHtcbiAgZW4gPSAnZW4nLFxuICBlcyA9ICdlcycsXG4gIG5sID0gJ25sJyxcbiAgZnIgPSAnZnInLFxuICBkZSA9ICdkZScsXG4gICdpdC1pdCcgPSAnaXQtaXQnLFxuICAnamEtanAnID0gJ2phLWpwJyxcbiAgJ3B0LWJyJyA9ICdwdC1icicsXG4gICdkYS1kaycgPSAnZGEtZGsnLFxuICAnbmItbm8nID0gJ25iLW5vJyxcbiAgJ3BsLXBsJyA9ICdwbC1wbCcsXG4gICdzdi1zZScgPSAnc3Ytc2UnLFxufVxuXG4vL1RoaXMgZnVuY3Rpb24gcmV0cmlldmVzIGFsbCBsYW5ndWFnZXMgZnJvbSB0aGUgZW51bS4gSXQgaXMgdXNlZCB0byBpbml0aWFsaXplIHRyYW5zbG9jb1xuZXhwb3J0IGNvbnN0IGdldEF2YWlsYWJsZUxhbmdzID0gKCkgPT4gT2JqZWN0LnZhbHVlcyhMYW5ndWFnZSk7XG5cbiJdfQ==

package/esm2022/shared/lib/services/localization/transloco-lazy-module-utils.mjs

@@ -0,0 +1,27 @@
+import { TRANSLOCO_SCOPE } from '@ngneat/transloco';
+/**
+ * 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
+ */
+export 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),
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shared/lib/services/localization/transloco-testing.module.mjs

@@ -0,0 +1,11 @@
+import { TranslocoTestingModule, } from '@ngneat/transloco';
+export const getTranslocoModule = (options = {}) => TranslocoTestingModule.forRoot({
+    translocoConfig: {
+        reRenderOnLangChange: false,
+        availableLangs: ['en'],
+        defaultLang: 'en',
+    },
+    preloadLangs: true,
+    ...options,
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsb2NvLXRlc3RpbmcubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvdGdvLWNvZGluZy10ZXN0L3NyYy9zaGFyZWQvbGliL3NlcnZpY2VzL2xvY2FsaXphdGlvbi90cmFuc2xvY28tdGVzdGluZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHNCQUFzQixHQUV2QixNQUFNLG1CQUFtQixDQUFDO0FBRTNCLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLENBQUMsVUFBbUMsRUFBRSxFQUFFLEVBQUUsQ0FDMUUsc0JBQXNCLENBQUMsT0FBTyxDQUFDO0lBQzdCLGVBQWUsRUFBRTtRQUNmLG9CQUFvQixFQUFFLEtBQUs7UUFDM0IsY0FBYyxFQUFFLENBQUMsSUFBSSxDQUFDO1FBQ3RCLFdBQVcsRUFBRSxJQUFJO0tBQ2xCO0lBQ0QsWUFBWSxFQUFFLElBQUk7SUFDbEIsR0FBRyxPQUFPO0NBQ1gsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgVHJhbnNsb2NvVGVzdGluZ01vZHVsZSxcbiAgVHJhbnNsb2NvVGVzdGluZ09wdGlvbnMsXG59IGZyb20gJ0BuZ25lYXQvdHJhbnNsb2NvJztcblxuZXhwb3J0IGNvbnN0IGdldFRyYW5zbG9jb01vZHVsZSA9IChvcHRpb25zOiBUcmFuc2xvY29UZXN0aW5nT3B0aW9ucyA9IHt9KSA9PlxuICBUcmFuc2xvY29UZXN0aW5nTW9kdWxlLmZvclJvb3Qoe1xuICAgIHRyYW5zbG9jb0NvbmZpZzoge1xuICAgICAgcmVSZW5kZXJPbkxhbmdDaGFuZ2U6IGZhbHNlLFxuICAgICAgYXZhaWxhYmxlTGFuZ3M6IFsnZW4nXSxcbiAgICAgIGRlZmF1bHRMYW5nOiAnZW4nLFxuICAgIH0sXG4gICAgcHJlbG9hZExhbmdzOiB0cnVlLFxuICAgIC4uLm9wdGlvbnMsXG4gIH0pO1xuIl19

package/esm2022/shared/lib/services/media/media.service.mjs

@@ -0,0 +1,129 @@
+import { Injectable, signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export 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: "18.2.13", ngImport: i0, type: MediaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MediaService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MediaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"media.service.js","sourceRoot":"","sources":["../../../../../../../../packages/tgo-coding-test/src/shared/lib/services/media/media.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;;AAMlC,MAAM,OAAO,YAAY;IACf,aAAa,GAAyB,IAAI,CAAC;IAC3C,oBAAoB,CAAmC;IACtD,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAErC,aAAa;QACX,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,CAAC;IAC7B,CAAC;IAED,cAAc,CAAC,IAGd;QACC,OAAO,SAAS,CAAC,YAAY,CAAC,YAAY,CACxC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,CACrC,CAAC;IACJ,CAAC;IAED,WAAW;QAGT,IAAI,sBAA+C,CAAC;QACpD,OAAO,IAAI,UAAU,CAAC,CAAC,QAAQ,EAAE,EAAE;YACjC,KAAK,IAAI,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;iBACpD,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;gBACf,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;gBAC/C,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;gBAC3B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAC3B,MAAM,WAAW,GAAW,EAAE,CAAC;gBAC/B,IAAI,CAAC,aAAa,CAAC,eAAe,GAAG,CAAC,KAAK,EAAE,EAAE;oBAC7C,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC/B,CAAC,CAAC;gBAEF,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,MAAM,EAAE,GAAG,EAAE;oBAC/C,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,WAAW,EAAE;wBACtC,IAAI,EAAE,WAAW;qBAClB,CAAC,CAAC;oBACH,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;oBACrD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAC5B,QAAQ,CAAC,QAAQ,EAAE,CAAC;gBACtB,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC,aAAa,CAAC,OAAO,GAAG,CAAC,KAAK,EAAE,EAAE;oBACrC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBACtB,QAAQ,CAAC,QAAQ,EAAE,CAAC;gBACtB,CAAC,CAAC;gBAEF,MAAM,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;gBACxC,MAAM,0BAA0B,GAC9B,YAAY,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;gBAC/C,MAAM,YAAY,GAAG,YAAY,CAAC,cAAc,EAAE,CAAC;gBACnD,0BAA0B,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;gBAEjD,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;gBACvD,MAAM,OAAO,GAAG,GAAG,EAAE;oBACnB,YAAY,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;oBAC7C,IAAI,UAAU,GAAG,GAAG,CAAC;oBACrB,KAAK,MAAM,SAAS,IAAI,OAAO,EAAE,CAAC;wBAChC,UAAU,IAAI,SAAS,GAAG,SAAS,CAAC;oBACtC,CAAC;oBACD,IAAI,UAAU,GAAG,CAAC,EAAE,CAAC;wBACnB,QAAQ,CAAC,IAAI,CAAC;4BACZ,IAAI,EAAE,QAAQ;4BACd,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;yBAC9C,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,sBAAsB,EAAE,CAAC;4BAC5B,sBAAsB,GAAG,IAAI,CAAC,eAAe,CAAC;gCAC5C,KAAK,EAAE,KAAK;gCACZ,KAAK,EAAE,IAAI;6BACZ,CAAC,CAAC;4BAEH,sBAAsB;iCACnB,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE;gCACtB,IAAI,CAAC,aAAa,EAAE,CAAC;oCACnB,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC;oCAC/C,QAAQ,CAAC,QAAQ,EAAE,CAAC;gCACtB,CAAC;4BACH,CAAC,CAAC;iCACD,OAAO,CAAC,GAAG,EAAE;gCACZ,sBAAsB,GAAG,IAAI,CAAC;4BAChC,CAAC,CAAC,CAAC;wBACP,CAAC;oBACH,CAAC;oBAED,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;wBACrB,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;oBACxC,CAAC;gBACH,CAAC,CAAC;gBACF,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;YACxC,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;gBACf,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACtB,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,GAAW;QACzB,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,KAAK,CAAC,OAAO,GAAG,GAAG,EAAE;gBACnB,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC;YACF,KAAK,CAAC,OAAO,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,uBAAuB,CAAC,IAA2B;QACjD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,IAGrB;QACC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;YAChC,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACnB,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAEO,yBAAyB,CAAC,IAGjC;QACC,MAAM,aAAa,GAAG,IAAI,CAAC,oBAAoB,EAAE,aAAa,CAAC;QAC/D,MAAM,aAAa,GAAG,IAAI,CAAC,oBAAoB,EAAE,aAAa,CAAC;QAC/D,OAAO;YACL,KAAK,EACH,IAAI,CAAC,KAAK,IAAI,aAAa;gBACzB,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE;gBACxC,CAAC,CAAC,IAAI,CAAC,KAAK;YAChB,KAAK,EACH,IAAI,CAAC,KAAK,IAAI,aAAa;gBACzB,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE;gBACxC,CAAC,CAAC,IAAI,CAAC,KAAK;SACjB,CAAC;IACJ,CAAC;wGA9IU,YAAY;4GAAZ,YAAY,cAFX,MAAM;;4FAEP,YAAY;kBAHxB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, signal } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { SelectedMediaDevices } from '../../models';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MediaService {\n  private mediaRecorder: MediaRecorder | null = null;\n  private selectedMediaDevices: SelectedMediaDevices | undefined;\n  readonly isRecording = signal(false);\n\n  stopRecording(): void {\n    this.mediaRecorder?.stop();\n  }\n\n  getMediaStream(data: {\n    audio: boolean;\n    video: boolean;\n  }): Promise<MediaStream> {\n    return navigator.mediaDevices.getUserMedia(\n      this.getMediaStreamConstraints(data)\n    );\n  }\n\n  recordAudio(): Observable<\n    { type: 'complete'; file: Blob } | { type: 'volume'; value: number }\n  > {\n    let checkPermissionPromise: Promise<boolean> | null;\n    return new Observable((observer) => {\n      void this.getMediaStream({ video: false, audio: true })\n        .then((stream) => {\n          this.mediaRecorder = new MediaRecorder(stream);\n          this.mediaRecorder.start();\n          this.isRecording.set(true);\n          const audioChunks: Blob[] = [];\n          this.mediaRecorder.ondataavailable = (event) => {\n            audioChunks.push(event.data);\n          };\n\n          this.mediaRecorder.addEventListener('stop', () => {\n            const audioBlob = new Blob(audioChunks, {\n              type: 'audio/mp3',\n            });\n            observer.next({ type: 'complete', file: audioBlob });\n            this.isRecording.set(false);\n            observer.complete();\n          });\n\n          this.mediaRecorder.onerror = (error) => {\n            observer.error(error);\n            observer.complete();\n          };\n\n          const audioContext = new AudioContext();\n          const mediaStreamAudioSourceNode =\n            audioContext.createMediaStreamSource(stream);\n          const analyserNode = audioContext.createAnalyser();\n          mediaStreamAudioSourceNode.connect(analyserNode);\n\n          const pcmData = new Float32Array(analyserNode.fftSize);\n          const onFrame = () => {\n            analyserNode.getFloatTimeDomainData(pcmData);\n            let sumSquares = 0.0;\n            for (const amplitude of pcmData) {\n              sumSquares += amplitude * amplitude;\n            }\n            if (sumSquares > 0) {\n              observer.next({\n                type: 'volume',\n                value: Math.sqrt(sumSquares / pcmData.length),\n              });\n            } else {\n              if (!checkPermissionPromise) {\n                checkPermissionPromise = this.checkPermission({\n                  video: false,\n                  audio: true,\n                });\n\n                checkPermissionPromise\n                  .then((hasPermission) => {\n                    if (!hasPermission) {\n                      observer.error(new Error('Permission denied'));\n                      observer.complete();\n                    }\n                  })\n                  .finally(() => {\n                    checkPermissionPromise = null;\n                  });\n              }\n            }\n\n            if (!observer.closed) {\n              window.requestAnimationFrame(onFrame);\n            }\n          };\n          window.requestAnimationFrame(onFrame);\n        })\n        .catch((error) => {\n          observer.error(error);\n          observer.complete();\n        });\n    });\n  }\n\n  async playAudio(url: string): Promise<void> {\n    const audio = new Audio(url);\n    await audio.play();\n    return new Promise((resolve, reject) => {\n      audio.onended = () => {\n        resolve();\n      };\n      audio.onerror = (event) => reject(event);\n    });\n  }\n\n  setSelectedMediaDevices(data?: SelectedMediaDevices): void {\n    this.selectedMediaDevices = data;\n  }\n\n  async checkPermission(data: {\n    audio: boolean;\n    video: boolean;\n  }): Promise<boolean> {\n    try {\n      await this.getMediaStream(data);\n      return true;\n    } catch (err) {\n      console.error(err);\n      return false;\n    }\n  }\n\n  private getMediaStreamConstraints(data: {\n    audio: boolean;\n    video: boolean;\n  }): MediaStreamConstraints {\n    const audioDeviceID = this.selectedMediaDevices?.audioDeviceId;\n    const videoDeviceID = this.selectedMediaDevices?.videoDeviceId;\n    return {\n      audio:\n        data.audio && audioDeviceID\n          ? { deviceId: { exact: audioDeviceID } }\n          : data.audio,\n      video:\n        data.video && videoDeviceID\n          ? { deviceId: { exact: videoDeviceID } }\n          : data.video,\n    };\n  }\n}\n\n"]}

package/esm2022/shared/lib/services/mixpanel/mixpanel.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import '../../models/window';
+import * as i0 from "@angular/core";
+export 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: "18.2.13", ngImport: i0, type: MixpanelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MixpanelService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MixpanelService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shared/lib/services/theme/theme.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+var THEME_VARS;
+(function (THEME_VARS) {
+    THEME_VARS["COMPANY_COLOR"] = "--color-primary-50";
+})(THEME_VARS || (THEME_VARS = {}));
+export 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: "18.2.13", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ThemeService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3Rnby1jb2RpbmctdGVzdC9zcmMvc2hhcmVkL2xpYi9zZXJ2aWNlcy90aGVtZS90aGVtZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRTNDLElBQUssVUFFSjtBQUZELFdBQUssVUFBVTtJQUNiLGtEQUFvQyxDQUFBO0FBQ3RDLENBQUMsRUFGSSxVQUFVLEtBQVYsVUFBVSxRQUVkO0FBR0QsTUFBTSxPQUFPLFlBQVk7SUFDTixnQkFBZ0IsR0FBRyxTQUFTLENBQUM7SUFFOUMsZUFBZTtRQUNiLE9BQU8sQ0FDTCxJQUFJLENBQUMsbUJBQW1CLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQztZQUNsRCxJQUFJLENBQUMsZ0JBQWdCLENBQ3RCLENBQUM7SUFDSixDQUFDO0lBRU8sbUJBQW1CLENBQUMsWUFBb0I7UUFDOUMsT0FBTyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO2FBQzlDLGdCQUFnQixDQUFDLFlBQVksQ0FBQzthQUM5QixJQUFJLEVBQUUsQ0FBQztJQUNaLENBQUM7d0dBZFUsWUFBWTs0R0FBWixZQUFZOzs0RkFBWixZQUFZO2tCQUR4QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5lbnVtIFRIRU1FX1ZBUlMge1xuICBDT01QQU5ZX0NPTE9SID0gJy0tY29sb3ItcHJpbWFyeS01MCcsXG59XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBUaGVtZVNlcnZpY2Uge1xuICBwcml2YXRlIHJlYWRvbmx5IEJSQU5EX1BJTktfQ09MT1IgPSAnI0Q0MTBBQSc7XG5cbiAgZ2V0Q29tcGFueUNvbG9yKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIChcbiAgICAgIHRoaXMuZ2V0Q1NTVmFyaWFibGVWYWx1ZShUSEVNRV9WQVJTLkNPTVBBTllfQ09MT1IpIHx8XG4gICAgICB0aGlzLkJSQU5EX1BJTktfQ09MT1JcbiAgICApO1xuICB9XG5cbiAgcHJpdmF0ZSBnZXRDU1NWYXJpYWJsZVZhbHVlKHZhcmlhYmxlTmFtZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgICByZXR1cm4gZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5kb2N1bWVudEVsZW1lbnQpXG4gICAgICAuZ2V0UHJvcGVydHlWYWx1ZSh2YXJpYWJsZU5hbWUpXG4gICAgICAudHJpbSgpO1xuICB9XG59XG5cbiJdfQ==