@perspective-dev/client 4.0.0

package/dist/esm/ts-rs/ViewConfigUpdate.d.ts

@@ -0,0 +1,90 @@
+import type { Aggregate } from "./Aggregate.js";
+import type { Expressions } from "./Expressions.js";
+import type { Filter } from "./Filter.js";
+import type { FilterReducer } from "./FilterReducer.js";
+import type { Sort } from "./Sort.js";
+export type ViewConfigUpdate = {
+    /**
+     * A group by _groups_ the dataset by the unique values of each column used
+     * as a group by - a close analogue in SQL to the `GROUP BY` statement.
+     * The underlying dataset is aggregated to show the values belonging to
+     * each group, and a total row is calculated for each group, showing
+     * the currently selected aggregated value (e.g. `sum`) of the column.
+     * Group by are useful for hierarchies, categorizing data and
+     * attributing values, i.e. showing the number of units sold based on
+     * State and City. In Perspective, group by are represented as an array
+     * of string column names to pivot, are applied in the order provided;
+     * For example, a group by of `["State", "City", "Postal Code"]` shows
+     * the values for each Postal Code, which are grouped by City,
+     * which are in turn grouped by State.
+     */
+    group_by?: Array<string>;
+    /**
+     * A split by _splits_ the dataset by the unique values of each column used
+     * as a split by. The underlying dataset is not aggregated, and a new
+     * column is created for each unique value of the split by. Each newly
+     * created column contains the parts of the dataset that correspond to
+     * the column header, i.e. a `View` that has `["State"]` as its split
+     * by will have a new column for each state. In Perspective, Split By
+     * are represented as an array of string column names to pivot.
+     */
+    split_by?: Array<string>;
+    /**
+     * The `columns` property specifies which columns should be included in the
+     * [`crate::View`]'s output. This allows users to show or hide a specific
+     * subset of columns, as well as control the order in which columns
+     * appear to the user. This is represented in Perspective as an array
+     * of string column names.
+     */
+    columns?: Array<string | null>;
+    /**
+     * The `filter` property specifies columns on which the query can be
+     * filtered, returning rows that pass the specified filter condition.
+     * This is analogous to the `WHERE` clause in SQL. There is no limit on
+     * the number of columns where `filter` is applied, but the resulting
+     * dataset is one that passes all the filter conditions, i.e. the
+     * filters are joined with an `AND` condition.
+     *
+     * Perspective represents `filter` as an array of arrays, with the values
+     * of each inner array being a string column name, a string filter
+     * operator, and a filter operand in the type of the column.
+     */
+    filter?: Array<Filter>;
+    /**
+     * The `sort` property specifies columns on which the query should be
+     * sorted, analogous to `ORDER BY` in SQL. A column can be sorted
+     * regardless of its data type, and sorts can be applied in ascending
+     * or descending order. Perspective represents `sort` as an array of
+     * arrays, with the values of each inner array being a string column
+     * name and a string sort direction. When `column-pivots` are applied,
+     * the additional sort directions `"col asc"` and `"col desc"` will
+     * determine the order of pivot columns groups.
+     */
+    sort?: Array<Sort>;
+    /**
+     * The `expressions` property specifies _new_ columns in Perspective that
+     * are created using existing column values or arbitary scalar values
+     * defined within the expression. In `<perspective-viewer>`,
+     * expressions are added using the "New Column" button in the side
+     * panel.
+     */
+    expressions?: Expressions;
+    /**
+     * Aggregates perform a calculation over an entire column, and are
+     * displayed when one or more [Group By](#group-by) are applied to the
+     * `View`. Aggregates can be specified by the user, or Perspective will
+     * use the following sensible default aggregates based on column type:
+     *
+     * - "sum" for `integer` and `float` columns
+     * - "count" for all other columns
+     *
+     * Perspective provides a selection of aggregate functions that can be
+     * applied to columns in the `View` constructor using a dictionary of
+     * column name to aggregate function name.
+     */
+    aggregates?: {
+        [key in string]?: Aggregate;
+    };
+    group_by_depth?: number;
+    filter_op?: FilterReducer;
+};

package/dist/esm/ts-rs/ViewOnUpdateResp.d.ts

@@ -0,0 +1,4 @@
+export type ViewOnUpdateResp = {
+    delta: Array<number>;
+    port_id: number;
+};

package/dist/esm/ts-rs/ViewWindow.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Options for serializing a window of data from a [`View`].
+ *
+ * Some fields of [`ViewWindow`] are only applicable to specific methods of
+ * [`View`].
+ */
+export type ViewWindow = {
+    start_row: number | null;
+    start_col: number | null;
+    end_row: number | null;
+    end_col: number | null;
+    id: boolean | null;
+    index: boolean | null;
+    leaves_only: boolean | null;
+    /**
+     * Only impacts [`View::to_csv`]
+     */
+    formatted: boolean | null;
+    /**
+     * Only impacts [`View::to_arrow`]
+     */
+    compression: string | null;
+};

package/dist/esm/wasm/browser.d.ts

@@ -0,0 +1,21 @@
+import type * as psp from "../../../dist/wasm/perspective-js.d.ts";
+/**
+ * Create a new client connected exclusively to a new Web Worker instance of
+ * the Perspective engine.
+ * @param module
+ * @returns
+ */
+export declare function worker(module: Promise<typeof psp>, server_wasm: Promise<WebAssembly.Module>, perspective_wasm_worker: Promise<SharedWorker | ServiceWorker | Worker>): Promise<psp.Client>;
+/**
+ * Create a new client connected via WebSocket to a server implemnting the
+ * Perspective Protocol.
+ * @param module
+ * @param url
+ * @returns
+ */
+export declare function websocket(module: Promise<typeof psp>, url: string | URL): Promise<psp.Client>;
+declare const _default: {
+    websocket: typeof websocket;
+    worker: typeof worker;
+};
+export default _default;

package/dist/esm/wasm/decompress.d.ts

@@ -0,0 +1 @@
+export declare function load_wasm_stage_0(wasm: ArrayBuffer | Response | WebAssembly.Module | (() => Promise<ArrayBuffer>)): Promise<Uint8Array>;

package/dist/esm/wasm/emscripten_api.d.ts

@@ -0,0 +1,5 @@
+export type * from "../../../dist/wasm/perspective-js.js";
+import type * as perspective_server_t from "@perspective-dev/server/dist/wasm/perspective-server.js";
+export type PspPtr = BigInt | number;
+export type EmscriptenServer = bigint | number;
+export declare function compile_perspective(wasmBinary: ArrayBuffer): Promise<perspective_server_t.MainModule>;

package/dist/esm/wasm/engine.d.ts

@@ -0,0 +1,40 @@
+import type { MainModule } from "@perspective-dev/server/dist/wasm/perspective-server.js";
+import type { EmscriptenServer } from "./emscripten_api.ts";
+export type ApiResponse = {
+    client_id: number;
+    data: Uint8Array;
+};
+export interface PerspectiveServerOptions {
+    on_poll_request?: (x: PerspectiveServer) => Promise<void>;
+}
+export declare class PerspectivePollThread {
+    private poll_handle?;
+    private server;
+    constructor(server: PerspectiveServer);
+    private set_poll_handle;
+    on_poll_request(): Promise<void>;
+}
+export declare class PerspectiveServer {
+    clients: Map<number, (buffer: Uint8Array) => Promise<void>>;
+    server: EmscriptenServer;
+    module: MainModule;
+    on_poll_request?: (x: PerspectiveServer) => Promise<void>;
+    constructor(module: MainModule, options?: PerspectiveServerOptions);
+    /**
+     * Helper function to create server emitter/receiver pairs
+     */
+    make_session(callback: (buffer: Uint8Array) => Promise<void>): PerspectiveSession;
+    poll(): Promise<void>;
+    delete(): void;
+}
+export declare class PerspectiveSession {
+    private mod;
+    private server;
+    private client_id;
+    private client_map;
+    private on_poll_request?;
+    constructor(mod: MainModule, server: EmscriptenServer, client_id: number, client_map: Map<number, (buffer: Uint8Array) => Promise<void>>, on_poll_request?: (() => Promise<void>) | undefined);
+    handle_request(view: Uint8Array): Promise<void>;
+    private poll;
+    close(): void;
+}

package/dist/esm/wasm/perspective-server.poly.d.ts

@@ -0,0 +1 @@
+export default function (obj: any): Promise<any>;

package/dist/esm/websocket.d.ts

@@ -0,0 +1,4 @@
+import type * as perspective_client from "../../dist/wasm/perspective-js.js";
+export declare function websocket(WebSocket: typeof window.WebSocket, Client: typeof perspective_client.Client, url: string | URL, options?: {
+    maxPayload: number;
+}): Promise<perspective_client.Client>;