@sorisdk/web-audio 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,241 @@
+import { MatcherEphemeralAuthOptions, InitMatcherOptions, MatcherEphemeralAuthResult, PackSource, MatchResult, AudioFingerprintType } from '@sorisdk/matcher';
+export { AudioFingerprintType, PackSource } from '@sorisdk/matcher';
+import { InitAfpgenOptions } from '@sorisdk/afpgen';
+
+declare const DEFAULT_BROWSER_AUDIOPACK_VERSION = "20220401000000";
+interface BrowserAudioPackState {
+    version: string;
+    packUrl: string;
+}
+interface BrowserAudioPackStateStore {
+    load(): BrowserAudioPackState | null | Promise<BrowserAudioPackState | null>;
+    save(state: BrowserAudioPackState): void | Promise<void>;
+    clear?(): void | Promise<void>;
+}
+interface BrowserAudioPackLoader {
+    loadPack(source: string | URL): Promise<void>;
+}
+interface CreateLocalStorageAudioPackStoreOptions {
+    key: string;
+    storage?: Storage;
+}
+interface AuthenticateAndLoadAudioPackOptions {
+    loader: BrowserAudioPackLoader;
+    auth: Omit<MatcherEphemeralAuthOptions, "version">;
+    store: BrowserAudioPackStateStore;
+    initialVersion?: string;
+    matcherInit?: Omit<InitMatcherOptions, "auth">;
+}
+interface AuthenticateAndLoadAudioPackResult extends MatcherEphemeralAuthResult {
+    requestedVersion: string;
+    loadedPackUrl: string;
+    persistedVersion: string;
+    source: "cache" | "network";
+    cachedState: BrowserAudioPackState | null;
+}
+declare function createLocalStorageAudioPackStore(options: CreateLocalStorageAudioPackStoreOptions): BrowserAudioPackStateStore;
+declare function authenticateAndLoadAudioPack(options: AuthenticateAndLoadAudioPackOptions): Promise<AuthenticateAndLoadAudioPackResult>;
+
+interface BrowserSessionManager {
+    getSessionId(): string;
+    clear?(): void | Promise<void>;
+}
+interface CreateLocalStorageSessionManagerOptions {
+    key: string;
+    storage?: Storage;
+    generateSessionId?: () => string;
+}
+declare function createLocalStorageSessionManager(options: CreateLocalStorageSessionManagerOptions): BrowserSessionManager;
+
+interface InitMatchWindowWasmOptions {
+    loader?: () => Promise<unknown>;
+    wasmInitInput?: unknown;
+}
+
+type DetectedMatch = Pick<MatchResult, "afpType" | "name" | "position" | "score">;
+interface MaterialActivityRequestPayload {
+    type: "material";
+    material_id: string;
+    metadata?: unknown;
+}
+interface MicrophoneMatcherCampaignEvent {
+    match: DetectedMatch;
+    campaign: Record<string, unknown>;
+    activityId: string | null;
+    raw: Record<string, unknown>;
+}
+interface MicrophoneMatcherActivityReporterOptions {
+    endpoint: string | URL;
+    token: string | (() => string | Promise<string>);
+    fetch?: typeof fetch;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    mapMatchToRequest?: (match: DetectedMatch) => MaterialActivityRequestPayload | null | Promise<MaterialActivityRequestPayload | null>;
+    mapResponseToCampaign?: (response: Record<string, unknown>, match: DetectedMatch) => MicrophoneMatcherCampaignEvent | null | Promise<MicrophoneMatcherCampaignEvent | null>;
+}
+interface CreateMicrophoneMatcherWasmOptions {
+    afpgen?: InitAfpgenOptions;
+    matcher?: Omit<InitMatcherOptions, "auth">;
+    matchWindow?: InitMatchWindowWasmOptions;
+}
+interface CreateMicrophoneMatcherOptions {
+    packSource?: PackSource;
+    mediaConstraints?: MediaStreamConstraints;
+    stopTracksOnStop?: boolean;
+    suspendContextOnStop?: boolean;
+    activityReporter?: MicrophoneMatcherActivityReporterOptions;
+    wasm?: CreateMicrophoneMatcherWasmOptions;
+}
+interface MicrophoneMatcherEventMap extends Record<string, unknown> {
+    ready: {
+        sampleRate: number;
+    };
+    microphoneready: {
+        stream: MediaStream;
+        trackCount: number;
+    };
+    start: {};
+    match: {
+        best: DetectedMatch;
+    };
+    campaign: MicrophoneMatcherCampaignEvent;
+    nomatch: {};
+    stop: {};
+    destroy: {};
+    error: {
+        phase: string;
+        error: Error;
+    };
+}
+type MicrophoneMatcherEventName = keyof MicrophoneMatcherEventMap;
+type MicrophoneMatcherListener<T extends MicrophoneMatcherEventName> = (payload: MicrophoneMatcherEventMap[T]) => void;
+
+type Awaitable<T> = T | Promise<T>;
+type AudioRecognizerMatcherOptions = Omit<CreateMicrophoneMatcherOptions, "activityReporter" | "packSource">;
+declare const DEFAULT_SORI_API_ENDPOINT = "https://console.soriapi.com/api";
+interface AudioRecognizerAuthOptions {
+    endpoint: string | URL;
+    appId: string;
+    fetch?: typeof fetch;
+    ephemeralKey?: string | (() => Awaitable<string>);
+    ephemeralKeyEndpoint?: string | URL;
+    ephemeralKeyFetch?: typeof fetch;
+    ephemeralKeyRequestInit?: RequestInit | (() => Awaitable<RequestInit | undefined>);
+}
+interface AudioRecognizerOptions extends AudioRecognizerMatcherOptions {
+    appId?: string;
+    apiEndpoint?: string | URL;
+    authEndpoint?: string | URL;
+    activityEndpoint?: string | URL;
+    fetch?: typeof fetch;
+    ephemeralKey?: string | (() => Awaitable<string>);
+    ephemeraKey?: string | (() => Awaitable<string>);
+    ephemeralKeyEndpoint?: string | URL;
+    ephemeralKeyFetch?: typeof fetch;
+    ephemeralKeyRequestInit?: RequestInit | (() => Awaitable<RequestInit | undefined>);
+    auth?: AudioRecognizerAuthOptions;
+    activityReporter?: false | (Omit<MicrophoneMatcherActivityReporterOptions, "endpoint" | "token"> & {
+        endpoint?: string | URL;
+    });
+    initialVersion?: string;
+    packStore?: BrowserAudioPackStateStore;
+    packStorageKey?: string;
+    sessionManager?: BrowserSessionManager;
+    sessionStorageKey?: string;
+}
+declare class AudioRecognizer {
+    private readonly events;
+    private readonly options;
+    private readonly packStore;
+    private readonly sessionManager;
+    private matcher;
+    private matcherPromise;
+    private activityToken;
+    private running;
+    private destroyed;
+    constructor(options: AudioRecognizerOptions);
+    on<T extends MicrophoneMatcherEventName>(eventName: T, listener: MicrophoneMatcherListener<T>): this;
+    off<T extends MicrophoneMatcherEventName>(eventName: T, listener: MicrophoneMatcherListener<T>): this;
+    once<T extends MicrophoneMatcherEventName>(eventName: T, listener: MicrophoneMatcherListener<T>): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): Promise<void>;
+    getDiagnostics(): Readonly<{
+        sampleCallbacks: number;
+        inputSamples: number;
+        normalizedSamples: number;
+        processedChunks: number;
+        fingerprints: number;
+        readyQueries: number;
+        matchRequests: number;
+    }> | null;
+    private ensureMatcher;
+    private bindMatcherEvents;
+    private ensureNotDestroyed;
+    private setAuthResult;
+}
+
+declare class MicrophoneMatcher {
+    private readonly events;
+    private readonly matcherSession;
+    private readonly mediaDevices;
+    private readonly audioContext;
+    private readonly stopTracksOnStop;
+    private readonly suspendContextOnStop;
+    private readonly audioGraphFactory;
+    private readonly packSource;
+    private readonly options;
+    private extractor;
+    private graphController;
+    private matchWindow;
+    private stream;
+    private running;
+    private destroyed;
+    private loadedPack;
+    private matchInFlight;
+    private pendingMatch;
+    private captureGeneration;
+    private pcmBuffer;
+    private resampleBuffer;
+    private resampleOffset;
+    private hopSize;
+    private diagnostics;
+    constructor(options: CreateMicrophoneMatcherOptions);
+    on<T extends MicrophoneMatcherEventName>(eventName: T, listener: MicrophoneMatcherListener<T>): this;
+    off<T extends MicrophoneMatcherEventName>(eventName: T, listener: MicrophoneMatcherListener<T>): this;
+    once<T extends MicrophoneMatcherEventName>(eventName: T, listener: MicrophoneMatcherListener<T>): this;
+    prepare(): Promise<void>;
+    loadPack(): Promise<void>;
+    loadPack(source: NonNullable<CreateMicrophoneMatcherOptions["packSource"]>): Promise<void>;
+    private prepareInternal;
+    addEntry(name: string, fingerprint: Uint8Array, afpType?: AudioFingerprintType): Promise<void>;
+    addOrReplace(name: string, fingerprint: Uint8Array, afpType?: AudioFingerprintType): Promise<void>;
+    clear(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): Promise<void>;
+    getDiagnostics(): Readonly<{
+        sampleCallbacks: number;
+        inputSamples: number;
+        normalizedSamples: number;
+        processedChunks: number;
+        fingerprints: number;
+        readyQueries: number;
+        matchRequests: number;
+    }>;
+    private handleAudioSamples;
+    private queueMatch;
+    private runMatchLoop;
+    private resetCaptureState;
+    private normalizeInputSamples;
+    private resampleToTargetRate;
+    private cleanupAfterStartFailure;
+    private resetDiagnostics;
+    private ensureNotDestroyed;
+    private matchWindowOrThrow;
+    private reportCampaign;
+}
+declare function createMicrophoneMatcher(options?: CreateMicrophoneMatcherOptions): Promise<MicrophoneMatcher>;
+
+declare function requestMicrophoneStream(mediaDevices: MediaDevices, mediaConstraints?: MediaStreamConstraints): Promise<MediaStream>;
+
+export { AudioRecognizer, type AudioRecognizerAuthOptions, type AudioRecognizerOptions, type AuthenticateAndLoadAudioPackOptions, type AuthenticateAndLoadAudioPackResult, type BrowserAudioPackLoader, type BrowserAudioPackState, type BrowserAudioPackStateStore, type BrowserSessionManager, type CreateLocalStorageAudioPackStoreOptions, type CreateLocalStorageSessionManagerOptions, type CreateMicrophoneMatcherOptions, type CreateMicrophoneMatcherWasmOptions, DEFAULT_BROWSER_AUDIOPACK_VERSION, DEFAULT_SORI_API_ENDPOINT, type DetectedMatch, type MaterialActivityRequestPayload, MicrophoneMatcher, type MicrophoneMatcherActivityReporterOptions, type MicrophoneMatcherCampaignEvent, type MicrophoneMatcherEventMap, type MicrophoneMatcherEventName, type MicrophoneMatcherListener, authenticateAndLoadAudioPack, createLocalStorageAudioPackStore, createLocalStorageSessionManager, createMicrophoneMatcher, requestMicrophoneStream };