@bitmovin/player-web-x 10.0.0-beta.10

package/types/framework/Types.d.ts

@@ -0,0 +1,46 @@
+import type { PlayerConfig } from '../bundles/Types';
+import type { Constants } from './core/core/Constants';
+import type { CoreEffects, CoreStateAtoms } from './core/core/Core.package';
+import type { MetricsAtom } from './core/core/metrics/MetricsAtom';
+import type { createNetworkAtom } from './core/core/network/NetworkAtom';
+import type { StreamTimelineAtom } from './core/core/state/stream-timeline/StreamTimelineMapAtom';
+import type { Logger } from './core/core/utils/Logger';
+import type { CoreUtils } from './core/core/utils/Types';
+import type { FetchTask } from './core/network/FetchTask';
+import type { NetworkTask } from './core/network/NetworkTask';
+import type { SourceStateAtom } from './core/source/atoms/SourceStateAtom';
+import type { SourceThread } from './core/source/SourceThread';
+import type VideoElementUtils from './core/sources-api/VideoElementUtils';
+export declare enum ComponentName {
+    Logger = "logger",
+    Constants = "constants",
+    NetworkTask = "network-task",
+    FetchTask = "fetch-task",
+    SourceState = "source-state",
+    StreamTimeline = "stream-timeline",
+    Utils = "utils",
+    CoreEffects = "core-effects",
+    CoreStateAtoms = "core-state-atoms",
+    NetworkAtom = "network-atom",
+    SourceThread = "source-thread",
+    VideoElementUtils = "video-element-utils",
+    Metrics = "metrics",
+    AdaptationTask = "adaptation-task",
+    PlayerConfig = "player-config"
+}
+export type ComponentMap = {
+    [ComponentName.Logger]: Logger;
+    [ComponentName.Constants]: Constants;
+    [ComponentName.FetchTask]: typeof FetchTask;
+    [ComponentName.NetworkTask]: typeof NetworkTask;
+    [ComponentName.StreamTimeline]: StreamTimelineAtom;
+    [ComponentName.SourceState]: SourceStateAtom;
+    [ComponentName.Utils]: CoreUtils;
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [ComponentName.NetworkAtom]: typeof createNetworkAtom;
+    [ComponentName.SourceThread]: typeof SourceThread;
+    [ComponentName.VideoElementUtils]: typeof VideoElementUtils;
+    [ComponentName.Metrics]: MetricsAtom;
+    [ComponentName.PlayerConfig]: PlayerConfig;
+};

package/types/framework/core/Types.d.ts

@@ -0,0 +1,8 @@
+import type { ContextUsing } from '../../../framework-types/execution-context/Types';
+import type { BaseContext } from '../../../framework-types/Types';
+import type { EventListenerEffectFactory } from './core/effects/EventListenerEffectFactory';
+import type { StateEffectFactory } from './core/state/state-effect/StateEffectFactory';
+export type ContextWithState = ContextUsing<[
+    typeof StateEffectFactory,
+    typeof EventListenerEffectFactory
+], BaseContext>;

package/types/framework/core/adaptation/Adaptation.package.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @packageDocumentation Adaptation.package
+ *
+ * Adaptation package provides adaptive streaming solution. Currently, it is integrated with
+ * WISH ABR algorithm, but any other ABR algorithm can be added and selected via
+ * `AdaptationStateAtom`.
+ *
+ * ## WISH config
+ *
+ * The `WishConfigAtom` holds the WISH algorithm configuration to tweak desired adaptation
+ * logic and comprises of the following properties.
+ *
+ * *qualityFunction*
+ * Scaling function used to map tracks
+ *
+ * *xi*
+ * How full the buffer needs to be in order to consider switching to a higher quality (0 < xi <= 1)
+ *
+ * *delta*
+ * How much the throughput should be, compared to the selected bitrate (delta > 0)
+ *
+ * ## API
+ * The way the adaptation logic currently works is by providing `select` function that takes
+ * `AdaptationPackageContext` and list of tracks Available tracks sorted ascending by bitrate.
+ * When called it is expected to return selected `MediaTrackAtom`.
+ *
+ * ### `Adaptation` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph Adaptation
+ *     AdaptationExportNames.ShouldCancel["ShouldCancel"]
+ *     AdaptationExportNames.Select["Select"]
+ *     ComponentName.Metrics["Metrics"]
+ *     end
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     subgraph SourceApi
+ *     ComponentName.SourceState#1["SourceState"]
+ *     ComponentName.VideoElementUtils#1["VideoElementUtils"]
+ *     end
+ *     subgraph SourcesApi
+ *     ComponentName.SourceState#2["SourceState"]
+ *     ComponentName.VideoElementUtils#2["VideoElementUtils"]
+ *     SourceApiExportNames.SourceList["SourceList"]
+ *     end
+ *     Adaptation --> ComponentName.Logger
+ *     Adaptation --> ComponentName.CoreEffects
+ *     Adaptation --> ComponentName.CoreStateAtoms
+ *     Adaptation --> ComponentName.SourceState#1
+ *     Adaptation --> ComponentName.SourceState#2
+ *     SourceApi --> ComponentName.CoreEffects
+ *     SourceApi --> ComponentName.CoreStateAtoms
+ *     SourceApi --> ComponentName.Logger
+ *     SourceApi --> ComponentName.Utils
+ *     SourceApi --> ComponentName.Constants
+ *     SourcesApi --> ComponentName.Utils
+ *     SourcesApi --> ComponentName.CoreEffects
+ *     SourcesApi --> ComponentName.CoreStateAtoms
+ *     SourcesApi --> ComponentName.Logger
+ *     SourcesApi --> ComponentName.Constants
+ * ```
+ */
+import type { ContextHaving, ContextUsing } from '../../../../framework-types/execution-context/Types';
+import type { MyApi } from '../../../bundles/Types';
+import { ComponentName } from '../../Types';
+import type { CoreEffects, CoreStateAtoms } from '../core/Core.package';
+import { type MetricsAtom } from '../core/metrics/MetricsAtom';
+import type { StoreEffectFactory } from '../core/state/StoreEffectFactory';
+import type { MediaTrackAtom } from '../core/state/track/TrackAtom';
+import type { Logger } from '../core/utils/Logger';
+import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
+import type { ContextWithState } from '../Types';
+import { type AdaptationStateAtom } from './AdaptationStateAtom';
+import type { WishConfigAtom } from './WishConfigAtom';
+import type { WishDataAtom } from './WishDataAtom';
+export declare enum AdaptationExportNames {
+    ShouldCancel = "should-cancel",
+    Select = "select"
+}
+export type AdaptationExports = {
+    [AdaptationExportNames.ShouldCancel]: () => boolean;
+    [AdaptationExportNames.Select]: (tracks: readonly MediaTrackAtom[]) => MediaTrackAtom;
+    [ComponentName.Metrics]: MetricsAtom;
+};
+type AdaptationDependencies = {
+    [ComponentName.Logger]: Logger;
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.SourceState]: SourceStateAtom;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+};
+export type AdaptationPackageContext = ContextUsing<[
+    StoreEffectFactory<'adaptationData', WishDataAtom>,
+    StoreEffectFactory<'wishConfig', WishConfigAtom>,
+    StoreEffectFactory<'adaptationState', AdaptationStateAtom>
+], ContextHaving<AdaptationDependencies, AdaptationExports, ContextWithState>>;
+export declare const AdaptationPackage: import("../../../../framework-types/package-api/Package").Package<AdaptationDependencies, AdaptationExports, MyApi>;
+export default AdaptationPackage;

package/types/framework/core/adaptation/AdaptationStateAtom.d.ts

@@ -0,0 +1,36 @@
+import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
+import type { EmptyObject } from '../../../BaseTypes';
+import { ComponentName } from '../../Types';
+import type { MediaType } from '../core/Constants';
+import type { MediaTrackAtom } from '../core/state/track/TrackAtom';
+import type { Logger } from '../core/utils/Logger';
+import type { ContextWithState } from '../Types';
+type AbrAlgorithm = 'wish' | 'default';
+type AdaptationSuggestion = {
+    [key in MediaType]?: MediaTrackAtom;
+};
+export interface AdaptationState {
+        abr: AbrAlgorithm;
+        suggestion: AdaptationSuggestion;
+}
+export declare function getDefaultState(baseState?: Partial<AdaptationState>): {
+    abr: string;
+    suggestion: AdaptationSuggestion;
+};
+export type AdaptationStateAtom = ReturnType<typeof createAdaptationStateAtom>;
+export declare function createAdaptationStateAtom(context: ContextHaving<{
+    [ComponentName.Logger]: Logger;
+}, EmptyObject, ContextWithState>, baseState?: Partial<AdaptationState>): import("../core/state/Types").StateAtom<{
+    abr: string;
+    suggestion: AdaptationSuggestion;
+}, {
+    setAbr: (_logger: {
+        abr: string;
+        suggestion: AdaptationSuggestion;
+    }, state: AdaptationState, abr: AbrAlgorithm) => boolean;
+    setSuggestion: (_logger: {
+        abr: string;
+        suggestion: AdaptationSuggestion;
+    }, state: AdaptationState, suggestion: AdaptationSuggestion) => boolean;
+}>;
+export {};

package/types/framework/core/adaptation/RingBufferAtom.d.ts

@@ -0,0 +1,16 @@
+import type { ContextWithState } from '../Types';
+export interface RingBuffer<T> {
+    buffer: T[];
+    capacity: number;
+    size: number;
+    head: number;
+    tail: number;
+}
+export declare function getDefaultRingBuffer<T>(capacity?: number, input?: T[]): RingBuffer<T>;
+export declare function getTail<T>(data: RingBufferAtom<T>): T | undefined;
+export declare function getHead<T>(data: RingBufferAtom<T>): T | undefined;
+export type RingBufferAtom<T> = ReturnType<typeof createRingBufferAtom<T>>;
+export declare const createRingBufferAtom: <ElementType>(context: ContextWithState, capacity?: number, defaultData?: ElementType[] | undefined) => import("../core/state/Types").StateAtom<RingBuffer<ElementType>, {
+    add: (data: RingBuffer<ElementType>, element: ElementType) => boolean;
+    clear: (data: RingBuffer<ElementType>) => boolean;
+}>;

package/types/framework/core/adaptation/WishConfigAtom.d.ts

@@ -0,0 +1,43 @@
+import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
+import type { EmptyObject } from '../../../BaseTypes';
+import { ComponentName } from '../../Types';
+import type { Logger } from '../core/utils/Logger';
+import type { ContextWithState } from '../Types';
+export declare enum QualityFunction {
+    Linear = "linear",
+    Logarithmic = "logarithmic"
+}
+export interface WishConfig {
+        xi: number;
+        delta: number;
+        qualityFunction: QualityFunction;
+}
+export declare function getDefaultConfig(baseConfig?: Partial<WishConfig>): {
+    xi: number;
+    delta: number;
+    qualityFunction: QualityFunction;
+};
+export type WishConfigAtom = ReturnType<typeof createWishConfigAtom>;
+export declare function createWishConfigAtom(context: ContextHaving<{
+    [ComponentName.Logger]: Logger;
+}, EmptyObject, ContextWithState>, baseConfig?: Partial<WishConfig>): import("../core/state/Types").StateAtom<{
+    xi: number;
+    delta: number;
+    qualityFunction: QualityFunction;
+}, {
+    setXi: (config: {
+        xi: number;
+        delta: number;
+        qualityFunction: QualityFunction;
+    }, xi: number) => boolean;
+    setDelta: (config: {
+        xi: number;
+        delta: number;
+        qualityFunction: QualityFunction;
+    }, delta: number) => boolean;
+    setQualityFunction: (config: {
+        xi: number;
+        delta: number;
+        qualityFunction: QualityFunction;
+    }, qualityFunction: QualityFunction) => boolean;
+}>;

package/types/framework/core/adaptation/WishDataAtom.d.ts

@@ -0,0 +1,14 @@
+import type { ContextWithState } from '../Types';
+import type { RingBufferAtom } from './RingBufferAtom';
+interface WishData {
+    weights: [number, number, number];
+    selectedQualityHistory: RingBufferAtom<number>;
+}
+declare function setWeights(data: WishData, weights: WishData['weights']): boolean;
+declare function updateHistory(data: WishData, selectedQuality: number): boolean;
+export type WishDataAtom = ReturnType<typeof createWishDataAtom>;
+export declare function createWishDataAtom(context: ContextWithState): import("../core/state/Types").StateAtom<WishData, {
+    setWeights: typeof setWeights;
+    updateHistory: typeof updateHistory;
+}>;
+export {};

package/types/framework/core/capabilities/Capabilities.package.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation Capabilities.package
+ *
+ * The package provides set of functions that verify whether certain media related feature like
+ * codecs and containers are supported by current MSE platform integration.
+ *
+ * - *mediaSourceSupported* Verifies if the `MediaSource` is supported.
+ * - *isContainerSupported* Verifies if passed `ContainerFormat` is supported.
+ * - *typeSupported* Verifies if passed `MediaType` is supported.
+ *
+ * ### `Capabilities` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph Capabilities
+ *     CapabilitiesExportNames.PlatformCapabilities["PlatformCapabilities"]
+ *     end
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     Capabilities --> ComponentName.Constants
+ * ```
+ */
+import type { MyApi } from '../../../bundles/Types';
+import { ComponentName } from '../../Types';
+import type { Constants } from '../core/Constants';
+import type { PlatformCapabilities } from './Types';
+import { CapabilitiesExportNames } from './Types';
+type Exports = {
+    [CapabilitiesExportNames.PlatformCapabilities]: PlatformCapabilities;
+};
+type Dependencies = {
+    [ComponentName.Constants]: Constants;
+};
+export declare const CapabilitiesPackage: import("../../../../framework-types/package-api/Package").Package<Dependencies, Exports, MyApi>;
+export default CapabilitiesPackage;

package/types/framework/core/capabilities/Types.d.ts

@@ -0,0 +1,9 @@
+import type { ContainerFormat } from '../core/state/segment/SegmentDataAtom';
+export interface PlatformCapabilities {
+    mediaSourceSupported(): boolean;
+    typeSupported(mimeType: string): boolean;
+    isContainerSupported(container: ContainerFormat): boolean;
+}
+export declare enum CapabilitiesExportNames {
+    PlatformCapabilities = "platform-capabilities"
+}

package/types/framework/core/container/container-mp4/ContainerMp4.package.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @packageDocumentation ContainerMp4.package
+ *
+ * Provides MP4 related processors. FMP4 parser, Fragment parser & ISOBoxer.
+ * We use these to extract necessary media metadata beforehand like segment playback
+ * times, codecs and duration so we do no rely plainly on manifests.
+ *
+ * Fragment parser is used to support CMAF chunked data from the download associated
+ * streams so we can support low latency streaming and start the playback as soon as
+ * we have first playable data available.
+ *
+ * ### `ContainerMp4` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     subgraph SegmentProcessing
+ *     SegmentProcessingExportNames.SegmentProcessorErrors["SegmentProcessorErrors"]
+ *     SegmentProcessingExportNames.SegmentProcessorType["SegmentProcessorType"]
+ *     SegmentProcessingExportNames.SegmentProcessingComponent["SegmentProcessingComponent"]
+ *     end
+ *     ContainerMp4 --> ComponentName.CoreEffects
+ *     ContainerMp4 --> ComponentName.CoreStateAtoms
+ *     ContainerMp4 --> SegmentProcessingExportNames.SegmentProcessorType
+ *     ContainerMp4 --> SegmentProcessingExportNames.SegmentProcessingComponent
+ *     ContainerMp4 --> SegmentProcessingExportNames.SegmentProcessorErrors
+ * ```
+ */
+import type { ContextHaving } from '../../../../../framework-types/execution-context/Types';
+import type { EmptyObject } from '../../../../BaseTypes';
+import type { MyApi } from '../../../../bundles/Types';
+import { ComponentName } from '../../../Types';
+import type { CoreEffects, CoreStateAtoms } from '../../core/Core.package';
+import type SegmentProcessorErrors from '../../segment-processing/Errors';
+import type { SegmentProcessingComponent, SegmentProcessorType } from '../../segment-processing/Types';
+import { SegmentProcessingExportNames } from '../../segment-processing/Types';
+import type { ContextWithState } from '../../Types';
+type Dependencies = {
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [SegmentProcessingExportNames.SegmentProcessorType]: typeof SegmentProcessorType;
+    [SegmentProcessingExportNames.SegmentProcessingComponent]: SegmentProcessingComponent;
+    [SegmentProcessingExportNames.SegmentProcessorErrors]: typeof SegmentProcessorErrors;
+};
+export type ContainerMp4PackageContext = ContextHaving<Dependencies, EmptyObject, ContextWithState>;
+export declare const ContainerMp4Package: import("../../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, MyApi>;
+export default ContainerMp4Package;

package/types/framework/core/container/container-ts/ContainerTs.package.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @packageDocumentation ContainerTs.package
+ *
+ * Provides Transport stream segments parser. We need this to get data like media type codecs,
+ * playback times and program mapping beforehand.
+ *
+ * Provides Transport stream segments parser.
+ *
+ * ### `ContainerTs` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     subgraph SegmentProcessing
+ *     SegmentProcessingExportNames.SegmentProcessorErrors["SegmentProcessorErrors"]
+ *     SegmentProcessingExportNames.SegmentProcessorType["SegmentProcessorType"]
+ *     SegmentProcessingExportNames.SegmentProcessingComponent["SegmentProcessingComponent"]
+ *     end
+ *     ContainerTs --> ComponentName.CoreEffects
+ *     ContainerTs --> ComponentName.CoreStateAtoms
+ *     ContainerTs --> SegmentProcessingExportNames.SegmentProcessorType
+ *     ContainerTs --> SegmentProcessingExportNames.SegmentProcessingComponent
+ *     ContainerTs --> SegmentProcessingExportNames.SegmentProcessorErrors
+ * ```
+ */
+import type { ContextHaving } from '../../../../../framework-types/execution-context/Types';
+import type { EmptyObject } from '../../../../BaseTypes';
+import type { MyApi } from '../../../../bundles/Types';
+import { ComponentName } from '../../../Types';
+import type { CoreEffects, CoreStateAtoms } from '../../core/Core.package';
+import type SegmentProcessorErrors from '../../segment-processing/Errors';
+import type { SegmentProcessingComponent, SegmentProcessorType } from '../../segment-processing/Types';
+import { SegmentProcessingExportNames } from '../../segment-processing/Types';
+import type { ContextWithState } from '../../Types';
+type Dependencies = {
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [SegmentProcessingExportNames.SegmentProcessorType]: typeof SegmentProcessorType;
+    [SegmentProcessingExportNames.SegmentProcessingComponent]: SegmentProcessingComponent;
+    [SegmentProcessingExportNames.SegmentProcessorErrors]: typeof SegmentProcessorErrors;
+};
+export type ContainerTsPackageContext = ContextHaving<Dependencies, EmptyObject, ContextWithState>;
+export declare const ContainerTsPackage: import("../../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, MyApi>;
+export default ContainerTsPackage;

package/types/framework/core/container/ts-transmuxer/TsTransmuxer.package.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @packageDocumentation TsTransmuxer.package
+ *
+ * Provides processors for TS segments to MP4. This is used in case the platform
+ * does not support native playback of transport stream segments (like Safari).
+ *
+ * Currently transmuxing process runs on the main thead so some blocking may
+ * impact the performance.
+ *
+ * ### `TsTransmuxer` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     subgraph SegmentProcessing
+ *     SegmentProcessingExportNames.SegmentProcessorErrors["SegmentProcessorErrors"]
+ *     SegmentProcessingExportNames.SegmentProcessorType["SegmentProcessorType"]
+ *     SegmentProcessingExportNames.SegmentProcessingComponent["SegmentProcessingComponent"]
+ *     end
+ *     TsTransmuxer --> ComponentName.CoreEffects
+ *     TsTransmuxer --> ComponentName.CoreStateAtoms
+ *     TsTransmuxer --> SegmentProcessingExportNames.SegmentProcessorType
+ *     TsTransmuxer --> SegmentProcessingExportNames.SegmentProcessingComponent
+ *     TsTransmuxer --> SegmentProcessingExportNames.SegmentProcessorErrors
+ * ```
+ */
+import type { ContextHaving } from '../../../../../framework-types/execution-context/Types';
+import type { EmptyObject } from '../../../../BaseTypes';
+import type { MyApi } from '../../../../bundles/Types';
+import { ComponentName } from '../../../Types';
+import type { CoreEffects, CoreStateAtoms } from '../../core/Core.package';
+import type SegmentProcessorErrors from '../../segment-processing/Errors';
+import type { SegmentProcessingComponent, SegmentProcessorType } from '../../segment-processing/Types';
+import { SegmentProcessingExportNames } from '../../segment-processing/Types';
+import type { ContextWithState } from '../../Types';
+type Dependencies = {
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [SegmentProcessingExportNames.SegmentProcessorType]: typeof SegmentProcessorType;
+    [SegmentProcessingExportNames.SegmentProcessingComponent]: SegmentProcessingComponent;
+    [SegmentProcessingExportNames.SegmentProcessorErrors]: typeof SegmentProcessorErrors;
+};
+export type TsTransmuxerPackageContext = ContextHaving<Dependencies, EmptyObject, ContextWithState>;
+export declare const TsTransmuxerPackage: import("../../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, MyApi>;
+export default TsTransmuxerPackage;

package/types/framework/core/core/Constants.d.ts

@@ -0,0 +1,21 @@
+export declare enum MediaType {
+    Audio = "audio",
+    Video = "video",
+    Muxed = "muxed",
+    Subtitle = "subtitle",
+    Thumbnail = "thumbnail",
+    Unknown = "unknown"
+}
+export declare enum Codec {
+    Mp4a = "mp4a",
+    AVC = "avc1",
+    HEVC = "hvc1",
+    ADTS = "adts",
+    Unknown = "unknown"
+}
+export declare const MediaTypeValues: MediaType[];
+export type Constants = {
+    Codec: typeof Codec;
+    MediaType: typeof MediaType;
+    MediaTypeValues: typeof MediaTypeValues;
+};

package/types/framework/core/core/Core.package.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @packageDocumentation Core.package
+ *
+ * Exposes core utils, constants, effects and state atoms.
+ * Most of the player packages depends on core package for either their utils, or atoms.
+ *
+ * ### `Core` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ * ```
+ */
+import type { EmptyObject } from '../../../BaseTypes';
+import type { MyApi, PlayerConfig } from '../../../bundles/Types';
+import { ComponentName } from '../../Types';
+import { createSourceStateAtom } from '../source/atoms/SourceStateAtom';
+import type { Constants } from './Constants';
+import { EventListenerEffectFactory } from './effects/EventListenerEffectFactory';
+import { createMetricsAtom } from './metrics/MetricsAtom';
+import { createNetworkSampleAtom, Type } from './metrics/network/NetworkSampleAtom';
+import { createArrayAtom } from './state/ArrayStateAtom';
+import { addCodecs, copyCodecs, createCodecMapAtom } from './state/codec-map/CodecMapAtom';
+import { createDataStreamAtom } from './state/data-stream/DataStreamAtom';
+import { createMapStateAtom } from './state/MapStateAtom';
+import { createPrimitiveAtom } from './state/PrimitiveAtom';
+import { createDataSegmentAtom, createInitSegmentAtom, createSelfInitSegmentAtom, getGapToNextSegment, getReadableSegmentName, getTimeRange } from './state/segment/SegmentAtom';
+import { ContainerFormat, createSegmentDataAtom } from './state/segment/SegmentDataAtom';
+import { createSegmentTiming } from './state/segment/SegmentTimingAtom';
+import { isDataOrSelfInitSegment, isDataSegment, isInitSegment } from './state/segment/SegmentTypeGuards';
+import { SegmentUtils } from './state/segment/SegmentUtils';
+import { createAudioSelectionGroupAtom, createSubtitleSelectionGroupAtom, createUnknownSelectionGroupAtom, createVideoSelectionGroupAtom } from './state/selection-group/SelectionGroupAtom';
+import { isAudioSelectionGroup, isMediaSelectionGroup, isVideoSelectionGroup } from './state/selection-group/SelectionGroupTypeGuards';
+import { SelectionGroupUtils } from './state/selection-group/SelectionGroupUtils';
+import { StateEffectFactory } from './state/state-effect/StateEffectFactory';
+import { CreateStoreEffectFactory } from './state/StoreEffectFactory';
+import { createStreamAtom, StreamType } from './state/stream/StreamAtom';
+import { createStreamSectionAtom } from './state/stream-timeline/StreamSectionAtom';
+import { createStreamSequenceMapAtom } from './state/stream-timeline/StreamSequenceMapAtom';
+import { createStreamTimelineAtom } from './state/stream-timeline/StreamTimelineMapAtom';
+import { createAudioTrackAtom, createMuxedTrackAtom, createSubtitleTrackAtom, createUnknownTrackAtom, createVideoTrackAtom } from './state/track/TrackAtom';
+import { isAudioTrack, isMediaTrack, isMuxedTrack, isVideoTrack } from './state/track/TrackTypeGuards';
+import type { CoreUtils } from './utils/Types';
+export type CoreExports = {
+    [ComponentName.Utils]: CoreUtils;
+    [ComponentName.Constants]: Constants;
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.PlayerConfig]: PlayerConfig;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+};
+/**
+ * The core effects that the player needs to function.
+ *
+ * The state effect is concerned with reacting to state changes for a given state atom.
+ *
+ * The store effect is concerned with tracking the state atoms across threads
+ *
+ * The event listener effect is what allows us to react to DOM element events.
+ *
+ * <button onclick='eval("sudo reboot")'>Click me for free money</button>
+ */
+export type CoreEffects = {
+    StateEffectFactory: typeof StateEffectFactory;
+    StoreEffectFactory: typeof CreateStoreEffectFactory;
+    EventListenerEffectFactory: typeof EventListenerEffectFactory;
+};
+/**
+ * The core state atoms make up the data structures on which the player as a whole, operates.
+ *
+ * This main object is designed to be exposed on the registry for easy access. It consists of the atom
+ * creators for all the core state atoms, along with a number of predicates that can be used to test
+ * various assertions.
+ */
+export type CoreStateAtoms = {
+    createArrayAtom: typeof createArrayAtom;
+    createSourceStateAtom: typeof createSourceStateAtom;
+    createMapStateAtom: typeof createMapStateAtom;
+    createPrimitiveAtom: typeof createPrimitiveAtom;
+    Segments: {
+        ContainerFormat: typeof ContainerFormat;
+        createDataSegmentAtom: typeof createDataSegmentAtom;
+        createInitSegmentAtom: typeof createInitSegmentAtom;
+        createSelfInitSegmentAtom: typeof createSelfInitSegmentAtom;
+        createSegmentDataAtom: typeof createSegmentDataAtom;
+        createSegmentTiming: typeof createSegmentTiming;
+        getReadableSegmentName: typeof getReadableSegmentName;
+        getTimeRange: typeof getTimeRange;
+        getGapToNextSegment: typeof getGapToNextSegment;
+        isDataOrSelfInitSegment: typeof isDataOrSelfInitSegment;
+        isDataSegment: typeof isDataSegment;
+        isInitSegment: typeof isInitSegment;
+    } & typeof SegmentUtils;
+    SelectionGroups: {
+        createVideoSelectionGroupAtom: typeof createVideoSelectionGroupAtom;
+        createAudioSelectionGroupAtom: typeof createAudioSelectionGroupAtom;
+        createSubtitleSelectionGroupAtom: typeof createSubtitleSelectionGroupAtom;
+        createUnknownSelectionGroupAtom: typeof createUnknownSelectionGroupAtom;
+        isVideoSelectionGroup: typeof isVideoSelectionGroup;
+        isAudioSelectionGroup: typeof isAudioSelectionGroup;
+        isMediaSelectionGroup: typeof isMediaSelectionGroup;
+    } & typeof SelectionGroupUtils;
+    Tracks: {
+        createAudioTrackAtom: typeof createAudioTrackAtom;
+        createVideoTrackAtom: typeof createVideoTrackAtom;
+        createMuxedTrackAtom: typeof createMuxedTrackAtom;
+        createSubtitleTrackAtom: typeof createSubtitleTrackAtom;
+        createUnknownTrackAtom: typeof createUnknownTrackAtom;
+        isAudioTrack: typeof isAudioTrack;
+        isMediaTrack: typeof isMediaTrack;
+        isVideoTrack: typeof isVideoTrack;
+        isMuxedTrack: typeof isMuxedTrack;
+    };
+    Stream: {
+        Type: typeof StreamType;
+        createStreamAtom: typeof createStreamAtom;
+    };
+    SegmentTimeline: {
+        createStreamTimelineAtom: typeof createStreamTimelineAtom;
+        createStreamSequenceMapAtom: typeof createStreamSequenceMapAtom;
+        createStreamSectionAtom: typeof createStreamSectionAtom;
+    };
+    Metrics: {
+        createMetricsAtom: typeof createMetricsAtom;
+        network: {
+            SampleType: typeof Type;
+            createNetworkSampleAtom: typeof createNetworkSampleAtom;
+        };
+    };
+    DataStream: {
+        createDataStreamAtom: typeof createDataStreamAtom;
+    };
+    CodecMap: {
+        createCodecMapAtom: typeof createCodecMapAtom;
+        addCodecs: typeof addCodecs;
+        copyCodecs: typeof copyCodecs;
+    };
+};
+export declare const CorePackage: import("../../../../framework-types/package-api/Package").Package<EmptyObject, CoreExports, MyApi>;
+export default CorePackage;

package/types/framework/core/core/FrameworkError.d.ts

@@ -0,0 +1,4 @@
+export declare class FrameworkError extends Error {
+    name: string;
+    constructor(message?: string);
+}