design-angular-kit 1.2.2 → 1.3.1

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"]}

package/esm2022/lib/components/core/video-player/video-player.component.mjs

@@ -0,0 +1,301 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { afterNextRender, ChangeDetectionStrategy, Component, DestroyRef, inject, Injector, Input, NgZone, signal, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { delay } from 'rxjs';
+import videojs from 'video.js';
+import { ItAbstractComponent } from '../../../abstracts/abstract.component';
+import { VideoPlayerI18nService } from './video-player-i18n.service';
+import { cookies } from './video-player.cookie';
+import * as i0 from "@angular/core";
+import * as i1 from "./video-player.config";
+var ViewType;
+(function (ViewType) {
+    ViewType["Default"] = "DEFAULT";
+    ViewType["Overlay"] = "OVERLAY";
+})(ViewType || (ViewType = {}));
+/**
+ * Video Player
+ * @description Component that allows playing a video.
+ */
+export class ItVideoPlayerComponent extends ItAbstractComponent {
+    #destroyRef;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.player = null;
+        this.viewTypes = ViewType;
+        this.viewType = signal(undefined);
+        this.cookieAccepted = signal(false);
+        this.i18nService = inject(VideoPlayerI18nService);
+        this.#destroyRef = inject(DestroyRef);
+        this.ngZone = inject(NgZone);
+        this.injector = inject(Injector);
+        afterNextRender(() => {
+            if (this.viewType() === ViewType.Overlay && cookies.isChoiceRemembered('youtube.com')) {
+                this.hideOverlay();
+            }
+        });
+        this.#destroyRef.onDestroy(() => this.player?.dispose());
+    }
+    async ngOnInit() {
+        const config = this.config.mergeConfig(this.options);
+        this.setViewType(config);
+        // Avoid running change detections while the script is being loaded.
+        await this.ngZone.runOutsideAngular(() => this.config.configureTech(config));
+        if (!this.videoPlayerRef) {
+            // Note: No need to pipe with `takeUntilDestroyed`; `toObservable` is
+            // completed by Angular when the `DestroyRef` from the injector is destroyed.
+            toObservable(this.cookieAccepted, { injector: this.injector })
+                .pipe(delay(0))
+                .subscribe(value => {
+                if (value && !this.player) {
+                    this.initVideoPlayer();
+                }
+            });
+            return;
+        }
+        this.initVideoPlayer();
+    }
+    acceptCookieHandler() {
+        this.rememberHandler();
+        this.hideOverlay();
+        this.cookieAccepted.set(true);
+    }
+    initVideoPlayer() {
+        const config = this.config.mergeConfig(this.options);
+        this.setVideoAttributes(config);
+        this.setVideoPlayer();
+    }
+    setVideoPlayer() {
+        const config = this.config.mergeConfig(this.options);
+        const onPlayerReadyCb = () => {
+            if (!this.player) {
+                return;
+            }
+            this.i18nService.init(this.player, this.#destroyRef);
+        };
+        const element = this.videoPlayerRef?.nativeElement;
+        if (!element) {
+            throw Error('videoPlayerRef is undefined');
+        }
+        this.player = this.ngZone.runOutsideAngular(() => videojs(element, config, onPlayerReadyCb));
+    }
+    setViewType(config) {
+        this.viewType.set(config.tech === 'youtube' ? ViewType.Overlay : ViewType.Default);
+        this.cookieAccepted.set(this.viewType() === ViewType.Overlay && cookies.isChoiceRemembered('youtube.com'));
+    }
+    hideOverlay() {
+        if (!this.acceptOverlayableRef) {
+            return;
+        }
+        const classes = ['show'];
+        this.acceptOverlayableRef.nativeElement.classList.remove(...classes);
+        if (!this.acceptOveralyRef) {
+            return;
+        }
+        this.acceptOveralyRef.nativeElement.classList.remove(...classes);
+        this.acceptOveralyRef.nativeElement.setAttribute('aria-hidden', 'true');
+    }
+    rememberHandler() {
+        if (!this.chrRememberRef) {
+            return;
+        }
+        const remember = this.chrRememberRef.nativeElement.checked;
+        cookies.rememberChoice('youtube.com', remember);
+    }
+    setVideoAttributes(options) {
+        if (!this.videoPlayerRef) {
+            return;
+        }
+        const v = this.videoPlayerRef.nativeElement;
+        const { autoplay, controls, loop, muted, poster, fluid } = options;
+        if (autoplay) {
+            v.setAttribute('autoplay', autoplay.toString());
+        }
+        if (controls) {
+            v.setAttribute('controls', '');
+        }
+        if (loop) {
+            v.setAttribute('loop', '');
+        }
+        if (muted) {
+            v.setAttribute('muted', '');
+        }
+        if (poster) {
+            v.setAttribute('poster', poster);
+        }
+        if (fluid) {
+            v.setAttribute('fluid', '');
+        }
+        v.setAttribute('preload', 'none');
+        v.setAttribute('playsinline', '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItVideoPlayerComponent, deps: [{ token: i1.VideoPlayerConfigService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.6", type: ItVideoPlayerComponent, isStandalone: true, selector: "it-video-player", inputs: { options: "options" }, viewQueries: [{ propertyName: "videoPlayerRef", first: true, predicate: ["videoPlayer"], descendants: true }, { propertyName: "acceptOveralyRef", first: true, predicate: ["acceptOveraly"], descendants: true }, { propertyName: "acceptOverlayableRef", first: true, predicate: ["acceptOverlayable"], descendants: true }, { propertyName: "chrRememberRef", first: true, predicate: ["chkRemember"], descendants: true }], usesInheritance: true, ngImport: i0, template: `@switch (viewType()) {
+      @case (viewTypes.Default) {
+        <div class="row">
+          <ng-container *ngTemplateOutlet="videoTemplate"></ng-container>
+          <ng-container *ngTemplateOutlet="transcriptionTemplate"></ng-container>
+        </div>
+      }
+      @case (viewTypes.Overlay) {
+        <div #acceptOverlayable class="acceptoverlayable show">
+          <div #acceptOveraly class="acceptoverlay acceptoverlay-primary fade show">
+            <div class="acceptoverlay-inner">
+              <div class="acceptoverlay-icon">
+                <svg class="icon icon-xl"><use href="/bootstrap-italia/dist/svg/sprites.svg#it-video"></use></svg>
+              </div>
+              <p>
+                Accetta i cookie di YouTube per vedere il video. Puoi gestire le preferenze nella
+                <a href="#" class="text-white">cookie policy</a>.
+              </p>
+              <div class="acceptoverlay-buttons bg-dark">
+                <button type="button" class="btn btn-primary" (click)="acceptCookieHandler()">Accetta</button>
+                <div class="form-check">
+                  <input id="chk-remember{{ id }}" type="checkbox" #chkRemember />
+                  <label for="chk-remember{{ id }}">Ricorda per tutti i video</label>
+                </div>
+              </div>
+            </div>
+          </div>
+          @if (cookieAccepted()) {
+            <div>
+              <ng-container *ngTemplateOutlet="videoTemplate"></ng-container>
+              <ng-container *ngTemplateOutlet="transcriptionTemplate"></ng-container>
+            </div>
+          }
+        </div>
+      }
+      @default {
+        <h1>No video provider</h1>
+      }
+    }
+    <ng-template #videoTemplate>
+      <div>
+        <video #videoPlayer class="video-js vjs-theme-bootstrap-italia vjs-fluid vjs-big-play-centered"></video>
+      </div>
+    </ng-template>
+
+    <ng-template #transcriptionTemplate>
+      <div class="vjs-transcription accordion">
+        <div class="accordion-item">
+          <h2 class="accordion-header " id="transcription-{{ id }}-head">
+            <button
+              class="accordion-button collapsed"
+              type="button"
+              data-bs-toggle="collapse"
+              [attr.data-bs-target]="'#transcription-' + id"
+              [attr.aria-controls]="'transcription-' + id"
+              aria-expanded="true">
+              <ng-content select="[transcriptionTitle]">Trascrizione</ng-content>
+            </button>
+          </h2>
+          <div
+            id="transcription-{{ id }}"
+            class="accordion-collapse collapse"
+            role="region"
+            [attr.aria-labelledby]="'transcription-' + id + '-head'">
+            <div class="accordion-body">
+              <ng-content select="[transcriptionText]">-</ng-content>
+            </div>
+          </div>
+        </div>
+      </div>
+    </ng-template> `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItVideoPlayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'it-video-player',
+                    template: `@switch (viewType()) {
+      @case (viewTypes.Default) {
+        <div class="row">
+          <ng-container *ngTemplateOutlet="videoTemplate"></ng-container>
+          <ng-container *ngTemplateOutlet="transcriptionTemplate"></ng-container>
+        </div>
+      }
+      @case (viewTypes.Overlay) {
+        <div #acceptOverlayable class="acceptoverlayable show">
+          <div #acceptOveraly class="acceptoverlay acceptoverlay-primary fade show">
+            <div class="acceptoverlay-inner">
+              <div class="acceptoverlay-icon">
+                <svg class="icon icon-xl"><use href="/bootstrap-italia/dist/svg/sprites.svg#it-video"></use></svg>
+              </div>
+              <p>
+                Accetta i cookie di YouTube per vedere il video. Puoi gestire le preferenze nella
+                <a href="#" class="text-white">cookie policy</a>.
+              </p>
+              <div class="acceptoverlay-buttons bg-dark">
+                <button type="button" class="btn btn-primary" (click)="acceptCookieHandler()">Accetta</button>
+                <div class="form-check">
+                  <input id="chk-remember{{ id }}" type="checkbox" #chkRemember />
+                  <label for="chk-remember{{ id }}">Ricorda per tutti i video</label>
+                </div>
+              </div>
+            </div>
+          </div>
+          @if (cookieAccepted()) {
+            <div>
+              <ng-container *ngTemplateOutlet="videoTemplate"></ng-container>
+              <ng-container *ngTemplateOutlet="transcriptionTemplate"></ng-container>
+            </div>
+          }
+        </div>
+      }
+      @default {
+        <h1>No video provider</h1>
+      }
+    }
+    <ng-template #videoTemplate>
+      <div>
+        <video #videoPlayer class="video-js vjs-theme-bootstrap-italia vjs-fluid vjs-big-play-centered"></video>
+      </div>
+    </ng-template>
+
+    <ng-template #transcriptionTemplate>
+      <div class="vjs-transcription accordion">
+        <div class="accordion-item">
+          <h2 class="accordion-header " id="transcription-{{ id }}-head">
+            <button
+              class="accordion-button collapsed"
+              type="button"
+              data-bs-toggle="collapse"
+              [attr.data-bs-target]="'#transcription-' + id"
+              [attr.aria-controls]="'transcription-' + id"
+              aria-expanded="true">
+              <ng-content select="[transcriptionTitle]">Trascrizione</ng-content>
+            </button>
+          </h2>
+          <div
+            id="transcription-{{ id }}"
+            class="accordion-collapse collapse"
+            role="region"
+            [attr.aria-labelledby]="'transcription-' + id + '-head'">
+            <div class="accordion-body">
+              <ng-content select="[transcriptionText]">-</ng-content>
+            </div>
+          </div>
+        </div>
+      </div>
+    </ng-template> `,
+                    imports: [NgTemplateOutlet],
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [{ type: i1.VideoPlayerConfigService }], propDecorators: { options: [{
+                type: Input
+            }], videoPlayerRef: [{
+                type: ViewChild,
+                args: ['videoPlayer', { static: false }]
+            }], acceptOveralyRef: [{
+                type: ViewChild,
+                args: ['acceptOveraly', { static: false }]
+            }], acceptOverlayableRef: [{
+                type: ViewChild,
+                args: ['acceptOverlayable', { static: false }]
+            }], chrRememberRef: [{
+                type: ViewChild,
+                args: ['chkRemember', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"video-player.component.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/core/video-player/video-player.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n  afterNextRender,\n  ChangeDetectionStrategy,\n  Component,\n  DestroyRef,\n  ElementRef,\n  inject,\n  Injector,\n  Input,\n  NgZone,\n  OnInit,\n  signal,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { delay } from 'rxjs';\nimport videojs from 'video.js';\nimport type Player from 'video.js/dist/types/player';\n\nimport { ItAbstractComponent } from '../../../abstracts/abstract.component';\nimport { VideoPlayerI18nService } from './video-player-i18n.service';\nimport { Tech, VideoPlayerConfigService } from './video-player.config';\nimport { cookies } from './video-player.cookie';\nimport { ItVideoPlayerConfig, ItVideoPlayerOptions } from './video-player.model';\n\nenum ViewType {\n  Default = 'DEFAULT',\n  Overlay = 'OVERLAY',\n}\n\n/**\n * Video Player\n * @description Component that allows playing a video.\n */\n@Component({\n  standalone: true,\n  selector: 'it-video-player',\n  template: `@switch (viewType()) {\n      @case (viewTypes.Default) {\n        <div class=\"row\">\n          <ng-container *ngTemplateOutlet=\"videoTemplate\"></ng-container>\n          <ng-container *ngTemplateOutlet=\"transcriptionTemplate\"></ng-container>\n        </div>\n      }\n      @case (viewTypes.Overlay) {\n        <div #acceptOverlayable class=\"acceptoverlayable show\">\n          <div #acceptOveraly class=\"acceptoverlay acceptoverlay-primary fade show\">\n            <div class=\"acceptoverlay-inner\">\n              <div class=\"acceptoverlay-icon\">\n                <svg class=\"icon icon-xl\"><use href=\"/bootstrap-italia/dist/svg/sprites.svg#it-video\"></use></svg>\n              </div>\n              <p>\n                Accetta i cookie di YouTube per vedere il video. Puoi gestire le preferenze nella\n                <a href=\"#\" class=\"text-white\">cookie policy</a>.\n              </p>\n              <div class=\"acceptoverlay-buttons bg-dark\">\n                <button type=\"button\" class=\"btn btn-primary\" (click)=\"acceptCookieHandler()\">Accetta</button>\n                <div class=\"form-check\">\n                  <input id=\"chk-remember{{ id }}\" type=\"checkbox\" #chkRemember />\n                  <label for=\"chk-remember{{ id }}\">Ricorda per tutti i video</label>\n                </div>\n              </div>\n            </div>\n          </div>\n          @if (cookieAccepted()) {\n            <div>\n              <ng-container *ngTemplateOutlet=\"videoTemplate\"></ng-container>\n              <ng-container *ngTemplateOutlet=\"transcriptionTemplate\"></ng-container>\n            </div>\n          }\n        </div>\n      }\n      @default {\n        <h1>No video provider</h1>\n      }\n    }\n    <ng-template #videoTemplate>\n      <div>\n        <video #videoPlayer class=\"video-js vjs-theme-bootstrap-italia vjs-fluid vjs-big-play-centered\"></video>\n      </div>\n    </ng-template>\n\n    <ng-template #transcriptionTemplate>\n      <div class=\"vjs-transcription accordion\">\n        <div class=\"accordion-item\">\n          <h2 class=\"accordion-header \" id=\"transcription-{{ id }}-head\">\n            <button\n              class=\"accordion-button collapsed\"\n              type=\"button\"\n              data-bs-toggle=\"collapse\"\n              [attr.data-bs-target]=\"'#transcription-' + id\"\n              [attr.aria-controls]=\"'transcription-' + id\"\n              aria-expanded=\"true\">\n              <ng-content select=\"[transcriptionTitle]\">Trascrizione</ng-content>\n            </button>\n          </h2>\n          <div\n            id=\"transcription-{{ id }}\"\n            class=\"accordion-collapse collapse\"\n            role=\"region\"\n            [attr.aria-labelledby]=\"'transcription-' + id + '-head'\">\n            <div class=\"accordion-body\">\n              <ng-content select=\"[transcriptionText]\">-</ng-content>\n            </div>\n          </div>\n        </div>\n      </div>\n    </ng-template> `,\n  imports: [NgTemplateOutlet],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ItVideoPlayerComponent extends ItAbstractComponent implements OnInit {\n  /**\n   * Options for video player configuration\n   */\n  @Input() options!: ItVideoPlayerOptions;\n\n  @ViewChild('videoPlayer', { static: false }) videoPlayerRef?: ElementRef<HTMLVideoElement>;\n\n  @ViewChild('acceptOveraly', { static: false }) acceptOveralyRef?: ElementRef<HTMLDivElement>;\n\n  @ViewChild('acceptOverlayable', { static: false }) acceptOverlayableRef?: ElementRef<HTMLDivElement>;\n\n  @ViewChild('chkRemember', { static: false }) chrRememberRef?: ElementRef<HTMLInputElement>;\n\n  player: Player | null = null;\n\n  readonly viewTypes = ViewType;\n\n  readonly viewType = signal<ViewType | undefined>(undefined);\n\n  readonly cookieAccepted = signal(false);\n\n  protected readonly i18nService = inject(VideoPlayerI18nService);\n\n  readonly #destroyRef = inject(DestroyRef);\n\n  private ngZone = inject(NgZone);\n  private injector = inject(Injector);\n\n  constructor(private config: VideoPlayerConfigService) {\n    super();\n\n    afterNextRender(() => {\n      if (this.viewType() === ViewType.Overlay && cookies.isChoiceRemembered('youtube.com')) {\n        this.hideOverlay();\n      }\n    });\n\n    this.#destroyRef.onDestroy(() => this.player?.dispose());\n  }\n\n  async ngOnInit() {\n    const config = this.config.mergeConfig(this.options);\n    this.setViewType(config);\n    // Avoid running change detections while the script is being loaded.\n    await this.ngZone.runOutsideAngular(() => this.config.configureTech(config as { tech: Tech }));\n\n    if (!this.videoPlayerRef) {\n      // Note: No need to pipe with `takeUntilDestroyed`; `toObservable` is\n      // completed by Angular when the `DestroyRef` from the injector is destroyed.\n      toObservable(this.cookieAccepted, { injector: this.injector })\n        .pipe(delay(0))\n        .subscribe(value => {\n          if (value && !this.player) {\n            this.initVideoPlayer();\n          }\n        });\n\n      return;\n    }\n\n    this.initVideoPlayer();\n  }\n\n  acceptCookieHandler() {\n    this.rememberHandler();\n    this.hideOverlay();\n    this.cookieAccepted.set(true);\n  }\n\n  private initVideoPlayer() {\n    const config = this.config.mergeConfig(this.options);\n    this.setVideoAttributes(config);\n    this.setVideoPlayer();\n  }\n\n  private setVideoPlayer() {\n    const config = this.config.mergeConfig(this.options);\n    const onPlayerReadyCb = () => {\n      if (!this.player) {\n        return;\n      }\n      this.i18nService.init(this.player, this.#destroyRef);\n    };\n\n    const element = this.videoPlayerRef?.nativeElement;\n    if (!element) {\n      throw Error('videoPlayerRef is undefined');\n    }\n\n    this.player = this.ngZone.runOutsideAngular(() => videojs(element, config, onPlayerReadyCb));\n  }\n\n  private setViewType(config: ItVideoPlayerConfig) {\n    this.viewType.set(config.tech === 'youtube' ? ViewType.Overlay : ViewType.Default);\n\n    this.cookieAccepted.set(this.viewType() === ViewType.Overlay && cookies.isChoiceRemembered('youtube.com'));\n  }\n\n  private hideOverlay() {\n    if (!this.acceptOverlayableRef) {\n      return;\n    }\n    const classes = ['show'];\n    this.acceptOverlayableRef.nativeElement.classList.remove(...classes);\n    if (!this.acceptOveralyRef) {\n      return;\n    }\n    this.acceptOveralyRef.nativeElement.classList.remove(...classes);\n    this.acceptOveralyRef.nativeElement.setAttribute('aria-hidden', 'true');\n  }\n\n  private rememberHandler() {\n    if (!this.chrRememberRef) {\n      return;\n    }\n    const remember = this.chrRememberRef.nativeElement.checked;\n    cookies.rememberChoice('youtube.com', remember);\n  }\n\n  private setVideoAttributes(options: ItVideoPlayerOptions) {\n    if (!this.videoPlayerRef) {\n      return;\n    }\n    const v = this.videoPlayerRef.nativeElement;\n\n    const { autoplay, controls, loop, muted, poster, fluid } = options;\n\n    if (autoplay) {\n      v.setAttribute('autoplay', autoplay.toString());\n    }\n\n    if (controls) {\n      v.setAttribute('controls', '');\n    }\n\n    if (loop) {\n      v.setAttribute('loop', '');\n    }\n\n    if (muted) {\n      v.setAttribute('muted', '');\n    }\n\n    if (poster) {\n      v.setAttribute('poster', poster);\n    }\n\n    if (fluid) {\n      v.setAttribute('fluid', '');\n    }\n\n    v.setAttribute('preload', 'none');\n    v.setAttribute('playsinline', '');\n  }\n}\n"]}

package/esm2022/lib/components/core/video-player/video-player.config.mjs

@@ -0,0 +1,43 @@
+import { inject, Injectable } from '@angular/core';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import { initYoutubePlugin } from 'bootstrap-italia/dist/plugins/util/youtube-video.js';
+import videojs from 'video.js';
+import { VideoPlayerI18nService } from './video-player-i18n.service';
+import * as i0 from "@angular/core";
+const hasYoutubeVideo = (options) => options.source?.type === 'video/youtube';
+export class VideoPlayerConfigService {
+    #languageService = inject(VideoPlayerI18nService);
+    async configureTech({ tech }) {
+        if (tech === 'youtube') {
+            initYoutubePlugin(videojs);
+        }
+    }
+    mergeConfig(o) {
+        const options = o;
+        const captions = options.captions ? options.captions.map(c => ({ ...c, kind: 'captions' })) : [];
+        const chapters = options.chapters ? options.chapters.map(c => ({ ...c, kind: 'chapters' })) : [];
+        const isYoutubeVideo = hasYoutubeVideo(options);
+        const DEFAULT_CONFIG = this.#languageService.getLanguage();
+        const tech = isYoutubeVideo ? 'youtube' : 'html5';
+        const techOrder = [tech];
+        //https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video#preload
+        const preload = options.preload ?? 'metadata';
+        const config = { ...DEFAULT_CONFIG, ...options, preload, techOrder, tracks: [...captions, ...chapters], tech: 'html5' };
+        return isYoutubeVideo
+            ? {
+                ...config,
+                sources: [o.source],
+                tech: 'youtube',
+                youtube: { ytControls: 2, rel: 0, fs: 0, modestbranding: 1 },
+            }
+            : config;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VideoPlayerConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VideoPlayerConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VideoPlayerConfigService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/core/video-player/video-player.cookie.mjs

@@ -0,0 +1,25 @@
+const preferencesMap = { ck3: {} };
+const STORAGE_KEY = 'bs-ck3';
+/*
+  Possible choices:
+  false => Accept once
+  true => Accept always
+*/
+const rememberChoice = (service, remember) => {
+    preferencesMap.ck3[service] = remember;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(preferencesMap.ck3));
+};
+const isChoiceRemembered = (service) => {
+    preferencesMap.ck3 = JSON.parse(localStorage.getItem(STORAGE_KEY) || '{}');
+    return Boolean(preferencesMap.ck3[service]) || false;
+};
+const clearAllRememberedChoices = () => {
+    localStorage.removeItem(STORAGE_KEY);
+};
+const cookies = {
+    rememberChoice,
+    isChoiceRemembered,
+    clearAllRememberedChoices,
+};
+export { cookies };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+// See options: https://videojs.com/guides/options
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/core/video-player/video-player.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { ItVideoPlayerComponent } from './video-player.component';
+import * as i0 from "@angular/core";
+export class ItVideoPlayerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItVideoPlayerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.6", ngImport: i0, type: ItVideoPlayerModule, imports: [ItVideoPlayerComponent], exports: [ItVideoPlayerComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItVideoPlayerModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItVideoPlayerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ItVideoPlayerComponent],
+                    exports: [ItVideoPlayerComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlkZW8tcGxheWVyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rlc2lnbi1hbmd1bGFyLWtpdC9zcmMvbGliL2NvbXBvbmVudHMvY29yZS92aWRlby1wbGF5ZXIvdmlkZW8tcGxheWVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDOztBQU1sRSxNQUFNLE9BQU8sbUJBQW1COzhHQUFuQixtQkFBbUI7K0dBQW5CLG1CQUFtQixZQUhwQixzQkFBc0IsYUFDdEIsc0JBQXNCOytHQUVyQixtQkFBbUI7OzJGQUFuQixtQkFBbUI7a0JBSi9CLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ2pDLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixDQUFDO2lCQUNsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJdFZpZGVvUGxheWVyQ29tcG9uZW50IH0gZnJvbSAnLi92aWRlby1wbGF5ZXIuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0l0VmlkZW9QbGF5ZXJDb21wb25lbnRdLFxuICBleHBvcnRzOiBbSXRWaWRlb1BsYXllckNvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIEl0VmlkZW9QbGF5ZXJNb2R1bGUge31cbiJdfQ==