@pmate/chat-sdk 0.1.1

package/lib/tokens/defaultTokens.js

@@ -0,0 +1,91 @@
+export const defaultChatInputTokens = {
+    color: {
+        brandPrimary: "#6D4AFF",
+        surfaceInputDefault: "#FFFFFF",
+        surfaceInputFocus: "#F7F4FF",
+        surfaceInputRecording: "#EEE7FF",
+        surfaceInputError: "#FFF1F3",
+        textPrimary: "#1F1637",
+        textSecondary: "#6F6790",
+        iconDefault: "#6F6790",
+        iconActive: "#6D4AFF",
+        actionSendDefault: "#6D4AFF",
+        actionSendDisabled: "#CFC6F6",
+        actionSendTextOnPrimary: "#FFFFFF",
+        borderDefault: "#E6E0F7",
+        borderFocus: "#B9A8FF",
+        borderError: "#F2A7B5",
+        statusError: "#D14363",
+        statusWarning: "#D98E04",
+        statusSuccess: "#2E9B62",
+        voiceWaveformActive: "#7C5CFF",
+        voiceWaveformBackground: "#DCD2FF",
+    },
+    spacing: {
+        inputOuter: 12,
+        inputInner: 10,
+        actionGap: 8,
+        attachmentGap: 8,
+        voiceWaveformGap: 4,
+        mobileTouchInset: 12,
+        desktopToolbarGap: 10,
+        statusHintTop: 6,
+    },
+    radius: {
+        inputSurface: 20,
+        actionButton: 16,
+        attachmentPreview: 14,
+        waveformBar: 999,
+        mobileHoldToTalk: 18,
+        desktopInputSurface: 16,
+    },
+    motion: {
+        pressFeedback: "120ms ease-out",
+        waveformPulse: "180ms ease-out",
+        stateTransition: "180ms ease",
+        transcribingLoading: "900ms linear infinite",
+    },
+    shadow: {
+        inputElevated: "0 6px 24px rgba(95, 70, 180, 0.08)",
+        recordingActive: "0 0 0 4px rgba(109, 74, 255, 0.14)",
+    },
+    typography: {
+        familyBase: '"SF Pro Text", "PingFang SC", "Helvetica Neue", sans-serif',
+        familyMono: '"SF Mono", "JetBrains Mono", monospace',
+        inputText: { size: 15, lineHeight: 22, weight: 400 },
+        statusHint: { size: 12, lineHeight: 16, weight: 500 },
+        actionLabel: { size: 13, lineHeight: 18, weight: 600 },
+        voiceHoldToTalk: { size: 14, lineHeight: 20, weight: 600 },
+    },
+};
+export function mergeChatInputTokens(overrides) {
+    return {
+        ...defaultChatInputTokens,
+        ...overrides,
+        color: { ...defaultChatInputTokens.color, ...overrides?.color },
+        spacing: { ...defaultChatInputTokens.spacing, ...overrides?.spacing },
+        radius: { ...defaultChatInputTokens.radius, ...overrides?.radius },
+        motion: { ...defaultChatInputTokens.motion, ...overrides?.motion },
+        shadow: { ...defaultChatInputTokens.shadow, ...overrides?.shadow },
+        typography: {
+            ...defaultChatInputTokens.typography,
+            ...overrides?.typography,
+            inputText: {
+                ...defaultChatInputTokens.typography.inputText,
+                ...overrides?.typography?.inputText,
+            },
+            statusHint: {
+                ...defaultChatInputTokens.typography.statusHint,
+                ...overrides?.typography?.statusHint,
+            },
+            actionLabel: {
+                ...defaultChatInputTokens.typography.actionLabel,
+                ...overrides?.typography?.actionLabel,
+            },
+            voiceHoldToTalk: {
+                ...defaultChatInputTokens.typography.voiceHoldToTalk,
+                ...overrides?.typography?.voiceHoldToTalk,
+            },
+        },
+    };
+}

package/lib/types/attachment.d.ts

@@ -0,0 +1,8 @@
+export type ChatAttachment = {
+    id: string;
+    name: string;
+    kind: "image";
+    file?: File;
+    url?: string;
+    previewUrl?: string;
+};

package/lib/types/attachment.js

@@ -0,0 +1 @@
+export {};

package/lib/types/chatInput.d.ts

@@ -0,0 +1,139 @@
+import type { ComponentType, ReactNode } from "react";
+import type { ChatAttachment } from "./attachment";
+import type { ChatVoiceConfig } from "./voice";
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends (...args: never[]) => unknown ? T[K] : T[K] extends Array<infer U> ? Array<DeepPartial<U>> : T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+export type ChatInputMode = "text" | "voice";
+export type ChatInputStatus = "idle" | "typing" | "voice-mode-ready" | "recording" | "transcribing" | "transcript-ready" | "attachment-selected" | "sending" | "error";
+export type ChatInputColorTokens = {
+    brandPrimary: string;
+    surfaceInputDefault: string;
+    surfaceInputFocus: string;
+    surfaceInputRecording: string;
+    surfaceInputError: string;
+    textPrimary: string;
+    textSecondary: string;
+    iconDefault: string;
+    iconActive: string;
+    actionSendDefault: string;
+    actionSendDisabled: string;
+    actionSendTextOnPrimary: string;
+    borderDefault: string;
+    borderFocus: string;
+    borderError: string;
+    statusError: string;
+    statusWarning: string;
+    statusSuccess: string;
+    voiceWaveformActive: string;
+    voiceWaveformBackground: string;
+};
+export type ChatInputSpacingTokens = {
+    inputOuter: number;
+    inputInner: number;
+    actionGap: number;
+    attachmentGap: number;
+    voiceWaveformGap: number;
+    mobileTouchInset: number;
+    desktopToolbarGap: number;
+    statusHintTop: number;
+};
+export type ChatInputRadiusTokens = {
+    inputSurface: number;
+    actionButton: number;
+    attachmentPreview: number;
+    waveformBar: number;
+    mobileHoldToTalk: number;
+    desktopInputSurface: number;
+};
+export type ChatInputMotionTokens = {
+    pressFeedback: string;
+    waveformPulse: string;
+    stateTransition: string;
+    transcribingLoading: string;
+};
+export type ChatInputShadowTokens = {
+    inputElevated: string;
+    recordingActive: string;
+};
+export type ChatInputTypographyScale = {
+    size: number;
+    lineHeight: number;
+    weight: number;
+};
+export type ChatInputTypographyTokens = {
+    familyBase: string;
+    familyMono: string;
+    inputText: ChatInputTypographyScale;
+    statusHint: ChatInputTypographyScale;
+    actionLabel: ChatInputTypographyScale;
+    voiceHoldToTalk: ChatInputTypographyScale;
+};
+export type ChatInputTokens = {
+    color: ChatInputColorTokens;
+    spacing: ChatInputSpacingTokens;
+    radius: ChatInputRadiusTokens;
+    motion: ChatInputMotionTokens;
+    shadow: ChatInputShadowTokens;
+    typography: ChatInputTypographyTokens;
+};
+export type ChatInputSlotProps = {
+    status: ChatInputStatus;
+    mode: ChatInputMode;
+    disabled?: boolean;
+};
+export type ChatInputSlots = {
+    sendAction: ComponentType<ChatInputSlotProps>;
+    statusHint: ComponentType<ChatInputSlotProps & {
+        text?: string;
+    }>;
+    recordingFeedback: ComponentType<ChatInputSlotProps & {
+        children?: ReactNode;
+    }>;
+};
+export type ChatInputInitialState = {
+    mode?: ChatInputMode;
+    status?: ChatInputStatus;
+    text?: string;
+    transcript?: string;
+    error?: string;
+    attachments?: ChatAttachment[];
+    waveformLevels?: number[];
+};
+export type ChatImageUploadResult = {
+    name?: string;
+    url: string;
+    previewUrl?: string;
+};
+export type ChatImageConfig = {
+    accept?: string;
+    uploadImage?: (file: File) => Promise<ChatImageUploadResult>;
+};
+export type ChatInputBaseProps = {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSend?: (payload: {
+        text: string;
+        attachments: ChatAttachment[];
+        transcript?: string;
+        audio?: Blob;
+        mode?: "text" | "voice";
+    }) => Promise<void> | void;
+    enableVoice?: boolean;
+    enableEmoji?: boolean;
+    enableImage?: boolean;
+    disabled?: boolean;
+    authToken?: string;
+    tokens?: DeepPartial<ChatInputTokens>;
+    slots?: Partial<ChatInputSlots>;
+    initialState?: ChatInputInitialState;
+    voice?: ChatVoiceConfig;
+    image?: ChatImageConfig;
+};
+export type ChatInputMobileProps = ChatInputBaseProps & {
+    voiceModeDefault?: ChatInputMode;
+};
+export type ChatInputDesktopProps = ChatInputBaseProps & {
+    submitShortcut?: "enter" | "meta-enter";
+};

package/lib/types/chatInput.js

@@ -0,0 +1 @@
+export {};

package/lib/types/voice.d.ts

@@ -0,0 +1,17 @@
+export type ChatVoiceStatus = "idle" | "voice-mode-ready" | "recording" | "transcribing" | "transcript-ready" | "error";
+export type WaveformLevel = number;
+export type ChatASRClient = {
+    transcribe(blob: Blob, input?: {
+        lang?: string;
+    }): Promise<{
+        text: string;
+    }>;
+};
+export type ChatVoiceConfig = {
+    asrClient?: ChatASRClient;
+    lang?: string;
+    minDurationMs?: number;
+    simulatedTranscript?: string;
+    shortRecordingMessage?: string;
+    onVoiceSend?: (blob: Blob) => Promise<void> | void;
+};

package/lib/types/voice.js

@@ -0,0 +1 @@
+export {};

package/lib/voice/MicStateManager.d.ts

@@ -0,0 +1,43 @@
+export declare enum MicState {
+    Idle = 0,
+    Initializing = 1,
+    Recording = 2
+}
+export declare enum MicEvents {
+    StateChanged = "stateChanged",
+    Data = "data",
+    Level = "level",
+    Finished = "finished",
+    Abort = "abort",
+    Error = "error"
+}
+type MicEventMap = {
+    [MicEvents.StateChanged]: (payload: {
+        state: MicState;
+    }) => void;
+    [MicEvents.Data]: (data: Blob) => void;
+    [MicEvents.Level]: (levels: number[]) => void;
+    [MicEvents.Finished]: (data: Blob) => void;
+    [MicEvents.Abort]: () => void;
+    [MicEvents.Error]: (error: Error) => void;
+};
+export declare class MicStateManager {
+    private recorder;
+    private state;
+    private chunks;
+    private stream;
+    private listeners;
+    private initialized;
+    on<K extends MicEvents>(event: K, handler: MicEventMap[K]): () => void;
+    private emit;
+    init(): void;
+    start(): Promise<void>;
+    stop(): void;
+    abort(): void;
+    dispose(): void;
+    private reset;
+    private pauseStream;
+    private releaseStream;
+    private setState;
+}
+export {};

package/lib/voice/MicStateManager.js

@@ -0,0 +1,155 @@
+import { Recorder, RecorderEvents } from "./Recorder";
+export var MicState;
+(function (MicState) {
+    MicState[MicState["Idle"] = 0] = "Idle";
+    MicState[MicState["Initializing"] = 1] = "Initializing";
+    MicState[MicState["Recording"] = 2] = "Recording";
+})(MicState || (MicState = {}));
+export var MicEvents;
+(function (MicEvents) {
+    MicEvents["StateChanged"] = "stateChanged";
+    MicEvents["Data"] = "data";
+    MicEvents["Level"] = "level";
+    MicEvents["Finished"] = "finished";
+    MicEvents["Abort"] = "abort";
+    MicEvents["Error"] = "error";
+})(MicEvents || (MicEvents = {}));
+export class MicStateManager {
+    recorder = new Recorder();
+    state = MicState.Idle;
+    chunks = [];
+    stream;
+    listeners = {
+        [MicEvents.StateChanged]: new Set(),
+        [MicEvents.Data]: new Set(),
+        [MicEvents.Level]: new Set(),
+        [MicEvents.Finished]: new Set(),
+        [MicEvents.Abort]: new Set(),
+        [MicEvents.Error]: new Set(),
+    };
+    initialized = false;
+    on(event, handler) {
+        this.listeners[event].add(handler);
+        return () => {
+            this.listeners[event].delete(handler);
+        };
+    }
+    emit(event, ...args) {
+        for (const handler of this.listeners[event]) {
+            ;
+            handler(...args);
+        }
+    }
+    init() {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        this.recorder.on(RecorderEvents.Data, (data) => {
+            this.chunks.push(data);
+            this.emit(MicEvents.Data, data);
+        });
+        this.recorder.on(RecorderEvents.Level, (levels) => {
+            this.emit(MicEvents.Level, levels);
+        });
+        this.recorder.on(RecorderEvents.Stop, () => {
+            const blob = new Blob(this.chunks, { type: "audio/pcm;rate=16000" });
+            if (blob.size < 1024 * 8) {
+                this.abort();
+                return;
+            }
+            this.emit(MicEvents.Finished, blob);
+            this.reset();
+        });
+        this.recorder.on(RecorderEvents.Error, (error) => {
+            this.abort();
+            this.emit(MicEvents.Error, error);
+        });
+    }
+    async start() {
+        if (this.state === MicState.Initializing || this.state === MicState.Recording) {
+            return;
+        }
+        this.setState(MicState.Initializing);
+        try {
+            if (!navigator.mediaDevices?.getUserMedia) {
+                throw new Error("Microphone access is not available in this browser.");
+            }
+            this.releaseStream();
+            this.stream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    echoCancellation: true,
+                    noiseSuppression: true,
+                    autoGainControl: true,
+                },
+            });
+            await this.recorder.init(this.stream);
+            this.stream.getTracks().forEach((track) => {
+                track.enabled = true;
+            });
+            await this.recorder.startRecording();
+            this.setState(MicState.Recording);
+        }
+        catch (error) {
+            this.reset();
+            this.emit(MicEvents.Error, toError(error));
+        }
+    }
+    stop() {
+        if (this.state !== MicState.Initializing && this.state !== MicState.Recording) {
+            return;
+        }
+        if (this.state === MicState.Initializing) {
+            this.abort();
+            return;
+        }
+        this.recorder.stopRecording();
+        this.recorder.detachStream();
+        this.pauseStream();
+        this.setState(MicState.Idle);
+    }
+    abort() {
+        if (this.state === MicState.Idle) {
+            return;
+        }
+        this.recorder.stopRecording();
+        this.recorder.detachStream();
+        this.pauseStream();
+        this.emit(MicEvents.Abort);
+        this.reset();
+    }
+    dispose() {
+        this.recorder.stopRecording();
+        this.releaseStream();
+        this.recorder.dispose();
+        this.reset();
+    }
+    reset() {
+        this.chunks = [];
+        this.setState(MicState.Idle);
+    }
+    pauseStream() {
+        this.stream?.getTracks().forEach((track) => {
+            track.enabled = false;
+        });
+    }
+    releaseStream() {
+        this.recorder.detachStream();
+        this.stream?.getTracks().forEach((track) => {
+            try {
+                track.stop();
+            }
+            catch {
+                // ignore track shutdown failures during teardown
+            }
+        });
+        this.stream = undefined;
+    }
+    setState(state) {
+        this.state = state;
+        this.emit(MicEvents.StateChanged, { state });
+    }
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}

package/lib/voice/Recorder.d.ts

@@ -0,0 +1,44 @@
+export declare enum RecorderEvents {
+    Start = "start",
+    Stop = "stop",
+    Data = "data",
+    Level = "level",
+    Error = "error"
+}
+type RecorderHandlerMap = {
+    [RecorderEvents.Start]: () => void;
+    [RecorderEvents.Stop]: () => void;
+    [RecorderEvents.Data]: (data: Blob) => void;
+    [RecorderEvents.Level]: (levels: number[]) => void;
+    [RecorderEvents.Error]: (error: Error) => void;
+};
+export declare class Recorder {
+    private audioContext?;
+    private mediaStream?;
+    private mediaStreamSource?;
+    private analyserNode?;
+    private recorderProcessorNode?;
+    private silentGainNode?;
+    private meterFrameId?;
+    private isRecording;
+    private setupPromise;
+    private listeners;
+    initialized: boolean;
+    on<K extends RecorderEvents>(event: K, handler: RecorderHandlerMap[K]): () => void;
+    private emit;
+    clearListeners(): void;
+    init(stream: MediaStream): Promise<void>;
+    ensureAudioGraph(): Promise<void>;
+    private setupAudioGraph;
+    private attachStream;
+    detachStream(options?: {
+        stopTracks?: boolean;
+    }): void;
+    startRecording(): Promise<void>;
+    stopRecording(): void;
+    dispose(): void;
+    get isRecordingStatus(): boolean;
+    private startMetering;
+    private stopMetering;
+}
+export {};