design-angular-kit 1.2.1 → 1.3.0

package/esm2022/lib/components/core/tooltip/tooltip.directive.mjs

@@ -0,0 +1,143 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Tooltip } from 'bootstrap-italia';
+import { inputToBoolean } from '../../../utils/coercion';
+import * as i0 from "@angular/core";
+export class ItTooltipDirective {
+    /**
+     * Define the tooltip title
+     * @param title the tooltip title
+     */
+    set title(title) {
+        if (title) {
+            // this.element.setAttribute("title", title);
+            this.element.setAttribute('data-bs-original-title', title);
+        }
+    }
+    /**
+     * Define the tooltip placement
+     * @param placement
+     */
+    set tooltipPlacement(placement) {
+        this.element.setAttribute('data-bs-placement', placement);
+    }
+    /**
+     * Indicates whether the title contains html
+     * @param html true if contain html
+     */
+    set tooltipHtml(html) {
+        this.element.setAttribute('data-bs-html', html ? 'true' : 'false');
+    }
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        /**
+         * This event fires immediately when the show method is called.
+         */
+        this.showEvent = new EventEmitter();
+        /**
+         * This event is triggered when the tooltip has been made visible to the user (it will wait for the CSS transitions to complete).
+         */
+        this.shownEvent = new EventEmitter();
+        /**
+         * This event fires immediately when the hide method is called.
+         */
+        this.hideEvent = new EventEmitter();
+        /**
+         * This event is raised when the tooltip has finished being hidden from the user (it will wait for the CSS transitions to complete).
+         */
+        this.hiddenEvent = new EventEmitter();
+        /**
+         * This event fires after the show event when the tooltip template has been added to the DOM.
+         */
+        this.insertedEvent = new EventEmitter();
+        this.element = this._elementRef.nativeElement;
+    }
+    ngAfterViewInit() {
+        this.element.setAttribute('data-bs-toggle', 'tooltip');
+        this.tooltip = Tooltip.getOrCreateInstance(this.element);
+        this.element.addEventListener('show.bs.tooltip', event => this.showEvent.emit(event));
+        this.element.addEventListener('shown.bs.tooltip', event => this.shownEvent.emit(event));
+        this.element.addEventListener('hide.bs.tooltip', event => this.hideEvent.emit(event));
+        this.element.addEventListener('hidden.bs.tooltip', event => this.hiddenEvent.emit(event));
+        this.element.addEventListener('inserted.bs.tooltip', event => this.insertedEvent.emit(event));
+    }
+    ngOnDestroy() {
+        this.dispose();
+    }
+    /**
+     * Shows the tooltip of an item.
+     */
+    show() {
+        this.tooltip?.show();
+    }
+    /**
+     * Hide the tooltip of an element.
+     */
+    hide() {
+        this.tooltip?.hide();
+    }
+    /**
+     * Activate / Deactivate the tooltip of an element
+     */
+    toggle() {
+        this.tooltip?.toggle();
+    }
+    /**
+     * Hides and destroys the tooltip of an element.
+     */
+    dispose() {
+        this.tooltip?.dispose();
+    }
+    /**
+     * Gives the tooltip of an element a chance to be shown.
+     */
+    enable() {
+        this.tooltip?.enable();
+    }
+    /**
+     * Removes the ability to show the tooltip of an element.
+     */
+    disable() {
+        this.tooltip?.disable();
+    }
+    /**
+     * Toggles the possibility that the tooltip of an element is shown or hidden.
+     */
+    toggleEnabled() {
+        this.tooltip?.disable();
+    }
+    /**
+     * Updates the position of an element's tooltip.
+     */
+    update() {
+        this.tooltip?.disable();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItTooltipDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.0.6", type: ItTooltipDirective, isStandalone: true, selector: "[itTooltip]", inputs: { title: ["itTooltip", "title"], tooltipPlacement: "tooltipPlacement", tooltipHtml: ["tooltipHtml", "tooltipHtml", inputToBoolean] }, outputs: { showEvent: "showEvent", shownEvent: "shownEvent", hideEvent: "hideEvent", hiddenEvent: "hiddenEvent", insertedEvent: "insertedEvent" }, exportAs: ["itTooltip"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[itTooltip]',
+                    exportAs: 'itTooltip',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { title: [{
+                type: Input,
+                args: ['itTooltip']
+            }], tooltipPlacement: [{
+                type: Input
+            }], tooltipHtml: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], showEvent: [{
+                type: Output
+            }], shownEvent: [{
+                type: Output
+            }], hideEvent: [{
+                type: Output
+            }], hiddenEvent: [{
+                type: Output
+            }], insertedEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/core/tooltip/tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, ElementRef, EventEmitter, Input, OnDestroy, Output } from '@angular/core';\nimport { ElementPlacement } from '../../../interfaces/core';\nimport { Tooltip } from 'bootstrap-italia';\nimport { inputToBoolean } from '../../../utils/coercion';\n\n@Directive({\n  standalone: true,\n  selector: '[itTooltip]',\n  exportAs: 'itTooltip',\n})\nexport class ItTooltipDirective implements AfterViewInit, OnDestroy {\n  /**\n   * Define the tooltip title\n   * @param title the tooltip title\n   */\n  @Input('itTooltip') set title(title: string | undefined) {\n    if (title) {\n      // this.element.setAttribute(\"title\", title);\n      this.element.setAttribute('data-bs-original-title', title);\n    }\n  }\n\n  /**\n   * Define the tooltip placement\n   * @param placement\n   */\n  @Input() set tooltipPlacement(placement: ElementPlacement) {\n    this.element.setAttribute('data-bs-placement', placement);\n  }\n\n  /**\n   * Indicates whether the title contains html\n   * @param html true if contain html\n   */\n  @Input({ transform: inputToBoolean }) set tooltipHtml(html: boolean) {\n    this.element.setAttribute('data-bs-html', html ? 'true' : 'false');\n  }\n\n  /**\n   * This event fires immediately when the show method is called.\n   */\n  @Output() showEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event is triggered when the tooltip has been made visible to the user (it will wait for the CSS transitions to complete).\n   */\n  @Output() shownEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event fires immediately when the hide method is called.\n   */\n  @Output() hideEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event is raised when the tooltip has finished being hidden from the user (it will wait for the CSS transitions to complete).\n   */\n  @Output() hiddenEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event fires after the show event when the tooltip template has been added to the DOM.\n   */\n  @Output() insertedEvent: EventEmitter<Event> = new EventEmitter();\n\n  private readonly element: HTMLElement;\n  private tooltip?: Tooltip;\n\n  constructor(private readonly _elementRef: ElementRef) {\n    this.element = this._elementRef.nativeElement;\n  }\n\n  ngAfterViewInit(): void {\n    this.element.setAttribute('data-bs-toggle', 'tooltip');\n    this.tooltip = Tooltip.getOrCreateInstance(this.element);\n\n    this.element.addEventListener('show.bs.tooltip', event => this.showEvent.emit(event));\n    this.element.addEventListener('shown.bs.tooltip', event => this.shownEvent.emit(event));\n    this.element.addEventListener('hide.bs.tooltip', event => this.hideEvent.emit(event));\n    this.element.addEventListener('hidden.bs.tooltip', event => this.hiddenEvent.emit(event));\n    this.element.addEventListener('inserted.bs.tooltip', event => this.insertedEvent.emit(event));\n  }\n\n  ngOnDestroy(): void {\n    this.dispose();\n  }\n\n  /**\n   * Shows the tooltip of an item.\n   */\n  public show(): void {\n    this.tooltip?.show();\n  }\n\n  /**\n   * Hide the tooltip of an element.\n   */\n  public hide(): void {\n    this.tooltip?.hide();\n  }\n\n  /**\n   * Activate / Deactivate the tooltip of an element\n   */\n  public toggle(): void {\n    this.tooltip?.toggle();\n  }\n\n  /**\n   * Hides and destroys the tooltip of an element.\n   */\n  public dispose(): void {\n    this.tooltip?.dispose();\n  }\n\n  /**\n   * Gives the tooltip of an element a chance to be shown.\n   */\n  public enable(): void {\n    this.tooltip?.enable();\n  }\n\n  /**\n   * Removes the ability to show the tooltip of an element.\n   */\n  public disable(): void {\n    this.tooltip?.disable();\n  }\n\n  /**\n   * Toggles the possibility that the tooltip of an element is shown or hidden.\n   */\n  public toggleEnabled(): void {\n    this.tooltip?.disable();\n  }\n\n  /**\n   * Updates the position of an element's tooltip.\n   */\n  public update(): void {\n    this.tooltip?.disable();\n  }\n}\n"]}

package/esm2022/lib/components/core/video-player/video-player-i18n.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"video-player-i18n.model.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/core/video-player/video-player-i18n.model.ts"],"names":[],"mappings":"","sourcesContent":["interface VideoJsTranslation {\n  'Audio Player': string;\n  'Video Player': string;\n  Play: string;\n  Pause: string;\n  Replay: string;\n  'Current Time': string;\n  Duration: string;\n  'Remaining Time': string;\n  'Stream Type': string;\n  LIVE: string;\n  Loaded: string;\n  Progress: string;\n  'Progress Bar': string;\n  'progress bar timing: currentTime={1} duration={2}': string;\n  Fullscreen: string;\n  'Exit Fullscreen': string;\n  Mute: string;\n  Unmute: string;\n  'Playback Rate': string;\n  Subtitles: string;\n  'subtitles off': string;\n  Captions: string;\n  'captions off': string;\n  Chapters: string;\n  Descriptions: string;\n  'descriptions off': string;\n  'Audio Track': string;\n  'Volume Level': string;\n  'You aborted the media playback': string;\n  'A network error caused the media download to fail part-way.': string;\n  'The media could not be loaded, either because the server or network failed or because the format is not supported.': string;\n  'The media playback was aborted due to a corruption problem or because the media used features your browser did not support.': string;\n  'No compatible source was found for this media.': string;\n  'The media is encrypted and we do not have the keys to decrypt it.': string;\n  'Play Video': string;\n  Close: string;\n  'Close Modal Dialog': string;\n  'Modal Window': string;\n  'This is a modal window': string;\n  'This modal can be closed by pressing the Escape key or activating the close button.': string;\n  ', opens captions settings dialog': string;\n  ', opens subtitles settings dialog': string;\n  ', opens descriptions settings dialog': string;\n  ', selected': string;\n  'captions settings': string;\n  'subtitles settings': string;\n  'descriptions settings': string;\n  Text: string;\n  White: string;\n  Black: string;\n  Red: string;\n  Green: string;\n  Blue: string;\n  Yellow: string;\n  Magenta: string;\n  Cyan: string;\n  Background: string;\n  Window: string;\n  Transparent: string;\n  'Semi-Transparent': string;\n  Opaque: string;\n  'Font Size': string;\n  'Text Edge Style': string;\n  None: string;\n  Uniform: string;\n  'Drop shadow': string;\n  'Font Family': string;\n  'Proportional Sans-Serif': string;\n  'Monospace Sans-Serif': string;\n  'Proportional Serif': string;\n  'Monospace Serif': string;\n  'Small Caps': string;\n  Reset: string;\n  'restore all settings to the default values': string;\n  Done: string;\n  'Caption Settings Dialog': string;\n  'Beginning of dialog window. Escape will cancel and close the window.': string;\n  'End of dialog window.': string;\n  '{1} is loading.': string;\n  'Exit Picture-in-Picture': string;\n  'Picture-in-Picture': string;\n  Color: string;\n  Opacity: string;\n  'Text Background': string;\n  'Caption Area Background': string;\n  'Skip forward {1} seconds': string;\n  'Skip backward {1} seconds': string;\n}\n\ninterface VideoPlayerTranslations {\n  'audio-player': string;\n  'video-player': string;\n  play: string;\n  pause: string;\n  replay: string;\n  'current-time': string;\n  duration: string;\n  'remaining-time': string;\n  'stream-type': string;\n  live: string;\n  loaded: string;\n  progress: string;\n  'progress-bar': string;\n  'progress-bar-timing:-currenttime={1}-duration={2}': string;\n  fullscreen: string;\n  'exit-fullscreen': string;\n  mute: string;\n  unmute: string;\n  'playback-rate': string;\n  subtitles: string;\n  'subtitles-off': string;\n  captions: string;\n  'captions-off': string;\n  chapters: string;\n  descriptions: string;\n  'descriptions-off': string;\n  'audio-track': string;\n  'volume-level': string;\n  'you-aborted-the-media-playback': string;\n  'a-network-error-caused-the-media-download-to-fail-part-way.': string;\n  'the-media-could-not-be-loaded,-either-because-the-server-or-network-failed-or-because-the-format-is-not-supported.': string;\n  'the-media-playback-was-aborted-due-to-a-corruption-problem-or-because-the-media-used-features-your-browser-did-not-support.': string;\n  'no-compatible-source-was-found-for-this-media.': string;\n  'the-media-is-encrypted-and-we-do-not-have-the-keys-to-decrypt-it.': string;\n  'play-video': string;\n  close: string;\n  'close-modal-dialog': string;\n  'modal-window': string;\n  'this-is-a-modal-window': string;\n  'this-modal-can-be-closed-by-pressing-the-escape-key-or-activating-the-close-button.': string;\n  ',-opens-captions-settings-dialog': string;\n  ',-opens-subtitles-settings-dialog': string;\n  ',-opens-descriptions-settings-dialog': string;\n  ',-selected': string;\n  'captions-settings': string;\n  'subtitles-settings': string;\n  'descriptions-settings': string;\n  text: string;\n  white: string;\n  black: string;\n  red: string;\n  green: string;\n  blue: string;\n  yellow: string;\n  magenta: string;\n  cyan: string;\n  background: string;\n  window: string;\n  transparent: string;\n  'semi-transparent': string;\n  opaque: string;\n  'font-size': string;\n  'text-edge-style': string;\n  none: string;\n  uniform: string;\n  'drop-shadow': string;\n  'font-family': string;\n  'proportional-sans-serif': string;\n  'monospace-sans-serif': string;\n  'proportional-serif': string;\n  'monospace-serif': string;\n  'small-caps': string;\n  reset: string;\n  'restore-all-settings-to-the-default-values': string;\n  done: string;\n  'caption-settings-dialog': string;\n  'beginning-of-dialog-window.-escape-will-cancel-and-close-the-window.': string;\n  'end-of-dialog-window.': string;\n  '{1}-is-loading.': string;\n  'exit-picture-in-picture': string;\n  'picture-in-picture': string;\n  color: string;\n  opacity: string;\n  'text-background': string;\n  'caption-area-background': string;\n  'skip-forward-{1}-seconds': string;\n  'skip-backward-{1}-seconds': string;\n}\n\nexport type { VideoJsTranslation, VideoPlayerTranslations };\n"]}

package/esm2022/lib/components/core/video-player/video-player-i18n.service.mjs

@@ -0,0 +1,130 @@
+import { inject, Injectable } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { TranslateService } from '@ngx-translate/core';
+import { tap } from 'rxjs';
+import videojs from 'video.js';
+import * as i0 from "@angular/core";
+export class VideoPlayerI18nService {
+    #translate = inject(TranslateService);
+    init(player, destroyRef) {
+        this.#translate.onLangChange
+            .pipe(takeUntilDestroyed(destroyRef), tap({
+            next: e => {
+                const language = e.lang;
+                videojs.addLanguage(language, this.getTranslations());
+                player.language(language);
+            },
+        }))
+            .subscribe(x => {
+            console.log('onLangChange', x);
+        });
+    }
+    getLanguage() {
+        const language = this.#translate.currentLang ?? 'it';
+        return {
+            languages: { [language]: mapToVideoJsTranslation(this.#translate.instant('it.video-player')) },
+            language,
+        };
+    }
+    getTranslations() {
+        return mapToVideoJsTranslation(this.#translate.instant('it.video-player'));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VideoPlayerI18nService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VideoPlayerI18nService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VideoPlayerI18nService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function mapToVideoJsTranslation(translations) {
+    return {
+        'Audio Player': translations['audio-player'],
+        'Video Player': translations['video-player'],
+        Play: translations.play,
+        Pause: translations.pause,
+        Replay: translations.replay,
+        'Current Time': translations['current-time'],
+        Duration: translations.duration,
+        'Remaining Time': translations['remaining-time'],
+        'Stream Type': translations['stream-type'],
+        LIVE: translations.live,
+        Loaded: translations.loaded,
+        Progress: translations.progress,
+        'Progress Bar': translations['progress-bar'],
+        'progress bar timing: currentTime={1} duration={2}': translations['progress-bar-timing:-currenttime={1}-duration={2}'],
+        Fullscreen: translations.fullscreen,
+        'Exit Fullscreen': translations['exit-fullscreen'],
+        Mute: translations.mute,
+        Unmute: translations.unmute,
+        'Playback Rate': translations['playback-rate'],
+        Subtitles: translations.subtitles,
+        'subtitles off': translations['subtitles-off'],
+        Captions: translations.captions,
+        'captions off': translations['captions-off'],
+        Chapters: translations.chapters,
+        Descriptions: translations.descriptions,
+        'descriptions off': translations['descriptions-off'],
+        'Audio Track': translations['audio-track'],
+        'Volume Level': translations['volume-level'],
+        'You aborted the media playback': translations['you-aborted-the-media-playback'],
+        'A network error caused the media download to fail part-way.': translations['a-network-error-caused-the-media-download-to-fail-part-way.'],
+        'The media could not be loaded, either because the server or network failed or because the format is not supported.': translations['the-media-could-not-be-loaded,-either-because-the-server-or-network-failed-or-because-the-format-is-not-supported.'],
+        'The media playback was aborted due to a corruption problem or because the media used features your browser did not support.': translations['the-media-playback-was-aborted-due-to-a-corruption-problem-or-because-the-media-used-features-your-browser-did-not-support.'],
+        'No compatible source was found for this media.': translations['no-compatible-source-was-found-for-this-media.'],
+        'The media is encrypted and we do not have the keys to decrypt it.': translations['the-media-is-encrypted-and-we-do-not-have-the-keys-to-decrypt-it.'],
+        'Play Video': translations['play-video'],
+        Close: translations.close,
+        'Close Modal Dialog': translations['close-modal-dialog'],
+        'Modal Window': translations['modal-window'],
+        'This is a modal window': translations['this-is-a-modal-window'],
+        'This modal can be closed by pressing the Escape key or activating the close button.': translations['this-modal-can-be-closed-by-pressing-the-escape-key-or-activating-the-close-button.'],
+        ', opens captions settings dialog': translations[',-opens-captions-settings-dialog'],
+        ', opens subtitles settings dialog': translations[',-opens-subtitles-settings-dialog'],
+        ', opens descriptions settings dialog': translations[',-opens-descriptions-settings-dialog'],
+        ', selected': translations[',-selected'],
+        'captions settings': translations['captions-settings'],
+        'subtitles settings': translations['subtitles-settings'],
+        'descriptions settings': translations['descriptions-settings'],
+        Text: translations.text,
+        White: translations.white,
+        Black: translations.black,
+        Red: translations.red,
+        Green: translations.green,
+        Blue: translations.blue,
+        Yellow: translations.yellow,
+        Magenta: translations.magenta,
+        Cyan: translations.cyan,
+        Background: translations.background,
+        Window: translations.window,
+        Transparent: translations.transparent,
+        'Semi-Transparent': translations['semi-transparent'],
+        Opaque: translations.opaque,
+        'Font Size': translations['font-size'],
+        'Text Edge Style': translations['text-edge-style'],
+        None: translations.none,
+        Uniform: translations.uniform,
+        'Drop shadow': translations['drop-shadow'],
+        'Font Family': translations['font-family'],
+        'Proportional Sans-Serif': translations['proportional-sans-serif'],
+        'Monospace Sans-Serif': translations['monospace-sans-serif'],
+        'Proportional Serif': translations['proportional-serif'],
+        'Monospace Serif': translations['monospace-serif'],
+        'Small Caps': translations['small-caps'],
+        Reset: translations.reset,
+        'restore all settings to the default values': translations['restore-all-settings-to-the-default-values'],
+        Done: translations.done,
+        'Caption Settings Dialog': translations['caption-settings-dialog'],
+        'Beginning of dialog window. Escape will cancel and close the window.': translations['beginning-of-dialog-window.-escape-will-cancel-and-close-the-window.'],
+        'End of dialog window.': translations['end-of-dialog-window.'],
+        '{1} is loading.': translations['{1}-is-loading.'],
+        'Exit Picture-in-Picture': translations['exit-picture-in-picture'],
+        'Picture-in-Picture': translations['picture-in-picture'],
+        Color: translations.color,
+        Opacity: translations.opacity,
+        'Text Background': translations['text-background'],
+        'Caption Area Background': translations['caption-area-background'],
+        'Skip forward {1} seconds': translations['skip-forward-{1}-seconds'],
+        'Skip backward {1} seconds': translations['skip-backward-{1}-seconds'],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"video-player-i18n.service.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/core/video-player/video-player-i18n.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, inject, Injectable } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { TranslateService } from '@ngx-translate/core';\nimport { tap } from 'rxjs';\nimport videojs from 'video.js';\nimport Player from 'video.js/dist/types/player';\nimport { VideoJsTranslation, VideoPlayerTranslations } from './video-player-i18n.model';\n\n@Injectable({ providedIn: 'root' })\nexport class VideoPlayerI18nService {\n  readonly #translate = inject(TranslateService);\n\n  init(player: Player, destroyRef: DestroyRef) {\n    this.#translate.onLangChange\n      .pipe(\n        takeUntilDestroyed(destroyRef),\n        tap({\n          next: e => {\n            const language = e.lang;\n            videojs.addLanguage(language, this.getTranslations());\n            player.language(language);\n          },\n        })\n      )\n      .subscribe(x => {\n        console.log('onLangChange', x);\n      });\n  }\n\n  getLanguage() {\n    const language = this.#translate.currentLang ?? 'it';\n\n    return {\n      languages: { [language]: mapToVideoJsTranslation(this.#translate.instant('it.video-player')) },\n      language,\n    };\n  }\n\n  private getTranslations() {\n    return mapToVideoJsTranslation(this.#translate.instant('it.video-player'));\n  }\n}\n\nfunction mapToVideoJsTranslation(translations: VideoPlayerTranslations): VideoJsTranslation {\n  return {\n    'Audio Player': translations['audio-player'],\n    'Video Player': translations['video-player'],\n    Play: translations.play,\n    Pause: translations.pause,\n    Replay: translations.replay,\n    'Current Time': translations['current-time'],\n    Duration: translations.duration,\n    'Remaining Time': translations['remaining-time'],\n    'Stream Type': translations['stream-type'],\n    LIVE: translations.live,\n    Loaded: translations.loaded,\n    Progress: translations.progress,\n    'Progress Bar': translations['progress-bar'],\n    'progress bar timing: currentTime={1} duration={2}': translations['progress-bar-timing:-currenttime={1}-duration={2}'],\n    Fullscreen: translations.fullscreen,\n    'Exit Fullscreen': translations['exit-fullscreen'],\n    Mute: translations.mute,\n    Unmute: translations.unmute,\n    'Playback Rate': translations['playback-rate'],\n    Subtitles: translations.subtitles,\n    'subtitles off': translations['subtitles-off'],\n    Captions: translations.captions,\n    'captions off': translations['captions-off'],\n    Chapters: translations.chapters,\n    Descriptions: translations.descriptions,\n    'descriptions off': translations['descriptions-off'],\n    'Audio Track': translations['audio-track'],\n    'Volume Level': translations['volume-level'],\n    'You aborted the media playback': translations['you-aborted-the-media-playback'],\n    'A network error caused the media download to fail part-way.':\n      translations['a-network-error-caused-the-media-download-to-fail-part-way.'],\n    'The media could not be loaded, either because the server or network failed or because the format is not supported.':\n      translations['the-media-could-not-be-loaded,-either-because-the-server-or-network-failed-or-because-the-format-is-not-supported.'],\n    'The media playback was aborted due to a corruption problem or because the media used features your browser did not support.':\n      translations[\n        'the-media-playback-was-aborted-due-to-a-corruption-problem-or-because-the-media-used-features-your-browser-did-not-support.'\n      ],\n    'No compatible source was found for this media.': translations['no-compatible-source-was-found-for-this-media.'],\n    'The media is encrypted and we do not have the keys to decrypt it.':\n      translations['the-media-is-encrypted-and-we-do-not-have-the-keys-to-decrypt-it.'],\n    'Play Video': translations['play-video'],\n    Close: translations.close,\n    'Close Modal Dialog': translations['close-modal-dialog'],\n    'Modal Window': translations['modal-window'],\n    'This is a modal window': translations['this-is-a-modal-window'],\n    'This modal can be closed by pressing the Escape key or activating the close button.':\n      translations['this-modal-can-be-closed-by-pressing-the-escape-key-or-activating-the-close-button.'],\n    ', opens captions settings dialog': translations[',-opens-captions-settings-dialog'],\n    ', opens subtitles settings dialog': translations[',-opens-subtitles-settings-dialog'],\n    ', opens descriptions settings dialog': translations[',-opens-descriptions-settings-dialog'],\n    ', selected': translations[',-selected'],\n    'captions settings': translations['captions-settings'],\n    'subtitles settings': translations['subtitles-settings'],\n    'descriptions settings': translations['descriptions-settings'],\n    Text: translations.text,\n    White: translations.white,\n    Black: translations.black,\n    Red: translations.red,\n    Green: translations.green,\n    Blue: translations.blue,\n    Yellow: translations.yellow,\n    Magenta: translations.magenta,\n    Cyan: translations.cyan,\n    Background: translations.background,\n    Window: translations.window,\n    Transparent: translations.transparent,\n    'Semi-Transparent': translations['semi-transparent'],\n    Opaque: translations.opaque,\n    'Font Size': translations['font-size'],\n    'Text Edge Style': translations['text-edge-style'],\n    None: translations.none,\n    Uniform: translations.uniform,\n    'Drop shadow': translations['drop-shadow'],\n    'Font Family': translations['font-family'],\n    'Proportional Sans-Serif': translations['proportional-sans-serif'],\n    'Monospace Sans-Serif': translations['monospace-sans-serif'],\n    'Proportional Serif': translations['proportional-serif'],\n    'Monospace Serif': translations['monospace-serif'],\n    'Small Caps': translations['small-caps'],\n    Reset: translations.reset,\n    'restore all settings to the default values': translations['restore-all-settings-to-the-default-values'],\n    Done: translations.done,\n    'Caption Settings Dialog': translations['caption-settings-dialog'],\n    'Beginning of dialog window. Escape will cancel and close the window.':\n      translations['beginning-of-dialog-window.-escape-will-cancel-and-close-the-window.'],\n    'End of dialog window.': translations['end-of-dialog-window.'],\n    '{1} is loading.': translations['{1}-is-loading.'],\n    'Exit Picture-in-Picture': translations['exit-picture-in-picture'],\n    'Picture-in-Picture': translations['picture-in-picture'],\n    Color: translations.color,\n    Opacity: translations.opacity,\n    'Text Background': translations['text-background'],\n    'Caption Area Background': translations['caption-area-background'],\n    'Skip forward {1} seconds': translations['skip-forward-{1}-seconds'],\n    'Skip backward {1} seconds': translations['skip-backward-{1}-seconds'],\n  };\n}\n"]}