@meshstream/p2p-web 0.0.0-stage → 0.2.1

package/dist/vendor/meshstream-p2p-core.d.ts

@@ -0,0 +1,536 @@
+/** Core class for managing media streams loading via P2P. */
+export var Core: {
+    new (config: any): {
+        eventTarget: {
+            events: Map<any, any>;
+            dispatchEvent(eventName: any, a1: any, a2: any, a3: any, a4: any, a5: any): void;
+            getEventDispatcher(eventName: any): (a1: any, a2: any, a3: any, a4: any, a5: any) => void;
+            addEventListener(eventName: any, listener: any): void;
+            removeEventListener(eventName: any, listener: any): void;
+            clear(): void;
+        };
+        manifestResponseUrl: any;
+        streams: Map<any, any>;
+        mainStreamConfig: {};
+        secondaryStreamConfig: {};
+        commonCoreConfig: {};
+        bandwidthCalculators: {
+            all: {
+                clearThresholdMs: number;
+                loadingsCount: number;
+                bytes: any[];
+                loadingOnlyTimestamps: any[];
+                timestamps: any[];
+                noLoadingsTime: number;
+                loadingsStoppedAt: number;
+                addBytes(bytesLength: any, now?: number): void;
+                startLoading(now?: number): void;
+                stopLoading(now?: number): void;
+                getBandwidthLoadingOnly(seconds: any, ignoreThresholdTimestamp?: number): number;
+                getBandwidth(seconds: any, ignoreThresholdTimestamp?: number, now?: number): number;
+                clearStale(): void;
+                clear(): void;
+            };
+            http: {
+                clearThresholdMs: number;
+                loadingsCount: number;
+                bytes: any[];
+                loadingOnlyTimestamps: any[];
+                timestamps: any[];
+                noLoadingsTime: number;
+                loadingsStoppedAt: number;
+                addBytes(bytesLength: any, now?: number): void;
+                startLoading(now?: number): void;
+                stopLoading(now?: number): void;
+                getBandwidthLoadingOnly(seconds: any, ignoreThresholdTimestamp?: number): number;
+                getBandwidth(seconds: any, ignoreThresholdTimestamp?: number, now?: number): number;
+                clearStale(): void;
+                clear(): void;
+            };
+        };
+        segmentStorage: any;
+        webTorrentSocketPool: {
+            "__#private@#sockets": Map<any, any>;
+            "__#private@#eventTarget": {
+                events: Map<any, any>;
+                dispatchEvent(eventName: any, a1: any, a2: any, a3: any, a4: any, a5: any): void;
+                getEventDispatcher(eventName: any): (a1: any, a2: any, a3: any, a4: any, a5: any) => void;
+                addEventListener(eventName: any, listener: any): void;
+                removeEventListener(eventName: any, listener: any): void;
+                clear(): void;
+            };
+            addEventListener(eventName: any, listener: any): void;
+            removeEventListener(eventName: any, listener: any): void;
+            acquire(url: any): {
+                client: any;
+                release: () => void;
+            };
+            destroy(): void;
+        };
+        socketPoolLogger: any;
+        peerId: string;
+        mainStreamLoader: any;
+        secondaryStreamLoader: any;
+        streamDetails: {
+            isLive: boolean;
+            activeLevelBitrate: number;
+        };
+        storageInitPromise: any;
+        /**
+        * Retrieves the current configuration for the core instance, ensuring immutability.
+        *
+        * @returns A deep readonly version of the core configuration.
+        */
+        getConfig(): any;
+        /**
+        * Applies a set of dynamic configuration updates to the core, merging with the existing configuration.
+        *
+        * @param dynamicConfig - A set of configuration changes to apply.
+        *
+        * @example
+        * // Example of dynamically updating the download time windows and timeout settings.
+        * const dynamicConfig = {
+        *   httpDownloadTimeWindow: 60,  // Set HTTP download time window to 60 seconds
+        *   p2pDownloadTimeWindow: 60,   // Set P2P download time window to 60 seconds
+        *   httpNotReceivingBytesTimeoutMs: 1500,  // Set HTTP timeout to 1500 milliseconds
+        *   p2pNotReceivingBytesTimeoutMs: 1500    // Set P2P timeout to 1500 milliseconds
+        * };
+        * core.applyDynamicConfig(dynamicConfig);
+        */
+        applyDynamicConfig(dynamicConfig: any): void;
+        processSpecificDynamicConfigParams(prevConfig: any, updatedConfig: any, streamType: any): void;
+        getUpdatedStreamProperty(propertyName: any, updatedConfig: any, streamType: any): any;
+        /**
+        * Adds an event listener for the specified event type on the core event target.
+        *
+        * @param eventName - The name of the event to listen for.
+        * @param listener - The callback function to invoke when the event is fired.
+        */
+        addEventListener(eventName: any, listener: any): void;
+        /**
+        * Removes an event listener for the specified event type on the core event target.
+        *
+        * @param eventName - The name of the event to listen for.
+        * @param listener - The callback function to be removed.
+        */
+        removeEventListener(eventName: any, listener: any): void;
+        /**
+        * Sets the response URL for the manifest, stripping any query parameters.
+        *
+        * @param url - The full URL to the manifest response.
+        */
+        setManifestResponseUrl(url: any): void;
+        /**
+        * Checks if a segment is already stored within the core.
+        *
+        * @param segmentRuntimeId - The runtime identifier of the segment to check.
+        * @returns `true` if the segment is present, otherwise `false`.
+        */
+        hasSegment(segmentRuntimeId: any): boolean;
+        /**
+        * Retrieves a specific stream by its runtime identifier, if it exists.
+        *
+        * @param streamRuntimeId - The runtime identifier of the stream to retrieve.
+        * @returns The stream with its segments, or `undefined` if not found.
+        */
+        getStream(streamRuntimeId: any): any;
+        /**
+        * Ensures a stream exists in the map; adds it if it does not.
+        *
+        * @param stream - The stream to potentially add to the map.
+        */
+        addStreamIfNoneExists(stream: any): void;
+        /**
+        * Updates the segments associated with a specific stream.
+        *
+        * @param streamRuntimeId - The runtime identifier of the stream to update.
+        * @param addSegments - Optional segments to add to the stream.
+        * @param removeSegmentIds - Optional segment IDs to remove from the stream.
+        */
+        updateStream(streamRuntimeId: any, addSegments: any, removeSegmentIds: any): void;
+        /**
+        * Loads a segment given its runtime identifier and invokes the provided callbacks during the process.
+        * Initializes segment storage if it has not been initialized yet.
+        *
+        * @param segmentRuntimeId - The runtime identifier of the segment to load.
+        * @param callbacks - The callbacks to be invoked during segment loading.
+        * @throws {Error} - Throws if the manifest response URL is not defined.
+        */
+        loadSegment(segmentRuntimeId: any, callbacks: any): Promise<void>;
+        /**
+        * Aborts the loading of a segment specified by its runtime identifier.
+        *
+        * @param segmentRuntimeId - The runtime identifier of the segment whose loading is to be aborted.
+        */
+        abortSegmentLoading(segmentRuntimeId: any): void;
+        /**
+        * Updates the playback parameters while play head moves, specifically position and playback rate, for stream loaders.
+        *
+        * @param position - The new position in the stream, in seconds.
+        * @param rate - The new playback rate.
+        */
+        updatePlayback(position: any, rate: any): void;
+        /**
+        * Sets the active level bitrate, used for adjusting quality levels in adaptive streaming.
+        * Notifies the stream loaders if a change occurs.
+        *
+        * @param bitrate - The new bitrate to set as active.
+        */
+        setActiveLevelBitrate(bitrate: any): void;
+        /**
+        * Updates the 'isLive' status of the stream
+        *
+        * @param isLive - Boolean indicating whether the stream is live.
+        */
+        setIsLive(isLive: any): void;
+        /**
+        * Identify if a segment is loadable by the P2P core based on the segment's stream type and configuration.
+        * @param segmentRuntimeId Segment runtime identifier to check.
+        * @returns `true` if the segment is loadable by the P2P core, otherwise `false`.
+        */
+        isSegmentLoadable(segmentRuntimeId: any): boolean;
+        /**
+        * Cleans up resources used by the Core instance, including destroying any active stream loaders
+        * and clearing stored segments.
+        */
+        destroy(): void;
+        initializeSegmentStorage(): Promise<any>;
+        identifySegment(segmentRuntimeId: any): any;
+        overrideAllConfigs(dynamicConfig: any, mainStream: any, secondaryStream: any): void;
+        destroyStreamLoader(streamType: any): void;
+        getStreamHybridLoader(segment: any): any;
+        createNewHybridLoader(segment: any): {
+            streamManifestUrl: any;
+            lastRequestedSegment: any;
+            streamDetails: any;
+            config: any;
+            bandwidthCalculators: any;
+            segmentStorage: any;
+            webTorrentSocketPool: any;
+            eventTarget: any;
+            peerId: any;
+            requests: {
+                requestProcessQueueCallback: any;
+                bandwidthCalculators: any;
+                playback: any;
+                config: any;
+                eventTarget: any;
+                swarmId: any;
+                requests: Map<any, any>;
+                get executingHttpCount(): number;
+                get executingP2PCount(): number;
+                get(segment: any): any;
+                getOrCreateRequest(segment: any): any;
+                remove(request: any): void;
+                items(): MapIterator<any>;
+                httpRequests(): Generator<any, void, unknown>;
+                p2pRequests(): Generator<any, void, unknown>;
+                destroy(): void;
+            };
+            engineRequest: any;
+            p2pLoaders: {
+                "__#private@#loaders": Map<any, any>;
+                "__#private@#currentLoaderItem": any;
+                "__#private@#logger": any;
+                "__#private@#streamManifestUrl": any;
+                "__#private@#requests": any;
+                "__#private@#segmentStorage": any;
+                "__#private@#config": any;
+                "__#private@#webTorrentSocketPool": any;
+                "__#private@#eventTarget": any;
+                "__#private@#peerId": any;
+                "__#private@#onSegmentAnnouncement": any;
+                "__#private@#createLoader"(stream: any): {
+                    loader: {
+                        "__#private@#webtorrentManager": {
+                            "__#private@#config": any;
+                            "__#private@#eventTarget": {
+                                events: Map<any, any>;
+                                dispatchEvent(eventName: any, a1: any, a2: any, a3: any, a4: any, a5: any): void;
+                                getEventDispatcher(eventName: any): (a1: any, a2: any, a3: any, a4: any, a5: any) => void;
+                                addEventListener(eventName: any, listener: any): void;
+                                removeEventListener(eventName: any, listener: any): void;
+                                clear(): void;
+                            };
+                            "__#private@#connectingPeers": Set<any>;
+                            "__#private@#connectedPeers": Map<any, any>;
+                            "__#private@#clients": Set<any>;
+                            "__#private@#destroyed": boolean;
+                            "__#private@#started": boolean;
+                            "__#private@#claimPeer": (remotePeerId: any) => boolean;
+                            addEventListener(eventName: any, listener: any): void;
+                            removeEventListener(eventName: any, listener: any): void;
+                            start(): void;
+                            destroy(): void;
+                            "__#private@#closePeer"(peerId: any, cause: any): void;
+                            "__#private@#addConnectedPeer"(peerId: any, connection: any, channel: any, trackerUrl: any): void;
+                        };
+                        "__#private@#peersMap": Map<any, any>;
+                        "__#private@#swarmId": any;
+                        "__#private@#streamSwarmId": string;
+                        "__#private@#isAnnounceMicrotaskCreated": boolean;
+                        "__#private@#webtorrentManagerLogger": any;
+                        "__#private@#churnLogger": any;
+                        "__#private@#infoHash": string;
+                        "__#private@#streamManifestUrl": any;
+                        "__#private@#stream": any;
+                        "__#private@#requests": any;
+                        "__#private@#segmentStorage": any;
+                        "__#private@#config": any;
+                        "__#private@#webTorrentSocketPool": any;
+                        "__#private@#eventTarget": any;
+                        "__#private@#onSegmentAnnouncement": any;
+                        "__#private@#churnCleanupTimeoutId": NodeJS.Timeout;
+                        "__#private@#onPeerConnect": any;
+                        "__#private@#onPeerConnectError": any;
+                        "__#private@#onPeerClose": any;
+                        "__#private@#onPeerError": any;
+                        "__#private@#onPeerWarning": any;
+                        "__#private@#onTrackerWarning": any;
+                        "__#private@#onTrackerError": any;
+                        "__#private@#onPeerSegmentsAnnouncement": any;
+                        "__#private@#churnCleanup": () => void;
+                        downloadSegment(segment: any): void;
+                        isSegmentLoadingOrLoadedBySomeone(segment: any): boolean;
+                        isSegmentLoadedBySomeone(segment: any): boolean;
+                        get connectedPeerCount(): number;
+                        peers(): Generator<any, void, unknown>;
+                        "__#private@#getSegmentsAnnouncement"(): {
+                            loaded: any;
+                            httpLoading: any[];
+                        };
+                        "__#private@#onPeerConnectedWebTorrent": (event: any) => void;
+                        "__#private@#onPeerDisconnectedWebTorrent": (event: any) => void;
+                        broadcastAnnouncement: (sendEmptyAnnouncement?: boolean) => void;
+                        "__#private@#sendSegmentsAnnouncement": (sendEmptyAnnouncement?: boolean) => void;
+                        "__#private@#onSegmentRequested": (peer: any, segmentExternalId: any, requestId: any, byteFrom: any) => Promise<void>;
+                        destroy(): void;
+                    };
+                    stream: any;
+                    loggerInfo: string;
+                };
+                "__#private@#findOrCreateLoaderForStream"(stream: any): any;
+                changeCurrentLoader(stream: any): void;
+                "__#private@#setLoaderDestroyTimeout"(item: any): void;
+                "__#private@#destroyAndRemoveLoader"(item: any): void;
+                get currentLoader(): any;
+                destroy(): void;
+            };
+            playback: {
+                position: any;
+                rate: number;
+            };
+            segmentAvgDuration: number;
+            logger: any;
+            levelChangedTimestamp: any;
+            lastQueueProcessingTimeStamp: any;
+            randomHttpDownloadTimeout: any;
+            initialHttpDelayTimeoutId: any;
+            isProcessQueueMicrotaskCreated: boolean;
+            swarmId: any;
+            createdAt: number;
+            setIntervalLoading(): void;
+            loadSegment(segment: any, callbacks: any): Promise<void>;
+            requestProcessQueueMicrotask: (force?: boolean) => void;
+            processRequests(queueSegmentIds: any, queueDownloadRatio: any): void;
+            processQueue(): void;
+            abortSegmentRequest(segmentRuntimeId: any): void;
+            loadThroughHttp(segment: any): void;
+            loadThroughP2P(segment: any): void;
+            loadRandomThroughHttp(): void;
+            abortLastHttpLoadingInQueueAfterItem(queue: any, segment: any): boolean;
+            abortLastP2PLoadingInQueueAfterItem(queue: any, segment: any): boolean;
+            getAvailableStorageCapacityPercent(): number;
+            generateQueue(): {
+                queue: {
+                    segment: any;
+                    statuses: {
+                        isHighDemand: boolean;
+                        isHttpDownloadable: boolean;
+                        isP2PDownloadable: any;
+                    };
+                }[];
+                queueSegmentIds: Set<any>;
+                maxPossibleLength: number;
+                alreadyLoadedCount: number;
+                queueDownloadRatio: number;
+            };
+            getBandwidth(queueDownloadRatio: any): any;
+            notifyLevelChanged(): void;
+            sendBroadcastAnnouncement(sendEmptySegmentsAnnouncement?: boolean): void;
+            updatePlayback(position: any, rate: any): void;
+            updateStream(stream: any): void;
+            destroy(): void;
+        };
+    };
+    /** Default configuration for common core settings. */
+    DEFAULT_COMMON_CORE_CONFIG: {
+        segmentMemoryStorageLimit: undefined;
+        customSegmentStorageFactory: undefined;
+        trackerClientVersionPrefix: string;
+    };
+    /** Default configuration for stream settings. */
+    DEFAULT_STREAM_CONFIG: {
+        isP2PUploadDisabled: boolean;
+        isP2PDisabled: boolean;
+        simultaneousHttpDownloads: number;
+        simultaneousP2PDownloads: number;
+        preferP2PForEngineRequest: boolean;
+        highDemandTimeWindow: number;
+        httpDownloadInitialTimeoutMs: number;
+        httpDownloadTimeWindow: number;
+        p2pDownloadTimeWindow: number;
+        webRtcMaxMessageSize: number;
+        p2pNotReceivingBytesTimeoutMs: number;
+        p2pInactiveLoaderDestroyTimeoutMs: number;
+        httpNotReceivingBytesTimeoutMs: number;
+        httpErrorRetries: number;
+        p2pErrorRetries: number;
+        announceTrackers: string[];
+        rtcConfig: {
+            iceServers: {
+                urls: string;
+            }[];
+        };
+        validateP2PSegment: undefined;
+        validateHTTPSegment: undefined;
+        httpRequestSetup: undefined;
+        swarmId: undefined;
+        p2pMaxPeers: number;
+        p2pChurnMaxPeersMultiplier: number;
+        p2pChurnCleanupIntervalMs: number;
+        p2pChurnGracePeriodMs: number;
+        webRtcOffersCount: number;
+        webRtcOfferTimeoutMs: number;
+        webRtcIceGatheringTimeoutMs: number;
+        webRtcConnectionTimeoutMs: number;
+    };
+};
+/** Custom error class for errors that occur during core network requests. */
+export var CoreRequestError: {
+    new (type: any, message: any, cause: any): {
+        name: string;
+        type: any;
+        cause: any;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** Represents an error that occurred while establishing a peer connection. */
+export var PeerConnectError: {
+    new (type: any, message: any, cause: any): {
+        name: string;
+        type: any;
+        cause: any;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** Represents an error that occurred during a peer connection. */
+export var PeerError: {
+    new (type: any, message: any, cause: any): {
+        name: string;
+        type: any;
+        cause: any;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** Represents a warning that occurred during a peer connection. */
+export var PeerWarning: {
+    new (type: any, message: any, cause: any): {
+        name: string;
+        type: any;
+        cause: any;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/**
+* Represents an error that can occur during the request process, with a timestamp for when the error occurred.
+* @template T - The specific type of request error.
+*/
+export var RequestError: {
+    new <T>(type: any, message: any, cause: any): {
+        name: string;
+        /** Error timestamp. */
+        timestamp: number;
+        type: any;
+        cause: any;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** Represents an error that occurred during a tracker request. */
+export var TrackerError: {
+    new (type: any, message: any, cause: any): {
+        name: string;
+        type: any;
+        cause: any;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** Represents a warning that occurred during a tracker request. */
+export var TrackerWarning: {
+    new (type: any, message: any, cause: any): {
+        name: string;
+        type: any;
+        cause: any;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/**
+* Base class for domain-specific errors carrying a machine-readable type discriminator.
+* @internal
+*/
+export var TypedError: {
+    new (type: any, message: any, cause: any): {
+        type: any;
+        cause: any;
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export var debug: any;
+/**
+* Generates a stable, unique string ID for a stream based on its properties.
+* Uses a SHA-1 hash to avoid collisions and encodes the result to standard Base64.
+*/
+export function generateStreamShortId({ bitrate, codecs, width, height, language, channels, name, frameRate, videoRange }: {
+    bitrate: any;
+    codecs: any;
+    width: any;
+    height: any;
+    language: any;
+    channels: any;
+    name: any;
+    frameRate: any;
+    videoRange: any;
+}): string;

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** SDK release identifier attached to all Web usage reports. */
+export declare const MESHSTREAM_WEB_SDK_VERSION = "0.2.0";

package/package.json

@@ -1,6 +1,53 @@
-{
-  "name": "@meshstream/p2p-web",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@meshstream/p2p-web",
+  "version": "0.2.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./adapters": {
+      "types": "./dist/adapters.d.ts",
+      "import": "./dist/adapters.js"
+    },
+    "./advanced": {
+      "types": "./dist/advanced.d.ts",
+      "import": "./dist/advanced.js"
+    },
+    "./service-worker": {
+      "types": "./dist/service-worker.d.ts",
+      "import": "./dist/service-worker.js"
+    }
+  },
+  "files": [
+    "dist/*.d.ts",
+    "dist/**/*.d.ts",
+    "dist/index.js",
+    "dist/adapters.js",
+    "dist/advanced.js",
+    "dist/service-worker.js",
+    "dist/meshstream-sw.js",
+    "src/vendor/MESHSTREAM_CORE_LICENSE.txt"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:release": "npm run build && node ../../scripts/bundle-web-sdk.mjs && node ../../scripts/minify-web-sdk.mjs dist",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "prepack": "npm test && npm run build:release",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "devDependencies": {
+    "dashjs": "^5.2.1",
+    "esbuild": "^0.28.2",
+    "hls.js": "^1.6.13",
+    "p2p-media-loader-core": "file:src/vendor/p2p-media-loader-core-3.0.1.tgz",
+    "p2p-media-loader-hlsjs": "3.0.1",
+    "p2p-media-loader-shaka": "3.0.1",
+    "shaka-player": "^4.16.47",
+    "terser": "^5.51.2",
+    "typescript": "^5.9.0"
+  }
+}