334 lines
9.0 KiB
TypeScript
334 lines
9.0 KiB
TypeScript
/*
|
|
* Copyright 2025 coze-dev Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
export interface STSToken {
|
|
AccessKeyId: string;
|
|
SecretAccessKey: string;
|
|
SessionToken: string;
|
|
ExpiredTime: string;
|
|
CurrentTime: string;
|
|
}
|
|
|
|
export interface ObjectSync {
|
|
ChannelSource: string;
|
|
ChannelDest: string;
|
|
DataType: string;
|
|
BizID: string;
|
|
}
|
|
|
|
export interface Action {
|
|
name:
|
|
| 'GetMeta'
|
|
| 'StartWorkflow'
|
|
| 'Snapshot'
|
|
| 'Encryption'
|
|
| 'AddOptionInfo'
|
|
| 'CaptionUpload';
|
|
input?: any;
|
|
}
|
|
|
|
export interface VideoConfig {
|
|
spaceName: string;
|
|
processAction?: Action[];
|
|
}
|
|
|
|
export interface ImageConfig {
|
|
serviceId: string;
|
|
processAction?: Action[];
|
|
}
|
|
|
|
export interface ObjectConfig {
|
|
serviceId?: string;
|
|
spaceName?: string;
|
|
processAction?: Action[];
|
|
}
|
|
|
|
export interface Config {
|
|
userId: string;
|
|
appId: number;
|
|
stsToken?: STSToken;
|
|
region?:
|
|
| 'cn-north-1'
|
|
| 'us-east-1'
|
|
| 'ap-singapore-1'
|
|
| 'us-east-red'
|
|
| 'boe'
|
|
| 'boei18n'
|
|
| 'US-TTP'
|
|
| 'gcp';
|
|
videoHost?: string;
|
|
videoFallbackHost?: string;
|
|
imageHost?: string;
|
|
imageFallbackHost?: string;
|
|
videoConfig?: VideoConfig;
|
|
imageConfig?: ImageConfig;
|
|
objectConfig?: ObjectConfig;
|
|
testHost?: string;
|
|
/**
|
|
* Tt-uploader logic,
|
|
* The schema needs to be dynamically obtained according to the deployment environment of the current user
|
|
* Schema values are only available in HTTPS and HTTP.
|
|
* The SDK consumes schema internally, but there is no type definition, which is compatible with specialization.
|
|
*/
|
|
schema?: string;
|
|
|
|
useFileExtension?: boolean;
|
|
useServerCurrentTime?: boolean;
|
|
bizType?: string;
|
|
getSliceFunc?: (fileSize: number) => number;
|
|
uploadSliceCount?: number;
|
|
uploadHttpMethod?: string;
|
|
// upload timeout
|
|
uploadTimeout?: number;
|
|
// Upload gateway timeout
|
|
gatewayTimeout?: number;
|
|
// Skip download, only video upload is supported.
|
|
skipDownload?: boolean;
|
|
// Skip getting meta information, only picture upload support
|
|
skipMeta?: boolean;
|
|
noLog?: boolean;
|
|
// multi-instance identification
|
|
instanceId?: string;
|
|
// Passing appId and userId through
|
|
openExperiment?: boolean;
|
|
// Client side encryption
|
|
clientEncrypt?: boolean;
|
|
// Skip 1005, only support ImageX
|
|
skipCommit?: boolean;
|
|
// Whether to enable breakpoint continuation
|
|
enableDiskBreakpoint?: boolean;
|
|
}
|
|
|
|
export interface UpdateOptions {
|
|
userId?: string;
|
|
appId?: number;
|
|
stsToken?: STSToken;
|
|
region?:
|
|
| 'cn-north-1'
|
|
| 'us-east-1'
|
|
| 'ap-singapore-1'
|
|
| 'us-east-red'
|
|
| 'boe'
|
|
| 'boei18n'
|
|
| 'US-TTP'
|
|
| 'gcp';
|
|
videoHost?: string;
|
|
imageHost?: string;
|
|
videoConfig?: VideoConfig;
|
|
imageConfig?: ImageConfig;
|
|
|
|
useFileExtension?: boolean;
|
|
useServerCurrentTime?: boolean;
|
|
getSliceFunc?: (fileSize: number) => number;
|
|
uploadSliceCount?: number;
|
|
uploadHttpMethod?: string;
|
|
openExperiment?: boolean;
|
|
// Client side encryption
|
|
clientEncrypt?: boolean;
|
|
}
|
|
|
|
export interface FileOption {
|
|
file: Blob;
|
|
stsToken: STSToken;
|
|
type?: 'video' | 'image' | 'object';
|
|
callbackArgs?: string;
|
|
testHost?: string;
|
|
objectSync?: ObjectSync;
|
|
needExactFormat?: boolean;
|
|
storeKey?: string | Array<string>;
|
|
useDirectUpload?: boolean;
|
|
serviceType?: 'vod' | 'imagex';
|
|
}
|
|
|
|
export interface ImageFileOption {
|
|
file: Blob | Blob[];
|
|
stsToken: STSToken;
|
|
type?: 'image';
|
|
callbackArgs?: string;
|
|
storeKey?: string | Array<string>;
|
|
useDirectUpload?: boolean;
|
|
}
|
|
|
|
export interface StartOptions {
|
|
selectRoute?: boolean;
|
|
clientIp?: string;
|
|
selectRouteTimeout?: number;
|
|
selectRouteCacheTime?: number;
|
|
selectRouteFileSize?: number;
|
|
}
|
|
|
|
export interface StreamTaskOption {
|
|
stsToken: STSToken;
|
|
type?: 'video';
|
|
fileSize?: number;
|
|
}
|
|
|
|
export interface StreamSliceOption {
|
|
fileSlice: Blob;
|
|
index: number;
|
|
}
|
|
|
|
interface BaseEventInfo {
|
|
// File start upload timestamp, milliseconds
|
|
startTime: number;
|
|
// File completion upload timestamp
|
|
endTime: number;
|
|
// Phase start timestamp
|
|
stageStartTime: number;
|
|
// Phase completion timestamp
|
|
stageEndTime: number;
|
|
// Phase duration, calculated as stageEndTime - stageStartTime
|
|
duration: number;
|
|
// Current video file size
|
|
fileSize: number;
|
|
// The key of the current video file (automatically generated when addFile)
|
|
key: string;
|
|
// Stored file ID (preUpload)
|
|
oid: string;
|
|
// Current Upload Overall Progress Percentage (%)
|
|
percent: number;
|
|
// Upload the required signature information (preUpload)
|
|
signature: string;
|
|
// The size of each sharding (obtained by crc32)
|
|
sliceLength: number;
|
|
// The current lifecycle, if it is an unsupported browser, the value is'browserError'
|
|
stage: string;
|
|
// File upload running status, 1 means running, 2 means canceling, and 3 means pausing.
|
|
status: 1 | 2 | 3;
|
|
// Task queue instance
|
|
task: any;
|
|
type: 'success' | 'error'; // Current task status, success/failure
|
|
// Upload the required uploadID (get initUploadID)
|
|
uploadID: string;
|
|
// Description of the current state (constantly changing with the lifecycle)
|
|
extra: {
|
|
error?: any;
|
|
errorCode?: number;
|
|
message: string;
|
|
};
|
|
}
|
|
|
|
export interface UploadResultVideoMeta {
|
|
// Video duration in seconds
|
|
Duration: number;
|
|
// video width
|
|
Width: number;
|
|
// video height
|
|
Height: number;
|
|
// video format
|
|
Format: string;
|
|
// Video bit rate
|
|
Bitrate: number;
|
|
// file type
|
|
FileType: string;
|
|
// Video file size
|
|
Size: number;
|
|
// Video file md5 value, Note: Since MD5 needs to be downloaded and calculated, it consumes a large amount of network resources and computing resources, and most users do not use it. By default, MD5 is only returned when it is less than 100M and not an M3U8 file. Strong dependence on MD5 needs to be contacted for manual configuration.
|
|
Md5: string;
|
|
// The video source file is URI in tos, get the video broadcast address, please do not use this way to access
|
|
Uri: string;
|
|
}
|
|
|
|
/**
|
|
* Upload results, there are differences for different file types, which can be handled with paradigms here, but it is a bit cumbersome.
|
|
* For convenience, all the attributes are directly defined.
|
|
*/
|
|
export interface UploadResult {
|
|
// video
|
|
// =======
|
|
// video VID
|
|
Vid?: string;
|
|
// Video meta information, returned when a configuration for obtaining meta information is added
|
|
VideoMeta?: UploadResultVideoMeta;
|
|
// Cover image URI, returned when a configuration for capturing cover information is added
|
|
PosterUri?: string;
|
|
|
|
// Pictures & Files
|
|
// ==========
|
|
// The URI of the source file in tos, in the format bucket/oid. Consistent with ImageUri for images
|
|
Uri?: string;
|
|
|
|
// picture
|
|
// ==========
|
|
// Image URI in bucket/oid format
|
|
ImageUri?: string;
|
|
// image width
|
|
ImageWidth?: number;
|
|
// image height
|
|
ImageHeight?: number;
|
|
// The md5 value of the image data
|
|
ImageMd5?: string;
|
|
// File name, consistent with the oid section in ImageUri
|
|
FileName?: string;
|
|
|
|
// file
|
|
// ==========
|
|
// File meta information, returned when a configuration for obtaining meta information is added
|
|
ObjectMeta?: {
|
|
Md5: string;
|
|
Uri: string;
|
|
};
|
|
}
|
|
|
|
export type ProgressEventInfo = BaseEventInfo;
|
|
|
|
export type StreamProgressEventInfo = BaseEventInfo;
|
|
export type ErrorEventInfo = BaseEventInfo;
|
|
|
|
export interface CompleteEventInfo extends BaseEventInfo {
|
|
// Upload the results, note that the structure is different for different types,
|
|
uploadResult: UploadResult;
|
|
}
|
|
|
|
export interface EventPayloadMaps {
|
|
complete: CompleteEventInfo;
|
|
progress: ProgressEventInfo;
|
|
'stream-progress': StreamProgressEventInfo;
|
|
error: ErrorEventInfo;
|
|
}
|
|
|
|
type UploadEventName = 'complete' | 'error' | 'progress' | 'stream-progress';
|
|
|
|
export interface BytedUploader {
|
|
constructor: (config: Config) => void;
|
|
setOption: (options: UpdateOptions) => void;
|
|
addFile: (fileOption: FileOption) => string;
|
|
addImageFile: (imageFileOption: ImageFileOption) => string;
|
|
start: (key?: string, startOptions?: StartOptions) => void;
|
|
pause: (key?: string) => void;
|
|
cancel: (key?: string) => void;
|
|
removeFile: (key?: string) => void;
|
|
refreshSTSToken: (stsToken: STSToken) => void;
|
|
|
|
addStreamUploadTask: (streamOption: StreamTaskOption) => string;
|
|
addStreamSlice: (streamSlice: StreamSliceOption) => void;
|
|
completeStreamUpload: () => void;
|
|
|
|
on: <T extends UploadEventName>(
|
|
eventName: T,
|
|
callback: (info: EventPayloadMaps[T]) => void,
|
|
) => void;
|
|
once: <T extends UploadEventName>(
|
|
eventName: T,
|
|
callback: (info: EventPayloadMaps[T]) => void,
|
|
) => void;
|
|
removeListener: <T extends UploadEventName>(
|
|
eventName: T,
|
|
callback: (info: EventPayloadMaps[T]) => void,
|
|
) => void;
|
|
removeAllListeners: (eventName: UploadEventName) => void;
|
|
}
|