itube-specs 0.0.195

package/runtime/utils/video-data-add-model-icon.ts

@@ -0,0 +1,20 @@
+import type { IRawModelCard, IRawVideoData } from '../../types';
+
+export function videoDataAddModelIcon(videoData: IRawVideoData, modelsData: Array<IRawModelCard>): IRawVideoData {
+  const transformedData = { ...videoData };
+
+  transformedData.models = transformedData.models?.map((model) => {
+    const modelData = modelsData.find((item) => item.guid === model.guid);
+
+    if (modelData) {
+      return {
+        ...model,
+        icon: modelData.primary_image_url,
+      };
+    }
+
+    return model;
+  });
+
+  return transformedData;
+}

package/runtime/utils/vtt-helper.ts

@@ -0,0 +1,86 @@
+export interface IVttItem {
+    start: number;
+    end: number;
+    coords: { x: number; y: number; w: number; h: number };
+}
+
+export class VttHelper {
+  private readonly vttUrl: string;
+  public hasInited: boolean;
+  private vttData: Array<IVttItem> | null;
+
+  constructor(vttUrl: string) {
+    this.vttUrl = vttUrl;
+    this.hasInited = false;
+    this.vttData = null;
+  }
+
+  async init(): Promise<void> {
+    const vttContent: Response = await fetch(this.vttUrl);
+
+    if (vttContent.body) {
+      const reader: ReadableStreamDefaultReader<string> = vttContent.body
+        .pipeThrough(new TextDecoderStream())
+        .getReader();
+      const vtt: ReadableStreamReadResult<string> = await reader.read();
+      this.vttData = this.parseVTT(vtt);
+      this.hasInited = true;
+    }
+  }
+
+  private parseCoords(coordsString: string): { x: number; y: number; w: number; h: number } {
+    const [x, y, w, h] = coordsString.split(',').map(Number);
+    return { x, y, w, h };
+  }
+
+  private parseVTT(vttContent: ReadableStreamReadResult<string>): Array<IVttItem> {
+    if (!vttContent.value) {
+      return [];
+    }
+
+    const lines: Array<string> = vttContent.value.split('\n');
+    const result: Array<IVttItem> = [];
+    let item: Partial<IVttItem> = {};
+
+    for (let i = 0; i < lines.length; i++) {
+      const line: string = lines[i].trim();
+
+      if (line.includes('-->')) {
+        const parts: Array<string> = line.split(' ');
+        item.start = this.timeToSeconds(parts[0]);
+        item.end = this.timeToSeconds(parts[2]);
+      } else if (line.includes('#xywh=')) {
+        item.coords = this.parseCoords(line.split('#xywh=')[1]);
+      } else if (line.includes('Img')) {
+        if (Object.values(item).length && item.start !== undefined && item.end !== undefined && item.coords) {
+          result.push(item as IVttItem);
+        }
+        item = {};
+      }
+    }
+
+    return result;
+  }
+
+  private timeToSeconds(time: string): number {
+    const parts: Array<string> = time.split(':');
+    const hh: number = parseInt(parts[0], 10);
+    const mm: number = parseInt(parts[1], 10);
+    const ss: number = parseFloat(parts[2].replace(',', '.'));
+
+    return hh * 3600 + mm * 60 + ss;
+  }
+
+  getCoordsByTime(time: number, vttData: Array<IVttItem> | null = this.vttData):
+      { x: number; y: number; w: number; h: number } | string {
+    if (!this.hasInited || !vttData) {
+      return 'No preview';
+    }
+
+    return (
+      vttData.find((item: IVttItem) => {
+        return time >= item.start && time <= item.end;
+      }) || vttData[0]
+    ).coords;
+  }
+}

package/types/authorization-forms.d.ts

@@ -0,0 +1,16 @@
+export interface IRegistrateForm {
+    email: string
+    password_hash: string
+    token: string
+    username: string
+}
+
+export interface ILoginForm {
+    username: string
+    password_hash: string
+}
+
+export interface IPasswordForm {
+    email: string
+    token: string
+}

package/types/breadcrumb-item.d.ts

@@ -0,0 +1,4 @@
+export interface IBreadcrumbItem {
+  name: string | string[]
+  to?: string
+}

package/types/button-sizes.d.ts

@@ -0,0 +1 @@
+export type ButtonSizes = 's' | 'm' | undefined

package/types/button-themes.d.ts

@@ -0,0 +1 @@
+export type ButtonThemes = 'primary' | 'secondary' | 'ghost' | 'bordered' | 'tab' | undefined

package/types/card-info.d.ts

@@ -0,0 +1,22 @@
+import type { IParameterModel } from './parameter-model';
+
+export interface ICardInfo {
+  title: string;
+  description: string;
+  videosCount: number;
+  thumbUrl: string;
+
+  guid?: string;
+  // Fields specific to Channel
+  url?: string;
+  isNetwork?: boolean;
+  updated?: number;
+  avatarUrl?: string;
+
+  // Fields specific to Model
+  orientation?: string;
+  social?: {
+    [key: string]: string | undefined;
+  };
+  parameters?: IParameterModel[]
+}

package/types/category-card.d.ts

@@ -0,0 +1,8 @@
+export interface ICategoryCard {
+  name: string;
+  title: string;
+  videosCount: number;
+  thumbUrl?: string;
+  guid: string;
+  isTop?: boolean,
+}

package/types/change-email-form.d.ts

@@ -0,0 +1,3 @@
+export interface IChangeEmail {
+    email: string
+}

package/types/change-password-form.d.ts

@@ -0,0 +1,4 @@
+export interface IChangePasswordForm {
+    currentPassword: string
+    newPassword: string
+}

package/types/channel-card.d.ts

@@ -0,0 +1,10 @@
+export interface IChannelCard {
+  guid: string;
+  name: string;
+  url: string;
+  videosCount: number;
+  isNetwork: boolean;
+  updated: number;
+  avatarUrl: string;
+  thumbUrl: string;
+}

package/types/chips-item.d.ts

@@ -0,0 +1,8 @@
+export interface IChipsItem {
+    title: string
+    value?: string | string[] | number
+    icon?: string
+    prefix?: string
+    key?: string
+    query?: string
+}

package/types/contacts-form.d.ts

@@ -0,0 +1,10 @@
+import type { EContactsSubjects } from '../runtime/enums/contacts-subjects';
+
+export interface IContactsForm {
+  subject: EContactsSubjects
+  message: string
+  name: string
+  from: string
+  token: string
+  data: Record<string, string | boolean>
+}

package/types/contacts-scheme.d.ts

@@ -0,0 +1,14 @@
+import type { EContactsSubjects } from '../runtime/enums/contacts-subjects';
+import type { InputTypes } from '../types';
+
+export interface IContactScheme {
+    subject: EContactsSubjects
+    items?: {
+        type: InputTypes | string
+        value: string
+        label?: string
+        required?: boolean
+        wide?: boolean
+        text?: string
+    }[]
+}

package/types/country.d.ts

@@ -0,0 +1,5 @@
+export interface ICountry {
+    guid: string
+    title: string
+    numCode: string
+}

package/types/css-breakpoints.d.ts

@@ -0,0 +1 @@
+export type CssBreakpoints = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

package/types/filter-scheme.d.ts

@@ -0,0 +1,37 @@
+import type { ISelectItem, ITabItem } from '../types';
+
+export type FilterSchemeItemType =
+  | 'select'
+  | 'input'
+  | 'tabs'
+
+interface IFilterSchemeItemBase {
+  type: FilterSchemeItemType
+  title: string
+  className?: string
+  label?: string
+  wide?: boolean
+  fixed?: boolean
+}
+
+interface IFilterSchemeItemSelect extends IFilterSchemeItemBase {
+  type: 'select'
+  items: ISelectItem[]
+  placeholder: string
+}
+
+interface IFilterSchemeItemTabs extends IFilterSchemeItemBase {
+  type: 'tabs'
+  items: ITabItem[]
+}
+
+interface IFilterSchemeItemInput extends IFilterSchemeItemBase {
+  type: 'input'
+}
+
+export type FilterSchemeItem =
+  | IFilterSchemeItemSelect
+  | IFilterSchemeItemInput
+  | IFilterSchemeItemTabs
+
+export type FilterSchemeType = FilterSchemeItem[]

package/types/fluid-player.d.ts

@@ -0,0 +1,226 @@
+declare function fluidPlayer(
+    target: HTMLVideoElement | string,
+    options?: Partial<FluidPlayerOptions>
+): FluidPlayerInstance;
+
+declare type AdditionalEventInfo = { mediaSourceType: 'source' | 'preRoll' | 'midRoll' | 'postRoll' };
+declare type OnPlay = (event: 'play', callback: (additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnPlaying =
+    (event: 'playing', callback: (event: Event, additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnPause = (event: 'pause', callback: (additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnEnded = (event: 'ended', callback: (additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnSeeked = (event: 'seeked', callback: (additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnTheaterModeOn =
+    (event: 'theatreModeOn', callback: (event: Event, additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnTheaterModeOff =
+    (event: 'theatreModeOff', callback: (event: Event, additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnTimeUpdate =
+    (event: 'timeupdate', callback: (time: number, additionalInfo: AdditionalEventInfo) => void) => void;
+declare type OnMiniPlayerToggle =
+    (event: 'miniPlayerToggle', callback: (event: CustomEvent<{
+        isToggledOn: boolean
+    }>, additionalInfo: AdditionalEventInfo) => void) => void;
+
+declare interface FluidPlayerInstance {
+    play: () => void;
+    pause: () => void;
+    skipTo: (seconds: number) => void;
+    setPlaybackSpeed: (speed: number) => void;
+    setVolume: (volume: number) => void;
+    toggleControlBar: (shouldToggle: boolean) => void;
+    toggleFullScreen: (shouldToggle: boolean) => void;
+    toggleMiniPlayer: (shouldToggle: boolean) => void;
+    setHtmlOnPauseBlock: (pauseBlock: { html: string; width: number; height: number; }) => void;
+    destroy: () => void;
+    dashInstance: () => any | null;
+    hlsInstance: () => any | null;
+    on: OnPlay & OnPlaying & OnPause & OnEnded & OnSeeked & OnTheaterModeOn & OnTheaterModeOff & OnTimeUpdate &
+        OnMiniPlayerToggle;
+}
+
+declare interface LayoutControls {
+    primaryColor: false | string;
+    posterImage: false | string;
+    posterImageSize: 'auto' | 'cover' | 'contain';
+    playButtonShowing: boolean;
+    playPauseAnimation: boolean;
+    fillToContainer: boolean;
+    autoPlay: boolean;
+    preload: 'none' | 'metadata' | 'auto' | string;
+    mute: boolean;
+    doubleclickFullscreen: boolean;
+    subtitlesEnabled: boolean;
+    keyboardControl: boolean;
+    title: string;
+    loop: boolean;
+    logo: Partial<{
+        imageUrl: string | null;
+        position: 'top right' | 'top left' | 'bottom right' | 'bottom left';
+        clickUrl: string | null;
+        opacity: number;
+        mouseOverImageUrl: string | null;
+        imageMargin: string;
+        hideWithControls: boolean;
+        showOverAds: boolean;
+    }>;
+    controlBar: Partial<{
+        autoHide: boolean;
+        autoHideTimeout: number;
+        animated: boolean;
+    }>;
+    timelinePreview: VTTPreviewOptions | StaticPreviewOptions;
+    htmlOnPauseBlock: Partial<{
+        html: string | null;
+        height: number | null;
+        width: number | null;
+    }>;
+    layout: 'default' | string;
+    allowDownload: boolean;
+    playbackRateEnabled: boolean;
+    allowTheatre: boolean;
+    theatreAdvanced: Partial<{
+        theatreElement: string;
+        classToApply: string;
+    }>;
+    theatreSettings: Partial<{
+        width: string;
+        height: string;
+        marginTop: number;
+        horizontalAlign: 'center' | 'left' | 'right';
+    }>;
+    playerInitCallback: () => void;
+    persistentSettings: Partial<{
+        volume: boolean;
+        quality: boolean;
+        speed: boolean;
+        theatre: boolean;
+    }>;
+    controlForwardBackward: Partial<{
+        show: boolean;
+        doubleTapMobile: boolean;
+    }>;
+    contextMenu: Partial<{
+        controls: boolean;
+        links: Array<{
+            href: string;
+            label: string;
+        }>;
+    }>;
+    miniPlayer: Partial<{
+        enabled: boolean;
+        width: number;
+        height: number;
+        widthMobile: number;
+        placeholderText: string;
+        position: 'top right' | 'top left' | 'bottom right' | 'bottom left';
+        autoToggle: boolean;
+    }>;
+    showCardBoardView: boolean;
+    showCardBoardJoystick: boolean;
+    roundedCorners: number;
+    autoRotateFullScreen: boolean;
+}
+
+declare interface VTTPreviewOptions {
+    file: string;
+    type: 'VTT';
+    spriteRelativePath?: boolean;
+    sprite?: string;
+}
+
+declare interface StaticPreviewOptions {
+    type: 'static';
+    frames: Array<{
+        startTime: number;
+        endTime: number;
+        image: string;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>
+}
+
+declare interface VastOptions {
+    adList: Array<PreRollAdOptions | MidRollAdOptions | PostRollAdOptions | OnPauseRollAdOptions>;
+    skipButtonCaption: string;
+    skipButtonClickCaption: string;
+    adText: string;
+    adTextPosition: 'top right' | 'top left' | 'bottom right' | 'bottom left';
+    adCTAText: string | boolean;
+    adCTATextPosition: 'top right' | 'top left' | 'bottom right' | 'bottom left';
+    adCTATextVast: boolean;
+    vastTimeout: number;
+    showPlayButton: boolean;
+    maxAllowedVastTagRedirects: number;
+    showProgressbarMarkers: boolean;
+    adClickable: boolean;
+    allowVPAID: boolean;
+    vastAdvanced: Partial<{
+        vastLoadedCallback: () => void;
+        noVastVideoCallback: () => void;
+        vastVideoSkippedCallback: () => void;
+        vastVideoEndedCallback: () => void;
+    }>;
+}
+
+declare interface AdOptions {
+    vastTag: string;
+    roll: string;
+    fallbackVastTags?: Array<string>;
+    adText?: string;
+    adTextPosition?: 'top right' | 'top left' | 'bottom right' | 'bottom left';
+    adClickable?: boolean;
+    vAlign?: 'top' | 'middle' | 'bottom';
+    nonLinearDuration?: number;
+    size?: '468x60' | '300x250' | '728x90';
+}
+
+declare interface PreRollAdOptions extends AdOptions {
+    roll: 'preRoll';
+}
+
+declare interface MidRollAdOptions extends AdOptions {
+    roll: 'midRoll';
+    timer: number | string;
+}
+
+declare interface PostRollAdOptions extends AdOptions {
+    roll: 'postRoll';
+}
+
+declare interface OnPauseRollAdOptions extends AdOptions {
+    roll: 'onPauseRoll';
+}
+
+declare interface ModulesOptions {
+    configureHls: (options: any) => any;
+    onBeforeInitHls: (hls: any) => void;
+    onAfterInitHls: (hls: any) => void;
+    configureDash: (options: any) => any;
+    onBeforeInitDash: (dash: any) => void;
+    onAfterInitDash: (dash: any) => void;
+}
+
+declare interface FluidPlayerOptions {
+    layoutControls: Partial<LayoutControls>;
+    vastOptions: Partial<VastOptions>;
+    modules: Partial<ModulesOptions>;
+    onBeforeXMLHttpRequestOpen?: (request: XMLHttpRequest) => void;
+    onBeforeXMLHttpRequest?: (request: XMLHttpRequest) => void;
+    debug?: boolean;
+    captions: Partial<{
+        play: string;
+        pause: string;
+        mute: string;
+        unmute: string;
+        fullscreen: string;
+        exitFullscreen: string;
+    }>;
+    suggestedVideos?: {
+        configUrl: string | null;
+    };
+    hls?: {
+        overrideNative: boolean;
+    };
+}

package/types/gender.d.ts

@@ -0,0 +1,5 @@
+export interface IGender {
+    guid: string
+    title: string
+    code: string
+}

package/types/group-categories.d.ts

@@ -0,0 +1,15 @@
+import type { ICategoryCard, IRawCategoryCard } from '../types/index.d.ts';
+
+export interface IGroupCategories {
+    categories: ICategoryCard[],
+    name: string,
+    title: string,
+    weight: number
+}
+
+export interface IRawGroupCategories {
+    categories: IRawCategoryCard[],
+    name: string,
+    title: string,
+    weight: number
+}

package/types/index.d.ts

@@ -0,0 +1,59 @@
+export * from './video-data.d.ts';
+export * from './video-card.d.ts';
+export * from './thumbs-urls.d.ts';
+export * from './raw/raw-category-info.d.ts';
+export * from './raw/raw-category-card.d.ts';
+export * from './raw/raw-channel-card.d.ts';
+export * from './raw/raw-channel-info.d.ts';
+export * from './raw/raw-model-card.d.ts';
+export * from './raw/raw-model-info.d.ts';
+export * from './raw/raw-playlist-card.d.ts';
+export * from './raw/raw-playlist-data.d.ts';
+export * from './raw/raw-playlist-user.d.ts';
+export * from './raw/raw-playlist-video.d.ts';
+export * from './raw/raw-profile-data.d.ts';
+export * from './raw/raw-video-data.d.ts';
+export * from './raw/raw-video-card.d.ts';
+export * from './card-info.d.ts';
+export * from './parameter-model.d.ts';
+export * from './breadcrumb-item.d.ts';
+export * from './change-password-form.d.ts';
+export * from './channel-card.d.ts';
+export * from './country.d.ts';
+export * from './category-card.d.ts';
+export * from './contacts-form.d.ts';
+export * from './input-types.d.ts';
+export * from './contacts-scheme.d.ts';
+export * from './authorization-forms.d.ts';
+export * from './gender.d.ts';
+export * from './group-categories.d.ts';
+export * from './model-card.d.ts';
+export * from './model-tag.d.ts';
+export * from './playlist-card.d.ts';
+export * from './playlist-data.d.ts';
+export * from './playlist-info-type.d.ts';
+export * from './playlist-video-form.d.ts';
+export * from './profile-data.d.ts';
+export * from './recovery-password-form.d.ts';
+export * from './related-phrases.d.ts';
+export * from './report-form.d.ts';
+export * from './report-scheme.d.ts';
+export * from './request-filters.d.ts';
+export * from './model-filter.d.ts';
+export * from './model-filter-payload.d.ts';
+export * from './multi-suggest.d.ts';
+export * from './navigation-items.d.ts';
+export * from './link-item.d.ts';
+export * from './fluid-player.d.ts';
+export * from './chips-item.d.ts';
+export * from './paginated-response.d.ts';
+export * from './request-pagination.d.ts';
+export * from './tab-item.d.ts';
+export * from './filter-scheme.d.ts';
+export * from './search-top-models.d.ts';
+export * from './select-item.d.ts';
+export * from './model-group.d.ts';
+export * from './change-email-form.d.ts';
+export * from './css-breakpoints.d.ts';
+export * from './button-sizes.d.ts';
+export * from './button-themes.d.ts';

package/types/input-types.d.ts

@@ -0,0 +1 @@
+export type InputTypes = 'text' | 'number' | 'email' | 'password' | 'textarea' | 'date' | 'tel';

package/types/link-item.d.ts

@@ -0,0 +1,6 @@
+export interface ILinkItem {
+  title: string
+  name: string
+  icon?: string
+  external?: boolean
+}

package/types/model-card.d.ts

@@ -0,0 +1,7 @@
+export interface IModelCard {
+    title: string;
+    videosCount: number;
+    thumbUrl: string;
+    primaryImageUrl?: string;
+    guid: string
+}

package/types/model-filter-payload.d.ts

@@ -0,0 +1,4 @@
+export interface IModelFilterPayload {
+    name: string
+    value: string | number
+}

package/types/model-filter.d.ts

@@ -0,0 +1,15 @@
+import type { IModelGroup } from '~/types/model-group';
+
+export interface IModelFilterOptions {
+    name: string
+    title: string
+    quantity: number
+}
+
+export interface IModelFilter {
+    kind: string
+    name: string
+    title: string
+    options: IModelFilterOptions[]
+    group: IModelGroup
+}

package/types/model-group.d.ts

@@ -0,0 +1,5 @@
+export interface IModelGroup {
+    name: string
+    title: string
+    order: number
+}

package/types/model-tag.d.ts

@@ -0,0 +1,5 @@
+export interface IModelTag {
+    guid: string
+    title: string
+    primaryImageUrl: string
+}