@phenixrts/sdk 2025.2.4-beta.656 → 2025.2.4-beta.658

package/publish/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenixrts/sdk/publish",
-  "version": "2025.2.4-beta.656",
+  "version": "2025.2.4-beta.658",
   "files": [
     "min/"
   ],

package/types/sdk/discovery/PcastUri.d.ts

@@ -0,0 +1,6 @@
+export default class PcastUri {
+    static get discoveryPath(): string;
+    static normalizeDiscoveryUri(uri: string | URL): URL;
+    static buildRouteUrl(baseUri: string | URL, path: string[]): URL;
+    private constructor();
+}

package/types/sdk/replay/ReplayApi.d.ts

@@ -0,0 +1,16 @@
+import { EncodedEdgeToken } from '../../edgeAuth/EncodedEdgeToken';
+import { Millisecond } from '../../units/Units';
+import { IGetReplayManifestResponse } from '../api/Replay';
+export default class ReplayApi {
+    private readonly _logger;
+    private readonly _baseUri;
+    private readonly _timeoutMs;
+    constructor(baseUri: string, timeoutMs?: Millisecond);
+    buildReplayManifestUrl(token: EncodedEdgeToken, startTime: number, endTime: number): URL;
+    getReplayManifest(token: EncodedEdgeToken, startTime: number, endTime: number): Promise<IGetReplayManifestResponse>;
+    private buildManifestUrl;
+    private static mapHttpStatusToReplayStatus;
+    private static statusFromBody;
+    private logNonManifestBody;
+    private static redactCredentials;
+}

package/types/sdk/replay/player/IReplayMediaSource.d.ts

@@ -0,0 +1,6 @@
+import DisposableList from '../../../lang/DisposableList';
+interface IReplayMediaSource {
+    load(manifestUrl: string, session: DisposableList): Promise<void>;
+    release(): void;
+}
+export default IReplayMediaSource;

package/types/sdk/replay/player/IReplayPlayer.d.ts

@@ -0,0 +1,10 @@
+import IDisposable from '../../../lang/IDisposable';
+import ReadOnlySubject from '../../../rx/ReadOnlySubject';
+import { ReplayPlaybackError } from '../ReplaySessionError';
+interface IReplayPlayer extends IDisposable {
+    readonly ended: ReadOnlySubject<boolean>;
+    readonly fatalError: ReadOnlySubject<ReplayPlaybackError | null>;
+    play(manifestUrl: string): Promise<void>;
+    stop(): void;
+}
+export default IReplayPlayer;

package/types/sdk/replay/player/ReplayHlsJsPlayer.d.ts

@@ -0,0 +1,34 @@
+import DisposableList from '../../../lang/DisposableList';
+import ReadOnlySubject from '../../../rx/ReadOnlySubject';
+import { HlsErrorTypes, HlsPlayerType, IHlsEventData, IHlsLevel, ReplayHlsPlayerConfig } from '../../streaming/IHlsPlayer';
+import { ReplayFailureStatus } from '../ReplayStatus';
+import { ReplayPlaybackError } from '../ReplaySessionError';
+import IReplayPlayer from './IReplayPlayer';
+import IReplayMediaSource from './IReplayMediaSource';
+export declare const replayHlsConfig: ReplayHlsPlayerConfig;
+export default class ReplayHlsJsPlayer implements IReplayPlayer, IReplayMediaSource {
+    private readonly _logger;
+    private readonly _videoElement;
+    private readonly _Hls;
+    private readonly _lifecycle;
+    private _hls;
+    private _lastSegmentNumber;
+    private _isTailMissing;
+    constructor(videoElement: HTMLVideoElement, Hls: HlsPlayerType);
+    static findHighestLevel(levels: IHlsLevel[]): number;
+    static isMediaRequest(details?: string): boolean;
+    static errorDetails(data: IHlsEventData): string | undefined;
+    static httpStatusOf(data: IHlsEventData): number | undefined;
+    static mapHlsErrorToStatus(data: IHlsEventData, errorTypes?: Pick<HlsErrorTypes, 'KEY_SYSTEM_ERROR'>): ReplayFailureStatus;
+    get ended(): ReadOnlySubject<boolean>;
+    get fatalError(): ReadOnlySubject<ReplayPlaybackError | null>;
+    load(manifestUrl: string, session: DisposableList): Promise<void>;
+    play(manifestUrl: string): Promise<void>;
+    release(): void;
+    stop(): void;
+    dispose(): void;
+    private selectStartLevel;
+    private isMissingTailSegment;
+    private endIfPlayedOut;
+    private reachableBufferedEnd;
+}

package/types/sdk/replay/player/ReplayNativeHlsPlayer.d.ts

@@ -0,0 +1,20 @@
+import DisposableList from '../../../lang/DisposableList';
+import ReadOnlySubject from '../../../rx/ReadOnlySubject';
+import { ReplayPlaybackError } from '../ReplaySessionError';
+import IReplayPlayer from './IReplayPlayer';
+import IReplayMediaSource from './IReplayMediaSource';
+export declare const nativeHlsMimeType = "application/vnd.apple.mpegurl";
+export default class ReplayNativeHlsPlayer implements IReplayPlayer, IReplayMediaSource {
+    private readonly _logger;
+    private readonly _videoElement;
+    private readonly _lifecycle;
+    constructor(videoElement: HTMLVideoElement);
+    static isSupportedBy(videoElement: HTMLVideoElement): boolean;
+    get ended(): ReadOnlySubject<boolean>;
+    get fatalError(): ReadOnlySubject<ReplayPlaybackError | null>;
+    play(manifestUrl: string): Promise<void>;
+    load(manifestUrl: string, session: DisposableList): Promise<void>;
+    release(): void;
+    stop(): void;
+    dispose(): void;
+}

package/types/sdk/replay/player/ReplayPlaybackLifecycle.d.ts

@@ -0,0 +1,22 @@
+import ReadOnlySubject from '../../../rx/ReadOnlySubject';
+import { ReplayPlaybackError } from '../ReplaySessionError';
+import IReplayPlayer from './IReplayPlayer';
+import IReplayMediaSource from './IReplayMediaSource';
+export default class ReplayPlaybackLifecycle implements IReplayPlayer {
+    private readonly _source;
+    private readonly _lifetime;
+    private readonly _ended;
+    private readonly _readOnlyEnded;
+    private readonly _fatalError;
+    private readonly _readOnlyFatalError;
+    private _session;
+    private _isDisposed;
+    constructor(videoElement: HTMLVideoElement, source: IReplayMediaSource);
+    get ended(): ReadOnlySubject<boolean>;
+    get fatalError(): ReadOnlySubject<ReplayPlaybackError | null>;
+    play(manifestUrl: string): Promise<void>;
+    stop(): void;
+    markEnded(): void;
+    reportFatalError(error: ReplayPlaybackError): void;
+    dispose(): void;
+}

package/types/sdk/replay/player/ReplayPlayerFactory.d.ts

@@ -0,0 +1,8 @@
+import IReplayPlayer from './IReplayPlayer';
+export default class ReplayPlayerFactory {
+    private static readonly _logger;
+    static isSupported(): boolean;
+    static playsNatively(): boolean;
+    static create(videoElement: HTMLVideoElement): Promise<IReplayPlayer>;
+    private constructor();
+}

package/types/sdk/streaming/IHlsPlayer.d.ts

@@ -1,4 +1,13 @@
 import { ChunkedStreamingStatistics } from './StreamTypes';
+export type HlsEvents = {
+    MANIFEST_PARSED: string;
+    FRAG_BUFFERED: string;
+    FRAG_LOADED: string;
+    LEVEL_LOADED: string;
+    VIDEO_TRACK_LOADED: string;
+    MEDIA_ENDED: string;
+    ERROR: string;
+};
 export interface IHlsPlayerType {
     media: HTMLVideoElement;
     streamController: {
@@ -9,12 +18,52 @@ export interface IHlsPlayerType {
     destroy(): void;
     loadSource: (url: string) => void;
     attachMedia: (videoElement: HTMLVideoElement) => void;
-    Events: {
-        FRAG_BUFFERED: string;
-        VIDEO_TRACK_LOADED: string;
-        FRAG_LOADED: string;
+    detachMedia: () => void;
+    stopLoad: () => void;
+    readonly levels: IHlsLevel[];
+    startLevel: number;
+    nextAutoLevel: number;
+    on: (event: string, handler: (event: string, data: IHlsEventData) => void) => void;
+    off: (event: string, handler?: (event: string, data: IHlsEventData) => void) => void;
+    Events: HlsEvents;
+}
+export interface IHlsLevelDetails {
+    startSN?: number;
+    endSN?: number;
+    totalduration?: number;
+}
+export interface IHlsEventData {
+    type?: string;
+    details?: string | IHlsLevelDetails;
+    fatal?: boolean;
+    reason?: string;
+    error?: Error;
+    networkDetails?: {
+        status?: number;
+    };
+    response?: {
+        code?: number;
+        text?: string;
     };
+    levels?: IHlsLevel[];
+    frag?: {
+        level?: number;
+        sn?: number | string;
+    };
+}
+export interface IHlsLevel {
+    height?: number;
+    width?: number;
+    bitrate?: number;
+    name?: string;
 }
+export type HlsErrorTypes = {
+    NETWORK_ERROR: string;
+    MEDIA_ERROR: string;
+    KEY_SYSTEM_ERROR: string;
+    MUX_ERROR: string;
+    OTHER_ERROR: string;
+};
 export type HlsPlayerConfig = {
     enableWorker: boolean;
     maxBufferLength: number;
@@ -24,12 +73,39 @@ export type HlsPlayerConfig = {
     liveDurationInfinity: boolean;
     highBufferWatchdogPeriod: number;
 };
+export type HlsRetryConfig = {
+    maxNumRetry: number;
+    retryDelayMs: number;
+    maxRetryDelayMs: number;
+};
+export type HlsLoadPolicy = {
+    default: {
+        maxTimeToFirstByteMs: number;
+        maxLoadTimeMs: number;
+        timeoutRetry: HlsRetryConfig;
+        errorRetry: HlsRetryConfig;
+    };
+};
+export type ReplayHlsPlayerConfig = {
+    enableWorker: boolean;
+    lowLatencyMode: boolean;
+    backBufferLength: number;
+    maxBufferLength: number;
+    maxMaxBufferLength: number;
+    startPosition: number;
+    testBandwidth: boolean;
+    manifestLoadPolicy: HlsLoadPolicy;
+    playlistLoadPolicy: HlsLoadPolicy;
+    fragLoadPolicy: HlsLoadPolicy;
+};
 export type HlsPlayerType = {
-    new (config: HlsPlayerConfig): IHlsPlayerType;
+    new (config: HlsPlayerConfig | ReplayHlsPlayerConfig): IHlsPlayerType;
     isSupported(): boolean;
     loadSource: (url: string) => void;
     attachMedia: (videoElement: HTMLVideoElement) => void;
     dispose(): void;
     destroy(): void;
+    readonly Events: HlsEvents;
+    readonly ErrorTypes: HlsErrorTypes;
     getStats(): ChunkedStreamingStatistics;
 };