sa2kit 1.6.33 → 1.6.35

package/dist/mikuFireworks3D/index.d.mts

@@ -0,0 +1,174 @@
+import * as React from 'react';
+import React__default from 'react';
+import { M as MikuFireworks3DProps, F as FireworkKind, g as FireworksRealtimeConfig, h as FireworksRealtimeState, f as FireworksRealtimeUser, a as FireworkLaunchPayload, c as FireworkEngineOptions, D as DanmakuMessage, e as DanmakuControllerOptions, d as DanmakuSendResult } from '../types-Cgk9zWhO.mjs';
+export { b as FireworkPosition } from '../types-Cgk9zWhO.mjs';
+
+declare function MikuFireworks3D({ width, height, className, defaultKind, autoLaunchOnDanmaku, maxParticles, maxActiveFireworks, defaultAvatarUrl, onLaunch, onDanmakuSend, onError, onFpsReport, onRealtimeStateChange, realtime, }: MikuFireworks3DProps): React__default.JSX.Element;
+
+interface FireworksCanvasProps {
+    canvasRef: React__default.RefObject<HTMLCanvasElement>;
+}
+declare function FireworksCanvas({ canvasRef }: FireworksCanvasProps): React__default.JSX.Element;
+
+interface FireworksControlPanelProps {
+    selectedKind: FireworkKind;
+    onKindChange: (kind: FireworkKind) => void;
+    autoLaunchOnDanmaku: boolean;
+    onAutoLaunchChange: (value: boolean) => void;
+    avatarUrl: string;
+    onAvatarUrlChange: (value: string) => void;
+    onLaunch: () => void;
+    fps: number;
+    realtimeConnected?: boolean;
+    onlineCount?: number;
+}
+declare function FireworksControlPanel({ selectedKind, onKindChange, autoLaunchOnDanmaku, onAutoLaunchChange, avatarUrl, onAvatarUrlChange, onLaunch, fps, realtimeConnected, onlineCount, }: FireworksControlPanelProps): React__default.JSX.Element;
+
+interface DanmakuPanelProps {
+    onSend: (text: string) => void;
+}
+declare function DanmakuPanel({ onSend }: DanmakuPanelProps): React__default.JSX.Element;
+
+interface RealtimeDanmakuEvent {
+    id: string;
+    roomId: string;
+    text: string;
+    color?: string;
+    kind?: FireworkKind;
+    user: FireworksRealtimeUser;
+    timestamp: number;
+}
+interface RealtimeFireworkEvent {
+    id: string;
+    roomId: string;
+    payload: FireworkLaunchPayload;
+    user: FireworksRealtimeUser;
+    timestamp: number;
+}
+type ServerMessage = {
+    type: 'joined';
+    roomId: string;
+    onlineCount: number;
+    self: FireworksRealtimeUser;
+} | {
+    type: 'room.snapshot';
+    roomId: string;
+    users: FireworksRealtimeUser[];
+    danmakuHistory: RealtimeDanmakuEvent[];
+    fireworkHistory: RealtimeFireworkEvent[];
+} | {
+    type: 'room.user_joined';
+    roomId: string;
+    user: FireworksRealtimeUser;
+    onlineCount: number;
+} | {
+    type: 'room.user_left';
+    roomId: string;
+    userId: string;
+    onlineCount: number;
+} | {
+    type: 'danmaku.broadcast';
+    roomId: string;
+    event: RealtimeDanmakuEvent;
+} | {
+    type: 'firework.broadcast';
+    roomId: string;
+    event: RealtimeFireworkEvent;
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+} | {
+    type: 'pong';
+    ts: number;
+};
+interface WebSocketTransportCallbacks {
+    onStateChange?: (state: FireworksRealtimeState) => void;
+    onDanmakuBroadcast?: (event: RealtimeDanmakuEvent) => void;
+    onFireworkBroadcast?: (event: RealtimeFireworkEvent) => void;
+    onSnapshot?: (snapshot: Extract<ServerMessage, {
+        type: 'room.snapshot';
+    }>) => void;
+    onError?: (error: Error) => void;
+}
+declare class WebSocketTransport {
+    private socket;
+    private reconnectTimer;
+    private isManualClose;
+    private readonly config;
+    private readonly callbacks;
+    private state;
+    constructor(config: FireworksRealtimeConfig, callbacks?: WebSocketTransportCallbacks);
+    connect(): void;
+    disconnect(): void;
+    sendDanmaku(payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    }): void;
+    sendFirework(payload: FireworkLaunchPayload): void;
+    getState(): FireworksRealtimeState;
+    private send;
+    private updateState;
+    private handleServerMessage;
+    private scheduleReconnect;
+}
+
+interface UseFireworksEngineOptions extends FireworkEngineOptions {
+    onLaunch?: (payload: FireworkLaunchPayload) => void;
+}
+declare function useFireworksEngine(options?: UseFireworksEngineOptions): {
+    containerRef: React.RefObject<HTMLDivElement>;
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    launch: (payload: FireworkLaunchPayload) => void;
+    fps: number;
+};
+
+interface DanmakuOverlayItem extends DanmakuMessage {
+    track: number;
+    durationMs: number;
+}
+interface SendDanmakuOptions {
+    optimistic?: boolean;
+}
+declare function useDanmakuController(options?: DanmakuControllerOptions): {
+    items: DanmakuOverlayItem[];
+    send: (text: string, color?: string, sendOptions?: SendDanmakuOptions) => DanmakuSendResult | null;
+    addIncoming: (message: DanmakuMessage) => void;
+    removeItem: (id: string) => void;
+};
+
+interface UseFireworksRealtimeOptions {
+    config?: FireworksRealtimeConfig;
+    enabled?: boolean;
+    onDanmakuBroadcast?: (event: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+        userId: string;
+        timestamp: number;
+        id: string;
+    }) => void;
+    onFireworkBroadcast?: (payload: FireworkLaunchPayload) => void;
+    onError?: (error: Error) => void;
+    onStateChange?: (state: FireworksRealtimeState) => void;
+}
+declare function useFireworksRealtime(options: UseFireworksRealtimeOptions): {
+    state: FireworksRealtimeState;
+    sendDanmaku: (payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    }) => void;
+    sendFirework: (payload: FireworkLaunchPayload) => void;
+};
+
+declare const DEFAULT_MAX_PARTICLES = 5000;
+declare const DEFAULT_MAX_ACTIVE_FIREWORKS = 12;
+declare const FIREWORK_KIND_LABELS: Record<FireworkKind, string>;
+declare const MIKU_PALETTE: string[];
+declare const NORMAL_PALETTE: string[];
+declare const DANMAKU_MAX_LENGTH = 32;
+declare const DANMAKU_TRACK_COUNT = 8;
+
+export { DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DanmakuControllerOptions, DanmakuMessage, type DanmakuOverlayItem, DanmakuPanel, DanmakuSendResult, FIREWORK_KIND_LABELS, FireworkEngineOptions, FireworkKind, FireworkLaunchPayload, FireworksCanvas, FireworksControlPanel, FireworksRealtimeConfig, FireworksRealtimeState, FireworksRealtimeUser, MIKU_PALETTE, MikuFireworks3D, MikuFireworks3DProps, NORMAL_PALETTE, type UseFireworksEngineOptions, WebSocketTransport, type WebSocketTransportCallbacks, useDanmakuController, useFireworksEngine, useFireworksRealtime };

package/dist/mikuFireworks3D/index.d.ts

@@ -0,0 +1,174 @@
+import * as React from 'react';
+import React__default from 'react';
+import { M as MikuFireworks3DProps, F as FireworkKind, g as FireworksRealtimeConfig, h as FireworksRealtimeState, f as FireworksRealtimeUser, a as FireworkLaunchPayload, c as FireworkEngineOptions, D as DanmakuMessage, e as DanmakuControllerOptions, d as DanmakuSendResult } from '../types-Cgk9zWhO.js';
+export { b as FireworkPosition } from '../types-Cgk9zWhO.js';
+
+declare function MikuFireworks3D({ width, height, className, defaultKind, autoLaunchOnDanmaku, maxParticles, maxActiveFireworks, defaultAvatarUrl, onLaunch, onDanmakuSend, onError, onFpsReport, onRealtimeStateChange, realtime, }: MikuFireworks3DProps): React__default.JSX.Element;
+
+interface FireworksCanvasProps {
+    canvasRef: React__default.RefObject<HTMLCanvasElement>;
+}
+declare function FireworksCanvas({ canvasRef }: FireworksCanvasProps): React__default.JSX.Element;
+
+interface FireworksControlPanelProps {
+    selectedKind: FireworkKind;
+    onKindChange: (kind: FireworkKind) => void;
+    autoLaunchOnDanmaku: boolean;
+    onAutoLaunchChange: (value: boolean) => void;
+    avatarUrl: string;
+    onAvatarUrlChange: (value: string) => void;
+    onLaunch: () => void;
+    fps: number;
+    realtimeConnected?: boolean;
+    onlineCount?: number;
+}
+declare function FireworksControlPanel({ selectedKind, onKindChange, autoLaunchOnDanmaku, onAutoLaunchChange, avatarUrl, onAvatarUrlChange, onLaunch, fps, realtimeConnected, onlineCount, }: FireworksControlPanelProps): React__default.JSX.Element;
+
+interface DanmakuPanelProps {
+    onSend: (text: string) => void;
+}
+declare function DanmakuPanel({ onSend }: DanmakuPanelProps): React__default.JSX.Element;
+
+interface RealtimeDanmakuEvent {
+    id: string;
+    roomId: string;
+    text: string;
+    color?: string;
+    kind?: FireworkKind;
+    user: FireworksRealtimeUser;
+    timestamp: number;
+}
+interface RealtimeFireworkEvent {
+    id: string;
+    roomId: string;
+    payload: FireworkLaunchPayload;
+    user: FireworksRealtimeUser;
+    timestamp: number;
+}
+type ServerMessage = {
+    type: 'joined';
+    roomId: string;
+    onlineCount: number;
+    self: FireworksRealtimeUser;
+} | {
+    type: 'room.snapshot';
+    roomId: string;
+    users: FireworksRealtimeUser[];
+    danmakuHistory: RealtimeDanmakuEvent[];
+    fireworkHistory: RealtimeFireworkEvent[];
+} | {
+    type: 'room.user_joined';
+    roomId: string;
+    user: FireworksRealtimeUser;
+    onlineCount: number;
+} | {
+    type: 'room.user_left';
+    roomId: string;
+    userId: string;
+    onlineCount: number;
+} | {
+    type: 'danmaku.broadcast';
+    roomId: string;
+    event: RealtimeDanmakuEvent;
+} | {
+    type: 'firework.broadcast';
+    roomId: string;
+    event: RealtimeFireworkEvent;
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+} | {
+    type: 'pong';
+    ts: number;
+};
+interface WebSocketTransportCallbacks {
+    onStateChange?: (state: FireworksRealtimeState) => void;
+    onDanmakuBroadcast?: (event: RealtimeDanmakuEvent) => void;
+    onFireworkBroadcast?: (event: RealtimeFireworkEvent) => void;
+    onSnapshot?: (snapshot: Extract<ServerMessage, {
+        type: 'room.snapshot';
+    }>) => void;
+    onError?: (error: Error) => void;
+}
+declare class WebSocketTransport {
+    private socket;
+    private reconnectTimer;
+    private isManualClose;
+    private readonly config;
+    private readonly callbacks;
+    private state;
+    constructor(config: FireworksRealtimeConfig, callbacks?: WebSocketTransportCallbacks);
+    connect(): void;
+    disconnect(): void;
+    sendDanmaku(payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    }): void;
+    sendFirework(payload: FireworkLaunchPayload): void;
+    getState(): FireworksRealtimeState;
+    private send;
+    private updateState;
+    private handleServerMessage;
+    private scheduleReconnect;
+}
+
+interface UseFireworksEngineOptions extends FireworkEngineOptions {
+    onLaunch?: (payload: FireworkLaunchPayload) => void;
+}
+declare function useFireworksEngine(options?: UseFireworksEngineOptions): {
+    containerRef: React.RefObject<HTMLDivElement>;
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    launch: (payload: FireworkLaunchPayload) => void;
+    fps: number;
+};
+
+interface DanmakuOverlayItem extends DanmakuMessage {
+    track: number;
+    durationMs: number;
+}
+interface SendDanmakuOptions {
+    optimistic?: boolean;
+}
+declare function useDanmakuController(options?: DanmakuControllerOptions): {
+    items: DanmakuOverlayItem[];
+    send: (text: string, color?: string, sendOptions?: SendDanmakuOptions) => DanmakuSendResult | null;
+    addIncoming: (message: DanmakuMessage) => void;
+    removeItem: (id: string) => void;
+};
+
+interface UseFireworksRealtimeOptions {
+    config?: FireworksRealtimeConfig;
+    enabled?: boolean;
+    onDanmakuBroadcast?: (event: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+        userId: string;
+        timestamp: number;
+        id: string;
+    }) => void;
+    onFireworkBroadcast?: (payload: FireworkLaunchPayload) => void;
+    onError?: (error: Error) => void;
+    onStateChange?: (state: FireworksRealtimeState) => void;
+}
+declare function useFireworksRealtime(options: UseFireworksRealtimeOptions): {
+    state: FireworksRealtimeState;
+    sendDanmaku: (payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    }) => void;
+    sendFirework: (payload: FireworkLaunchPayload) => void;
+};
+
+declare const DEFAULT_MAX_PARTICLES = 5000;
+declare const DEFAULT_MAX_ACTIVE_FIREWORKS = 12;
+declare const FIREWORK_KIND_LABELS: Record<FireworkKind, string>;
+declare const MIKU_PALETTE: string[];
+declare const NORMAL_PALETTE: string[];
+declare const DANMAKU_MAX_LENGTH = 32;
+declare const DANMAKU_TRACK_COUNT = 8;
+
+export { DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DanmakuControllerOptions, DanmakuMessage, type DanmakuOverlayItem, DanmakuPanel, DanmakuSendResult, FIREWORK_KIND_LABELS, FireworkEngineOptions, FireworkKind, FireworkLaunchPayload, FireworksCanvas, FireworksControlPanel, FireworksRealtimeConfig, FireworksRealtimeState, FireworksRealtimeUser, MIKU_PALETTE, MikuFireworks3D, MikuFireworks3DProps, NORMAL_PALETTE, type UseFireworksEngineOptions, WebSocketTransport, type WebSocketTransportCallbacks, useDanmakuController, useFireworksEngine, useFireworksRealtime };

package/dist/mikuFireworks3D/index.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var chunkPMTY2AI4_js = require('../chunk-PMTY2AI4.js');
+require('../chunk-DGUM43GV.js');
+
+
+
+Object.defineProperty(exports, "DANMAKU_MAX_LENGTH", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.DANMAKU_MAX_LENGTH; }
+});
+Object.defineProperty(exports, "DANMAKU_TRACK_COUNT", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.DANMAKU_TRACK_COUNT; }
+});
+Object.defineProperty(exports, "DEFAULT_MAX_ACTIVE_FIREWORKS", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.DEFAULT_MAX_ACTIVE_FIREWORKS; }
+});
+Object.defineProperty(exports, "DEFAULT_MAX_PARTICLES", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.DEFAULT_MAX_PARTICLES; }
+});
+Object.defineProperty(exports, "DanmakuPanel", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.DanmakuPanel; }
+});
+Object.defineProperty(exports, "FIREWORK_KIND_LABELS", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.FIREWORK_KIND_LABELS; }
+});
+Object.defineProperty(exports, "FireworksCanvas", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.FireworksCanvas; }
+});
+Object.defineProperty(exports, "FireworksControlPanel", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.FireworksControlPanel; }
+});
+Object.defineProperty(exports, "MIKU_PALETTE", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.MIKU_PALETTE; }
+});
+Object.defineProperty(exports, "MikuFireworks3D", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.MikuFireworks3D; }
+});
+Object.defineProperty(exports, "NORMAL_PALETTE", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.NORMAL_PALETTE; }
+});
+Object.defineProperty(exports, "WebSocketTransport", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.WebSocketTransport; }
+});
+Object.defineProperty(exports, "useDanmakuController", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.useDanmakuController; }
+});
+Object.defineProperty(exports, "useFireworksEngine", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.useFireworksEngine; }
+});
+Object.defineProperty(exports, "useFireworksRealtime", {
+  enumerable: true,
+  get: function () { return chunkPMTY2AI4_js.useFireworksRealtime; }
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/mikuFireworks3D/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/mikuFireworks3D/index.mjs

@@ -0,0 +1,4 @@
+export { DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DanmakuPanel, FIREWORK_KIND_LABELS, FireworksCanvas, FireworksControlPanel, MIKU_PALETTE, MikuFireworks3D, NORMAL_PALETTE, WebSocketTransport, useDanmakuController, useFireworksEngine, useFireworksRealtime } from '../chunk-SR4JFEHW.mjs';
+import '../chunk-BJTO5JO5.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/mikuFireworks3D/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/mikuFireworks3D/server/index.d.mts

@@ -0,0 +1,146 @@
+import { F as FireworkKind, a as FireworkLaunchPayload } from '../../types-Cgk9zWhO.mjs';
+
+interface FireworksUserIdentity {
+    userId: string;
+    nickname?: string;
+    avatarUrl?: string;
+}
+interface DanmakuBroadcastEvent {
+    id: string;
+    roomId: string;
+    text: string;
+    color?: string;
+    kind?: FireworkKind;
+    user: FireworksUserIdentity;
+    timestamp: number;
+}
+interface FireworkBroadcastEvent {
+    id: string;
+    roomId: string;
+    payload: FireworkLaunchPayload;
+    user: FireworksUserIdentity;
+    timestamp: number;
+}
+type FireworksClientMessage = {
+    type: 'join';
+    roomId: string;
+    user: FireworksUserIdentity;
+} | {
+    type: 'leave';
+} | {
+    type: 'danmaku.send';
+    payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    };
+} | {
+    type: 'firework.launch';
+    payload: FireworkLaunchPayload;
+} | {
+    type: 'ping';
+    ts?: number;
+};
+type FireworksServerMessage = {
+    type: 'joined';
+    roomId: string;
+    self: FireworksUserIdentity;
+    onlineCount: number;
+} | {
+    type: 'room.snapshot';
+    roomId: string;
+    users: FireworksUserIdentity[];
+    danmakuHistory: DanmakuBroadcastEvent[];
+    fireworkHistory: FireworkBroadcastEvent[];
+} | {
+    type: 'room.user_joined';
+    roomId: string;
+    user: FireworksUserIdentity;
+    onlineCount: number;
+} | {
+    type: 'room.user_left';
+    roomId: string;
+    userId: string;
+    onlineCount: number;
+} | {
+    type: 'danmaku.broadcast';
+    roomId: string;
+    event: DanmakuBroadcastEvent;
+} | {
+    type: 'firework.broadcast';
+    roomId: string;
+    event: FireworkBroadcastEvent;
+} | {
+    type: 'pong';
+    ts: number;
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+};
+interface FireworksConnectionTransport {
+    send: (encodedMessage: string) => void;
+    close?: (code?: number, reason?: string) => void;
+}
+interface FireworksConnection {
+    id: string;
+    handleMessage: (raw: unknown) => void;
+    disconnect: (reason?: string) => void;
+    send: (message: FireworksServerMessage) => void;
+}
+interface FireworksRoomHubOptions {
+    maxUsersPerRoom?: number;
+    historyLimit?: number;
+    maxDanmakuLength?: number;
+    logger?: Pick<Console, 'info' | 'warn' | 'error'>;
+}
+interface FireworksHubStats {
+    rooms: number;
+    connections: number;
+}
+interface WsLikeSocket {
+    send: (data: string) => void;
+    on: (event: 'message' | 'close' | 'error', listener: (...args: unknown[]) => void) => void;
+}
+
+declare class FireworksRoomHub {
+    private readonly rooms;
+    private readonly sessions;
+    private readonly maxUsersPerRoom;
+    private readonly historyLimit;
+    private readonly maxDanmakuLength;
+    private readonly logger?;
+    constructor(options?: FireworksRoomHubOptions);
+    connect(transport: FireworksConnectionTransport, id?: string): FireworksConnection;
+    disconnect(connectionId: string, reason?: string): void;
+    getStats(): {
+        rooms: number;
+        connections: number;
+    };
+    getRoomOnlineCount(roomId: string): number;
+    private handleRawMessage;
+    private joinRoom;
+    private leaveRoom;
+    private handleDanmaku;
+    private handleFirework;
+    private createRoom;
+    private sendToConnection;
+    private broadcastToRoom;
+    private sendError;
+}
+
+interface BindWsSocketOptions {
+    connectionId?: string;
+    onConnected?: (connection: FireworksConnection) => void;
+    onDisconnected?: (connectionId: string) => void;
+}
+/**
+ * Bind a ws-like socket to FireworksRoomHub.
+ *
+ * Example (ws package):
+ * const hub = new FireworksRoomHub();
+ * wss.on('connection', (socket) => bindWsSocket(hub, socket));
+ */
+declare function bindWsSocket(hub: FireworksRoomHub, socket: WsLikeSocket, options?: BindWsSocketOptions): FireworksConnection;
+
+export { type BindWsSocketOptions, type DanmakuBroadcastEvent, type FireworkBroadcastEvent, type FireworksClientMessage, type FireworksConnection, type FireworksConnectionTransport, type FireworksHubStats, FireworksRoomHub, type FireworksRoomHubOptions, type FireworksServerMessage, type FireworksUserIdentity, type WsLikeSocket, bindWsSocket };