Class RecognizerWebSocket

mimeTypes

• get mimeTypes(): string[]

  Returns string[]

constructor

• new RecognizerWebSocket(
      config: {
          recognition?: {
              export?: {
                  image?: {
                      guides?: boolean;
                      viewport?: { height?: number; width?: number; x?: number; y?: number };
                  };
                  "image-resolution"?: number;
                  jiix?: {
                      "bounding-box"?: boolean;
                      "full-stroke-ids"?: boolean;
                      ids?: boolean;
                      strokes?: boolean;
                      style?: boolean;
                      text?: { chars?: boolean; lines?: boolean; words?: boolean };
                  };
                  mathml?: { flavor?: { name?: string } };
              };
              gesture?: { enable?: boolean; ignoreGestureStrokes?: boolean };
              lang?: string;
              "raw-content"?: {
                  classification?: { types?: ("shape" | "text" | undefined)[] };
                  gestures?: (
                      | "join"
                      | "surround"
                      | "underline"
                      | "insert"
                      | "scratch-out"
                      | "strike-through"
                      | undefined
                  )[];
                  recognition?: { types?: ("shape" | "text" | undefined)[] };
                  "session-time"?: number;
                  text?: {
                      addLKText?: boolean;
                      customLexicon?: (string | undefined)[];
                      customResources?: (string | undefined)[];
                  };
              };
          };
          server?: {
              applicationKey?: string;
              hmacKey?: string
              | {};
              host?: string;
              scheme?: TScheme;
              version?: string;
              websocket?: {
                  autoReconnect?: boolean;
                  fileChunkSize?: number;
                  maxPingLostCount?: number;
                  maxRetryCount?: number;
                  pingDelay?: number;
                  pingEnabled?: boolean;
              };
          };
      },
      event?: RecognizerEvent,
  ): RecognizerWebSocket

  Parameters

  • config: {
        recognition?: {
            export?: {
                image?: {
                    guides?: boolean;
                    viewport?: { height?: number; width?: number; x?: number; y?: number };
                };
                "image-resolution"?: number;
                jiix?: {
                    "bounding-box"?: boolean;
                    "full-stroke-ids"?: boolean;
                    ids?: boolean;
                    strokes?: boolean;
                    style?: boolean;
                    text?: { chars?: boolean; lines?: boolean; words?: boolean };
                };
                mathml?: { flavor?: { name?: string } };
            };
            gesture?: { enable?: boolean; ignoreGestureStrokes?: boolean };
            lang?: string;
            "raw-content"?: {
                classification?: { types?: ("shape" | "text" | undefined)[] };
                gestures?: (
                    | "join"
                    | "surround"
                    | "underline"
                    | "insert"
                    | "scratch-out"
                    | "strike-through"
                    | undefined
                )[];
                recognition?: { types?: ("shape" | "text" | undefined)[] };
                "session-time"?: number;
                text?: {
                    addLKText?: boolean;
                    customLexicon?: (string | undefined)[];
                    customResources?: (string | undefined)[];
                };
            };
        };
        server?: {
            applicationKey?: string;
            hmacKey?: string
            | {};
            host?: string;
            scheme?: TScheme;
            version?: string;
            websocket?: {
                autoReconnect?: boolean;
                fileChunkSize?: number;
                maxPingLostCount?: number;
                maxRetryCount?: number;
                pingDelay?: number;
                pingEnabled?: boolean;
            };
        };
    }
  • Optionalevent: RecognizerEvent

  Returns RecognizerWebSocket

addStrokes

• addStrokes(
      strokes: IIStroke[],
      processGestures?: boolean,
  ): Promise<TRecognizerWebSocketMessageGesture | undefined>

  Parameters

  • strokes: IIStroke[]
  • processGestures: boolean = true

  Returns Promise<TRecognizerWebSocketMessageGesture | undefined>

clear

• clear(): Promise<void>

  Returns Promise<void>

close

• close(code: number, reason: string): Promise<void>

  Parameters

  • code: number
  • reason: string

  Returns Promise<void>

destroy

• destroy(): Promise<void>

  Returns Promise<void>

eraseStrokes

• eraseStrokes(strokeIds: string[]): Promise<void>

  Parameters

  • strokeIds: string[]

  Returns Promise<void>

export

• export(requestedMimeTypes?: string[]): Promise<TExport>

  Parameters

  • OptionalrequestedMimeTypes: string[]

  Returns Promise<TExport>

init

• init(): Promise<void>

  Returns Promise<void>

newSession

• newSession(
      config: {
          recognition?: {
              export?: {
                  image?: {
                      guides?: boolean;
                      viewport?: { height?: number; width?: number; x?: number; y?: number };
                  };
                  "image-resolution"?: number;
                  jiix?: {
                      "bounding-box"?: boolean;
                      "full-stroke-ids"?: boolean;
                      ids?: boolean;
                      strokes?: boolean;
                      style?: boolean;
                      text?: { chars?: boolean; lines?: boolean; words?: boolean };
                  };
                  mathml?: { flavor?: { name?: string } };
              };
              gesture?: { enable?: boolean; ignoreGestureStrokes?: boolean };
              lang?: string;
              "raw-content"?: {
                  classification?: { types?: ("shape" | "text" | undefined)[] };
                  gestures?: (
                      | "join"
                      | "surround"
                      | "underline"
                      | "insert"
                      | "scratch-out"
                      | "strike-through"
                      | undefined
                  )[];
                  recognition?: { types?: ("shape" | "text" | undefined)[] };
                  "session-time"?: number;
                  text?: {
                      addLKText?: boolean;
                      customLexicon?: (string | undefined)[];
                      customResources?: (string | undefined)[];
                  };
              };
          };
          server?: {
              applicationKey?: string;
              hmacKey?: string
              | {};
              host?: string;
              scheme?: TScheme;
              version?: string;
              websocket?: {
                  autoReconnect?: boolean;
                  fileChunkSize?: number;
                  maxPingLostCount?: number;
                  maxRetryCount?: number;
                  pingDelay?: number;
                  pingEnabled?: boolean;
              };
          };
      },
  ): Promise<void>

  Parameters

  • config: {
        recognition?: {
            export?: {
                image?: {
                    guides?: boolean;
                    viewport?: { height?: number; width?: number; x?: number; y?: number };
                };
                "image-resolution"?: number;
                jiix?: {
                    "bounding-box"?: boolean;
                    "full-stroke-ids"?: boolean;
                    ids?: boolean;
                    strokes?: boolean;
                    style?: boolean;
                    text?: { chars?: boolean; lines?: boolean; words?: boolean };
                };
                mathml?: { flavor?: { name?: string } };
            };
            gesture?: { enable?: boolean; ignoreGestureStrokes?: boolean };
            lang?: string;
            "raw-content"?: {
                classification?: { types?: ("shape" | "text" | undefined)[] };
                gestures?: (
                    | "join"
                    | "surround"
                    | "underline"
                    | "insert"
                    | "scratch-out"
                    | "strike-through"
                    | undefined
                )[];
                recognition?: { types?: ("shape" | "text" | undefined)[] };
                "session-time"?: number;
                text?: {
                    addLKText?: boolean;
                    customLexicon?: (string | undefined)[];
                    customResources?: (string | undefined)[];
                };
            };
        };
        server?: {
            applicationKey?: string;
            hmacKey?: string
            | {};
            host?: string;
            scheme?: TScheme;
            version?: string;
            websocket?: {
                autoReconnect?: boolean;
                fileChunkSize?: number;
                maxPingLostCount?: number;
                maxRetryCount?: number;
                pingDelay?: number;
                pingEnabled?: boolean;
            };
        };
    }

  Returns Promise<void>

recognizeGesture

• recognizeGesture(
      stroke: IIStroke,
  ): Promise<TRecognizerWebSocketMessageContextlessGesture | undefined>

  Parameters

  • stroke: IIStroke

  Returns Promise<TRecognizerWebSocketMessageContextlessGesture | undefined>

redo

• redo(actions: TIIHistoryBackendChanges): Promise<void>

  Parameters

  • actions: TIIHistoryBackendChanges

  Returns Promise<void>

replaceStrokes

• replaceStrokes(oldStrokeIds: string[], newStrokes: IIStroke[]): Promise<void>

  Parameters

  • oldStrokeIds: string[]
  • newStrokes: IIStroke[]

  Returns Promise<void>

send

• send(message: TRecognizerWebSocketMessage): Promise<void>

  Parameters

  • message: TRecognizerWebSocketMessage

  Returns Promise<void>

transformMatrix

• transformMatrix(strokeIds: string[], matrix: TMatrixTransform): Promise<void>

  Parameters

  • strokeIds: string[]
  • matrix: TMatrixTransform

  Returns Promise<void>

transformRotate

• transformRotate(
      strokeIds: string[],
      angle: number,
      x0?: number,
      y0?: number,
  ): Promise<void>

  Parameters

  • strokeIds: string[]
  • angle: number
  • x0: number = 0
  • y0: number = 0

  Returns Promise<void>

transformScale

• transformScale(
      strokeIds: string[],
      scaleX: number,
      scaleY: number,
      x0?: number,
      y0?: number,
  ): Promise<void>

  Parameters

  • strokeIds: string[]
  • scaleX: number
  • scaleY: number
  • x0: number = 0
  • y0: number = 0

  Returns Promise<void>

transformTranslate

• transformTranslate(strokeIds: string[], tx: number, ty: number): Promise<void>

  Parameters

  • strokeIds: string[]
  • tx: number
  • ty: number

  Returns Promise<void>

undo

• undo(actions: TIIHistoryBackendChanges): Promise<void>

  Parameters

  • actions: TIIHistoryBackendChanges

  Returns Promise<void>

waitForIdle

• waitForIdle(): Promise<void>

  Returns Promise<void>

configuration

event

initialized

url