@finos/perspective
    Preparing search index...

    An instance of a [Client] is a connection to a single perspective_server::Server, whether locally in-memory or remote over some transport like a WebSocket.

    The browser and node.js libraries both support the websocket(url) constructor, which connects to a remote perspective_server::Server instance over a WebSocket transport.

    In the browser, the worker() constructor creates a new Web Worker perspective_server::Server and returns a [Client] connected to it.

    In node.js, a pre-instantied [Client] connected synhronously to a global singleton perspective_server::Server is the default module export.

    JavaScript Examples

    Create a Web Worker perspective_server::Server in the browser and return a [Client] instance connected for it:

    import perspective from "@finos/perspective";
    const client = await perspective.worker();

    Create a WebSocket connection to a remote perspective_server::Server:

    import perspective from "@finos/perspective";
    const client = await perspective.websocket("ws://locahost:8080/ws");

    Access the synchronous client in node.js:

    import { default as client } from "@finos/perspective";
    
    Index

    Constructors

    • Parameters

      • send_request: Function
      • Optionalclose: null | Function

      Returns Client

    Methods

    • Returns string

    • Returns void

    • Retrieves the names of all tables that this client has access to.

      name is a string identifier unique to the [Table] (per [Client]), which can be used in conjunction with [Client::open_table] to get a [Table] instance without the use of [Client::table] constructor directly (e.g., one created by another [Client]).

      JavaScript Examples

      const tables = await client.get_hosted_table_names();
      

      Returns Promise<any>

    • Parameters

      • error: string
      • Optionalreconnect: null | Function

      Returns Promise<void>

    • Parameters

      • value: any

      Returns Promise<void>

    • Returns Promise<void>

    • Parameters

      • on_response: Function

      Returns ProxySession

    • Parameters

      • callback: Function

      Returns Promise<number>

    • Register a callback which is invoked whenever [Client::table] (on this [Client]) or [Table::delete] (on a [Table] belinging to this [Client]) are called.

      Parameters

      • on_update_js: Function

      Returns Promise<number>

    • Opens a [Table] that is hosted on the perspective_server::Server that is connected to this [Client].

      The name property of [TableInitOptions] is used to identify each [Table]. [Table] names can be looked up for each [Client] via [Client::get_hosted_table_names].

      JavaScript Examples

      Get a virtual [Table] named "table_one" from this [Client]

      const tables = await client.open_table("table_one");
      

      Parameters

      • entity_id: string

      Returns Promise<Table>

    • Remove a callback previously registered via Client::on_hosted_tables_update.

      Parameters

      • update_id: number

      Returns Promise<void>

    • Provides the [SystemInfo] struct, implementation-specific metadata about the [perspective_server::Server] runtime such as Memory and CPU usage.

      For WebAssembly servers, this method includes the WebAssembly heap size.

      JavaScript Examples

      const info = await client.system_info();
      

      Returns Promise<any>

    • Creates a new [Table] from either a schema or data.

      The [Client::table] factory function can be initialized with either a schema (see [Table::schema]), or data in one of these formats:

      • Apache Arrow
      • CSV
      • JSON row-oriented
      • JSON column-oriented
      • NDJSON

      When instantiated with data, the schema is inferred from this data. While this is convenient, inferrence is sometimes imperfect e.g. when the input is empty, null or ambiguous. For these cases, [Client::table] can first be instantiated with a explicit schema.

      When instantiated with a schema, the resulting [Table] is empty but with known column names and column types. When subsqeuently populated with [Table::update], these columns will be coerced to the schema's type. This behavior can be useful when [Client::table]'s column type inferences doesn't work.

      The resulting [Table] is virtual, and invoking its methods dispatches events to the perspective_server::Server this [Client] connects to, where the data is stored and all calculation occurs.

      Arguments

      • arg - Either schema or initialization data.
      • options - Optional configuration which provides one of:
        • limit - The max number of rows the resulting [Table] can store.
        • index - The column name to use as an index column. If this Table is being instantiated by data, this column name must be present in the data.
        • name - The name of the table. This will be generated if it is not provided.
        • format - The explicit format of the input data, can be one of "json", "columns", "csv" or "arrow". This overrides language-specific type dispatch behavior, which allows stringified and byte array alternative inputs.

      JavaScript Examples

      Load a CSV from a string:

      const table = await client.table("x,y\n1,2\n3,4");
      

      Load an Arrow from an ArrayBuffer:

      import * as fs from "node:fs/promises";
      const table2 = await client.table(await fs.readFile("superstore.arrow"));

      Load a CSV from a UInt8Array (the default for this type is Arrow) using a format override:

      const enc = new TextEncoder();
      const table = await client.table(enc.encode("x,y\n1,2\n3,4"), {
      format: "csv",
      });

      Create a table with an index:

      const table = await client.table(data, { index: "Row ID" });
      

      Parameters

      • value: string | ArrayBuffer | Record<string, unknown>[] | Record<string, unknown[]>
      • Optionaloptions: null | TableInitOptions

      Returns Promise<Table>

    • Terminates this [Client], cleaning up any [crate::View] handles the [Client] has open as well as its callbacks.

      Returns any