zyjj-web-sdk 1.1.33 → 2.0.0

package/lib/contract-v2/types.d.ts

@@ -0,0 +1,375 @@
+export declare const CONTRACT_VERSION_V2: "2.0.0";
+export type HostCapability = 'system.getRuntimeInfo' | 'navigation.openExternal' | 'navigation.close' | 'navigation.reveal' | 'files.pick' | 'files.read' | 'files.write' | 'files.stat' | 'files.removeTemp' | 'ffmpeg.execute' | 'ffmpeg.probe' | 'ffmpeg.cancel' | 'downloads.start' | 'downloads.cancel' | 'tasks.create' | 'tasks.appendEvent' | 'tasks.snapshot' | 'tasks.list' | 'tasks.cancel' | 'tasks.clear' | 'cloud.upload' | 'cloud.download' | 'transport.subscribeTask' | 'transport.unsubscribeTask' | 'cloud.executeTask' | 'settings.get' | 'settings.set';
+export type HostErrorCode = 'INVALID_REQUEST' | 'CONTRACT_VERSION_MISMATCH' | 'CAPABILITY_DENIED' | 'RESOURCE_DENIED' | 'NOT_FOUND' | 'CANCELLED' | 'CONFLICT' | 'INTERNAL';
+export interface HostError {
+    code: HostErrorCode;
+    message: string;
+    retryable: boolean;
+}
+export interface RuntimeInfo {
+    platform: 'web' | 'electron';
+    contractVersion: typeof CONTRACT_VERSION_V2;
+    capabilities: HostCapability[];
+}
+/** Remote-visible metadata only. A path, URI, Blob URL, or filesystem handle never crosses Contract v2. */
+export interface ResourceRef {
+    id: string;
+    name: string;
+    mime: string;
+    size: number;
+}
+export interface FileReadResult {
+    bytesBase64: string;
+}
+export interface FileStatResult {
+    name: string;
+    mime: string;
+    size: number;
+}
+export type FfmpegVideoCodec = 'copy' | 'libx264' | 'libvpx-vp9';
+export type FfmpegAudioCodec = 'copy' | 'aac' | 'libopus' | 'libmp3lame';
+export type FfmpegPreset = 'ultrafast' | 'veryfast' | 'fast' | 'medium' | 'slow';
+export interface FfmpegTrim {
+    startSeconds: number;
+    durationSeconds: number;
+}
+export interface FfmpegSource {
+    sourceId: string;
+    resource: ResourceRef;
+    mediaKind: 'video' | 'audio' | 'image';
+}
+export interface FfmpegOutputProfile {
+    name: string;
+    mime: 'video/mp4' | 'video/webm' | 'audio/mpeg' | 'audio/mp4' | 'image/png';
+    width?: number;
+    height?: number;
+    fps?: number;
+    videoCodec?: FfmpegVideoCodec;
+    audioCodec?: FfmpegAudioCodec;
+    preset?: FfmpegPreset;
+    crf?: number;
+}
+export interface FfmpegTranscodePlan {
+    kind: 'transcode';
+    source: FfmpegSource;
+    trim?: FfmpegTrim;
+    loop?: boolean;
+    includeVideo: boolean;
+    includeAudio: boolean;
+    output: FfmpegOutputProfile;
+}
+export interface FfmpegTransform {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    opacity: number;
+}
+export interface FfmpegVideoClip {
+    clipId: string;
+    sourceId: string;
+    timelineStartSeconds: number;
+    sourceStartSeconds: number;
+    durationSeconds: number;
+    transform: FfmpegTransform;
+}
+export interface FfmpegVideoTrack {
+    trackId: string;
+    mode: 'concat' | 'overlay';
+    layer: number;
+    clips: FfmpegVideoClip[];
+}
+export interface FfmpegAudioClip {
+    clipId: string;
+    sourceId: string;
+    timelineStartSeconds: number;
+    sourceStartSeconds: number;
+    durationSeconds: number;
+    volume: number;
+}
+export interface FfmpegAudioTrack {
+    trackId: string;
+    clips: FfmpegAudioClip[];
+}
+export interface FfmpegTextLayer {
+    layerId: string;
+    text: string;
+    timelineStartSeconds: number;
+    durationSeconds: number;
+    x: number;
+    y: number;
+    fontSize: number;
+    color: string;
+    background: string;
+    opacity: number;
+    layer: number;
+}
+export interface FfmpegCompositionPlan {
+    kind: 'composition';
+    canvas: {
+        width: number;
+        height: number;
+        fps: number;
+        durationSeconds: number;
+        background: string;
+    };
+    sources: FfmpegSource[];
+    videoTracks: FfmpegVideoTrack[];
+    audioTracks: FfmpegAudioTrack[];
+    textLayers: FfmpegTextLayer[];
+    output: FfmpegOutputProfile;
+}
+export interface FfmpegFrameSequencePlan {
+    kind: 'frame-sequence';
+    width: number;
+    height: number;
+    fps: number;
+    frames: Array<{
+        frameId: string;
+        resource: ResourceRef;
+    }>;
+    output: FfmpegOutputProfile;
+}
+export type FfmpegPlan = FfmpegTranscodePlan | FfmpegCompositionPlan | FfmpegFrameSequencePlan;
+export type TaskStateV2 = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+export type TaskEventTypeV2 = 'queued' | 'running' | 'stage.started' | 'stage.progress' | 'stage.retry' | 'log' | 'completed' | 'failed' | 'cancelled';
+export interface TaskEventRecordV2 {
+    eventId: string;
+    taskId: string;
+    seq: number;
+    at: string;
+    type: TaskEventTypeV2;
+    data: Record<string, string | number | boolean | null>;
+}
+export interface TaskSnapshotV2 {
+    taskId: string;
+    releaseId: string;
+    schedulerVersion: string;
+    planSnapshot: Record<string, unknown>;
+    state: TaskStateV2;
+    lastEventSeq: number;
+}
+export interface TaskSnapshotResult {
+    snapshot: TaskSnapshotV2 | null;
+    events: TaskEventRecordV2[];
+}
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type CloudUploadBackend = 'tencent-cos' | 'aliyun-oss';
+interface RequestBase<C extends HostCapability, P> {
+    requestId: string;
+    contractVersion: typeof CONTRACT_VERSION_V2;
+    capability: C;
+    payload: P;
+}
+export interface HostPayloadMap {
+    'system.getRuntimeInfo': Record<string, never>;
+    'navigation.openExternal': {
+        url: string;
+    };
+    'navigation.close': Record<string, never>;
+    'navigation.reveal': {
+        resource: ResourceRef;
+    };
+    'files.pick': {
+        accept: string[];
+        multiple: boolean;
+    };
+    'files.read': {
+        resource: ResourceRef;
+    };
+    'files.write': {
+        name: string;
+        mime: string;
+        bytesBase64: string;
+    };
+    'files.stat': {
+        resource: ResourceRef;
+    };
+    'files.removeTemp': {
+        resource: ResourceRef;
+    };
+    'ffmpeg.execute': {
+        taskId: string;
+        plan: FfmpegPlan;
+    };
+    'ffmpeg.probe': {
+        resource: ResourceRef;
+    };
+    'ffmpeg.cancel': {
+        taskId: string;
+    };
+    'downloads.start': {
+        resource: ResourceRef;
+        name: string;
+    };
+    'downloads.cancel': {
+        downloadId: string;
+    };
+    'tasks.create': TaskSnapshotV2;
+    'tasks.appendEvent': {
+        taskId: string;
+        event: TaskEventRecordV2;
+    };
+    'tasks.snapshot': {
+        taskId: string;
+    };
+    'tasks.list': Record<string, never>;
+    'tasks.cancel': {
+        taskId: string;
+    };
+    'tasks.clear': Record<string, never>;
+    'cloud.upload': {
+        resource: ResourceRef;
+        taskId?: string;
+    };
+    'cloud.download': {
+        url: string;
+        name: string;
+    };
+    'transport.subscribeTask': {
+        taskId: string;
+        afterSeq: number;
+    };
+    'transport.unsubscribeTask': {
+        subscriptionId: string;
+    };
+    'cloud.executeTask': {
+        taskId: string;
+        entityId: string;
+        input: {
+            [key: string]: JsonValue;
+        };
+        execution: 'sync' | 'async';
+    };
+    'settings.get': {
+        key: string;
+    };
+    'settings.set': {
+        key: string;
+        value: string | number | boolean;
+    };
+}
+export type HostRequest<C extends HostCapability = HostCapability> = C extends HostCapability ? RequestBase<C, HostPayloadMap[C]> : never;
+export interface HostResponseMap {
+    'system.getRuntimeInfo': RuntimeInfo;
+    'navigation.openExternal': Record<string, never>;
+    'navigation.close': Record<string, never>;
+    'navigation.reveal': Record<string, never>;
+    'files.pick': {
+        resources: ResourceRef[];
+    };
+    'files.read': FileReadResult;
+    'files.write': {
+        resource: ResourceRef;
+    };
+    'files.stat': FileStatResult;
+    'files.removeTemp': {
+        removed: string;
+    };
+    'ffmpeg.execute': {
+        outputs: ResourceRef[];
+        exitCode: number;
+    };
+    'ffmpeg.probe': {
+        durationSeconds: number | null;
+        streams: Array<{
+            codec: string;
+            kind: 'video' | 'audio' | 'other';
+        }>;
+    };
+    'ffmpeg.cancel': {
+        cancelled: string;
+    };
+    'downloads.start': {
+        downloadId: string;
+    };
+    'downloads.cancel': {
+        cancelled: string;
+    };
+    'tasks.create': TaskSnapshotV2;
+    'tasks.appendEvent': {
+        acceptedSeq: number;
+    };
+    'tasks.snapshot': TaskSnapshotResult;
+    'tasks.list': TaskSnapshotV2[];
+    'tasks.cancel': {
+        cancelled: string;
+    };
+    'tasks.clear': {
+        cleared: number;
+    };
+    'cloud.upload': {
+        key: string;
+        backend: CloudUploadBackend;
+    };
+    'cloud.download': {
+        resource: ResourceRef;
+    };
+    'transport.subscribeTask': {
+        subscriptionId: string;
+    };
+    'transport.unsubscribeTask': Record<string, never>;
+    'cloud.executeTask': {
+        backendTaskId: string | null;
+        output: {
+            [key: string]: JsonValue;
+        } | null;
+    };
+    'settings.get': {
+        value: string | number | boolean | null;
+    };
+    'settings.set': Record<string, never>;
+}
+export type HostSuccess<C extends HostCapability> = {
+    requestId: string;
+    contractVersion: typeof CONTRACT_VERSION_V2;
+    ok: true;
+    data: HostResponseMap[C];
+};
+export type HostFailure = {
+    requestId: string;
+    contractVersion: typeof CONTRACT_VERSION_V2;
+    ok: false;
+    error: HostError;
+};
+export type HostResponse<C extends HostCapability = HostCapability> = HostSuccess<C> | HostFailure;
+export interface TaskEventNotification {
+    subscriptionId: string;
+    taskId: string;
+    type: 'task.event';
+    event: TaskEventRecordV2;
+}
+export interface HostEvent {
+    subscriptionId: string;
+    taskId: string;
+    type: 'task.event';
+    event: TaskEventRecordV2;
+}
+export interface HostClientV2 {
+    invoke<C extends HostCapability>(request: HostRequest<C>): Promise<HostResponse<C>>;
+    subscribe(listener: (event: HostEvent) => void): () => void;
+    cancel(requestId: string): Promise<void>;
+    dispose?(): Promise<void>;
+}
+export interface RemoteAssetV2 {
+    url: string;
+    size: number;
+    sha256: string;
+    kind: 'js' | 'css' | 'wasm' | 'asset';
+    contentType: string;
+}
+export interface RemoteManifestV2 {
+    releaseId: string;
+    contractVersion: typeof CONTRACT_VERSION_V2;
+    uiEntry: string;
+    schedulerEntry: string;
+    assets: RemoteAssetV2[];
+    requiredCapabilities: HostCapability[];
+    issuedAt: string;
+    keyId: string;
+    signature: string;
+}
+export {};

package/lib/index.d.ts

@@ -1,126 +1,12 @@
-/// <reference types="ali-oss" />
-import { FileSource, LocalTaskStatus, LocalActionReqType, LocalActionResType, LocalTaskEventType, TaskType } from "./types/local-task.ts";
-import { CloudTaskStatus, ToolType } from "./types/cloud.ts";
-import { MQTTEventType } from "./types/mqtt.ts";
-import { FfmpegActionType, LabElementType, ToolConfigType, ToolTaskType } from "./types/tool-task.ts";
-import { TaskActionType, ToolEventType, WorkActionType } from "./types/new-local-task.ts";
+export * from './contract-v2/index.ts';
+export * from './api/api.ts';
+export * from './api/entity.ts';
+export * from './types/cloud.ts';
+export * from './types/config.ts';
+export * from './types/mqtt.ts';
+export * from './types/resource.ts';
+export * from './types/tool-task.ts';
 export { default as UserLoginModal } from './components/UserLogin.tsx';
-export type { UserLoginModalProps } from './components/UserLogin.tsx';
 export { default as PageTable } from './components/PageTable.tsx';
-export type { PageTableProps } from './components/PageTable.tsx';
 export { SendCommonRequest, SendKnowledgeRequest } from './api/api.ts';
-export declare const Api: {
-    GetAllTool: () => Promise<import("./api/entity.ts").GetPageInfo<import("./types/cloud.ts").ToolInfo>>;
-    ToolInc: (id: string) => Promise<unknown>;
-    UpdateUserInfo: (data: {
-        tool_id_list?: string[] | undefined;
-    }) => Promise<unknown>;
-    GetAppInfo: (os: string, version: string, uid?: string | undefined) => Promise<import("./types/cloud.ts").AppInfo>;
-    CostPoint: (data: {
-        name: string;
-        point: number;
-        desc: string;
-        uid: string;
-    }) => Promise<void>;
-    GetUserInfo: () => Promise<import("./types/cloud.ts").UserInfo>;
-    UserDownloadMaterial: (id: string) => Promise<string>;
-    GetMqttTaskClientInfo: () => Promise<import("./api/entity.ts").MqttClientInfo>;
-    AddTask: (data: import("./api/entity.ts").AddTaskReq) => Promise<string>;
-    GetTaskInfo: (id: string) => Promise<import("./types/cloud.ts").TaskInfo>;
-    GetTencentCosInfo: () => Promise<import("./api/entity.ts").GetCosResp>;
-    GetMaterialUrl: (key_list: string[]) => Promise<{
-        [key: string]: string;
-    }>;
-    GetMaterialTagList: () => Promise<string[]>;
-    GetToolList: (req: import("./api/entity.ts").GetPageReq) => Promise<import("./api/entity.ts").GetPageInfo<import("./types/cloud.ts").ToolInfo>>;
-    GetToolTagList: () => Promise<string[]>;
-    GetToolDetail: (id: string) => Promise<import("./api/entity.ts").GetToolDetailResp>;
-};
-export declare const Enum: {
-    ToolType: typeof ToolType;
-    LocalActionReqType: typeof LocalActionReqType;
-    LocalActionResType: typeof LocalActionResType;
-    MQTTEventType: typeof MQTTEventType;
-    FileSource: typeof FileSource;
-    LocalTaskStatus: typeof LocalTaskStatus;
-    LocalTaskEventType: typeof LocalTaskEventType;
-    ToolTaskType: typeof ToolTaskType;
-    FfmpegActionType: typeof FfmpegActionType;
-    CloudTaskStatus: typeof CloudTaskStatus;
-    TaskType: typeof TaskType;
-    LabElementType: typeof LabElementType;
-    ToolConfigType: typeof ToolConfigType;
-    ToolEventType: typeof ToolEventType;
-    WorkActionType: typeof WorkActionType;
-    TaskActionType: typeof TaskActionType;
-};
-export declare const Tool: {
-    render: {
-        renderTime: (time: number) => string;
-        renderEllipsis: (value: string) => import("react/jsx-runtime").JSX.Element;
-        renderCopy: (value: string) => import("react/jsx-runtime").JSX.Element;
-    };
-    utils: {
-        file2ToolParamFile: (file: File, no_path?: boolean | undefined, cloud_source?: FileSource | undefined) => import("./types/local-task.ts").ToolParamFile;
-        seconds2TimeStr: (seconds: number) => string;
-        object2query: (data: {
-            [key: string]: any;
-        }) => string;
-        paramReplace: (value: string, data: {
-            [key: string]: any;
-        }) => string;
-        object2urlParam: (data: {
-            [key: string]: any;
-        }) => string;
-        convertFileSize: (bytes: number) => string;
-        downloadFile: (url: string) => Promise<void>;
-        downloadFileDirect: (url: string, name?: string | undefined) => void;
-    };
-    cloud: {
-        getTencentCosInfo: () => Promise<{
-            cos: import("cos-js-sdk-v5");
-            path: string;
-            bucket: string;
-            region: string;
-        }>;
-        getAliYunOssInfo: () => Promise<{
-            oss: import("ali-oss");
-            path: string;
-            bucket: string;
-            region: string;
-        }>;
-    };
-    db: {
-        addTask: (data: import("./types/local-task.ts").LocalTaskInfo, table?: string) => Promise<IDBValidKey>;
-        getAllData: <T>(table?: string) => Promise<T[]>;
-        getData: <T_1>(id: string, table?: string) => Promise<T_1>;
-        updateData: <T_2>(id: string, data: T_2, table?: string) => Promise<IDBValidKey>;
-        deleteData: (id: string, table?: string) => Promise<void>;
-    };
-};
-export declare const Store: {
-    UserReducer: import("redux").Reducer<import("./store/entity.ts").UserState>;
-    UserAction: import("@reduxjs/toolkit").CaseReducerActions<{
-        loginOut(state: import("immer").WritableDraft<import("./store/entity.ts").UserState>): void;
-        showLogin(state: import("immer").WritableDraft<import("./store/entity.ts").UserState>): void;
-        hideLogin(state: import("immer").WritableDraft<import("./store/entity.ts").UserState>): void;
-    }, "user">;
-    GetUserInfo: import("@reduxjs/toolkit").AsyncThunk<import("./types/cloud.ts").UserInfo | undefined, undefined, any>;
-    MqttReducer: import("redux").Reducer<import("./store/entity.ts").MqttState>;
-    MqttAction: import("@reduxjs/toolkit").CaseReducerActions<{
-        closeClient(state: import("immer").WritableDraft<import("./store/entity.ts").MqttState>): void;
-        addMqttCallback(state: import("immer").WritableDraft<import("./store/entity.ts").MqttState>, info: {
-            payload: import("./types/mqtt.ts").MqttAddCallbackReq;
-            type: string;
-        }): void;
-        addMqttEventCallback(state: import("immer").WritableDraft<import("./store/entity.ts").MqttState>, info: {
-            payload: import("./types/mqtt.ts").MqttAddTaskEventReq;
-            type: string;
-        }): void;
-        addMqttListener(state: import("immer").WritableDraft<import("./store/entity.ts").MqttState>, info: {
-            payload: import("./store/entity.ts").MqttCallback;
-            type: string;
-        }): void;
-    }, "mqtt">;
-    InitMqtt: import("@reduxjs/toolkit").AsyncThunk<import("mqtt").MqttClient, undefined, any>;
-};
+export { getTencentCosInfo, getAliYunOssInfo } from './tool/utils.ts';