@uwdata/mosaic-core 0.16.2 → 0.17.0

package/dist/types/Selection.d.ts

@@ -1,235 +0,0 @@
-/**
- * Test if a value is a Selection instance.
- * @param {*} x The value to test.
- * @returns {x is Selection} True if the input is a Selection, false otherwise.
- */
-export function isSelection(x: any): x is Selection;
-/**
- * Represents a dynamic set of query filter predicates.
- */
-export class Selection extends Param {
-    /**
-     * Create a new Selection instance with an
-     * intersect (conjunction) resolution strategy.
-     * @param {object} [options] The selection options.
-     * @param {boolean} [options.cross=false] Boolean flag indicating
-     *  cross-filtered resolution. If true, selection clauses will not
-     *  be applied to the clients they are associated with.
-     * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
-     *  of clauses should correspond to an empty selection with no records. This
-     *  setting determines the default selection state.
-     * @param {Selection|Selection[]} [options.include] Upstream selections whose
-     *  clauses should be included as part of the new selection. Any clauses
-     *  published to upstream selections will be relayed to the new selection.
-     * @returns {Selection} The new Selection instance.
-     */
-    static intersect({ cross, empty, include }?: {
-        cross?: boolean;
-        empty?: boolean;
-        include?: Selection | Selection[];
-    }): Selection;
-    /**
-     * Create a new Selection instance with a
-     * union (disjunction) resolution strategy.
-     * @param {object} [options] The selection options.
-     * @param {boolean} [options.cross=false] Boolean flag indicating
-     *  cross-filtered resolution. If true, selection clauses will not
-     *  be applied to the clients they are associated with.
-     * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
-     *  of clauses should correspond to an empty selection with no records. This
-     *  setting determines the default selection state.
-     * @param {Selection|Selection[]} [options.include] Upstream selections whose
-     *  clauses should be included as part of the new selection. Any clauses
-     *  published to upstream selections will be relayed to the new selection.
-     * @returns {Selection} The new Selection instance.
-     */
-    static union({ cross, empty, include }?: {
-        cross?: boolean;
-        empty?: boolean;
-        include?: Selection | Selection[];
-    }): Selection;
-    /**
-     * Create a new Selection instance with a singular resolution strategy
-     * that keeps only the most recent selection clause.
-     * @param {object} [options] The selection options.
-     * @param {boolean} [options.cross=false] Boolean flag indicating
-     *  cross-filtered resolution. If true, selection clauses will not
-     *  be applied to the clients they are associated with.
-     * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
-     *  of clauses should correspond to an empty selection with no records. This
-     *  setting determines the default selection state.
-     * @param {Selection|Selection[]} [options.include] Upstream selections whose
-     *  clauses should be included as part of the new selection. Any clauses
-     *  published to upstream selections will be relayed to the new selection.
-     * @returns {Selection} The new Selection instance.
-     */
-    static single({ cross, empty, include }?: {
-        cross?: boolean;
-        empty?: boolean;
-        include?: Selection | Selection[];
-    }): Selection;
-    /**
-     * Create a new Selection instance with a
-     * cross-filtered intersect resolution strategy.
-     * @param {object} [options] The selection options.
-     * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
-     *  of clauses should correspond to an empty selection with no records. This
-     *  setting determines the default selection state.
-     * @param {Selection|Selection[]} [options.include] Upstream selections whose
-     *  clauses should be included as part of the new selection. Any clauses
-     *  published to upstream selections will be relayed to the new selection.
-     * @returns {Selection} The new Selection instance.
-     */
-    static crossfilter({ empty, include }?: {
-        empty?: boolean;
-        include?: Selection | Selection[];
-    }): Selection;
-    /**
-     * Create a new Selection instance.
-     * @param {SelectionResolver} [resolver] The selection resolution
-     *  strategy to apply.
-     * @param {Selection[]} [include] Upstream selections whose clauses
-     * should be included as part of this selection. Any clauses published
-     * to these upstream selections will be relayed to this selection.
-     */
-    constructor(resolver?: SelectionResolver, include?: Selection[]);
-    _resolved: any;
-    _resolver: SelectionResolver;
-    /** @type {Set<Selection>} */
-    _relay: Set<Selection>;
-    /**
-     * Create a cloned copy of this Selection instance.
-     * @returns {Selection} A clone of this selection.
-     */
-    clone(): Selection;
-    /**
-     * Create a clone of this Selection with clauses corresponding
-     * to the provided source removed.
-     * @param {*} source The clause source to remove.
-     * @returns {Selection} A cloned and updated Selection.
-     */
-    remove(source: any): Selection;
-    /**
-     * The selection clause resolver.
-     */
-    get resolver(): SelectionResolver;
-    /**
-     * Indicate if this selection has a single resolution strategy.
-     */
-    get single(): boolean;
-    /**
-     * The current array of selection clauses.
-     */
-    get clauses(): any;
-    /**
-     * The current active (most recently updated) selection clause.
-     */
-    get active(): any;
-    /**
-     * The value corresponding to a given source. Returns undefined if
-     * this selection does not include a clause from this source.
-     * @param {*} source The clause source to look up the value for.
-     */
-    valueFor(source: any): any;
-    /**
-     * Emit an activate event with the given selection clause.
-     * @param {SelectionClause} clause The clause repesenting the potential activation.
-     */
-    activate(clause: SelectionClause): void;
-    /**
-     * Update the selection with a new selection clause.
-     * @param {SelectionClause} clause The selection clause to add.
-     * @returns {this} This Selection instance.
-     */
-    update(clause: SelectionClause): this;
-    /**
-     * Reset the selection state by removing all provided clauses. If no clause
-     * array is provided as an argument, all current clauses are removed. The
-     * reset method (if defined) is invoked on all corresponding clause sources.
-     * The reset is relayed to downstream selections that include this selection.
-     * @param {SelectionClause[]} [clauses] The clauses to remove. If
-     *  unspecified, all current clauses are removed.
-     * @returns {this} This selection instance.
-     */
-    reset(clauses?: SelectionClause[]): this;
-    /**
-     * Indicates if a selection clause should not be applied to a given client.
-     * The return value depends on the selection resolution strategy.
-     * @param {*} client The selection clause.
-     * @param {*} clause The client to test.
-     * @returns True if the client should be skipped, false otherwise.
-     */
-    skip(client: any, clause: any): any;
-    /**
-     * Return a selection query predicate for the given client.
-     * @param {*} client The client whose data may be filtered.
-     * @param {boolean} [noSkip=false] Disable skipping of active
-     *  cross-filtered sources. If set true, the source of the active
-     *  clause in a cross-filtered selection will not be skipped.
-     * @returns {*} The query predicate for filtering client data,
-     *  based on the current state of this selection.
-     */
-    predicate(client: any, noSkip?: boolean): any;
-}
-/**
- * Implements selection clause resolution strategies.
- */
-export class SelectionResolver {
-    /**
-     * Create a new selection resolved instance.
-     * @param {object} [options] The resolution strategy options.
-     * @param {boolean} [options.union=false] Boolean flag to indicate a union strategy.
-     *  If false, an intersection strategy is used.
-     * @param {boolean} [options.cross=false] Boolean flag to indicate cross-filtering.
-     * @param {boolean} [options.single=false] Boolean flag to indicate single clauses only.
-     * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
-     *  of clauses should correspond to an empty selection with no records. This
-     *  setting determines the default selection state.
-     */
-    constructor({ union, cross, single, empty }?: {
-        union?: boolean;
-        cross?: boolean;
-        single?: boolean;
-        empty?: boolean;
-    });
-    union: boolean;
-    cross: boolean;
-    single: boolean;
-    empty: boolean;
-    /**
-     * Resolve a list of selection clauses according to the resolution strategy.
-     * @param {*[]} clauseList An array of selection clauses.
-     * @param {*} clause A new selection clause to add.
-     * @returns {*[]} An updated array of selection clauses.
-     */
-    resolve(clauseList: any[], clause: any, reset?: boolean): any[];
-    /**
-     * Indicates if a selection clause should not be applied to a given client.
-     * The return value depends on the resolution strategy.
-     * @param {*} client The selection clause.
-     * @param {*} clause The client to test.
-     * @returns True if the client should be skipped, false otherwise.
-     */
-    skip(client: any, clause: any): any;
-    /**
-     * Return a selection query predicate for the given client.
-     * @param {import('./util/selection-types.js').SelectionClause[]} clauseList
-     *  An array of selection clauses.
-     * @param {import('./util/selection-types.js').SelectionClause} active
-     *  The current active selection clause.
-     * @param {MosaicClient} client The client whose data may be filtered.
-     * @returns {*} The query predicate for filtering client data,
-     *  based on the current state of this selection.
-     */
-    predicate(clauseList: import("./util/selection-types.js").SelectionClause[], active: import("./util/selection-types.js").SelectionClause, client: MosaicClient): any;
-    /**
-     * Returns a filter function for queued selection updates.
-     * @param {*} value The new event value that will be enqueued.
-     * @returns {(value: *) => boolean|null} A dispatch queue filter
-     *  function, or null if all unemitted event values should be filtered.
-     */
-    queueFilter(value: any): (value: any) => boolean | null;
-}
-import { Param } from './Param.js';
-import type { SelectionClause } from './util/selection-types.js';
-import type { MosaicClient } from './MosaicClient.js';

package/dist/types/SelectionClause.d.ts

@@ -1,105 +0,0 @@
-/**
- * @typedef {import('./util/selection-types.js').SelectionClause} SelectionClause
- * @typedef {import('./util/selection-types.js').Scale} Scale
- * @typedef {import('./util/selection-types.js').Extent} Extent
- * @typedef {import('./util/selection-types.js').MatchMethod} MatchMethod
- * @typedef {import('./util/selection-types.js').BinMethod} BinMethod
- */
-/**
- * Generate a selection clause for a single selected point value.
- * @param {import('@uwdata/mosaic-sql').ExprValue} field The table column or expression to select.
- * @param {*} value The selected value.
- * @param {object} options Additional clause properties.
- * @param {*} options.source The source component generating this clause.
- * @param {Set<MosaicClient>} [options.clients] The Mosaic clients associated
- *  with this clause. These clients are not filtered by this clause in
- *  cross-filtering contexts.
- * @returns {SelectionClause} The generated selection clause.
- */
-export function clausePoint(field: import("@uwdata/mosaic-sql").ExprValue, value: any, { source, clients }: {
-    source: any;
-    clients?: Set<MosaicClient>;
-}): SelectionClause;
-/**
- * Generate a selection clause for multiple selected point values.
- * @param {import('@uwdata/mosaic-sql').ExprValue[]} fields The table columns or expressions to select.
- * @param {any[][] | null | undefined} value The selected values, as an array of
- *  arrays. Each subarray contains values for each *fields* entry.
- * @param {object} options Additional clause properties.
- * @param {*} options.source The source component generating this clause.
- * @param {Set<MosaicClient>} [options.clients] The Mosaic clients associated
- *  with this clause. These clients are not filtered by this clause in
- *  cross-filtering contexts.
- * @returns {SelectionClause} The generated selection clause.
- */
-export function clausePoints(fields: import("@uwdata/mosaic-sql").ExprValue[], value: any[][] | null | undefined, { source, clients }: {
-    source: any;
-    clients?: Set<MosaicClient>;
-}): SelectionClause;
-/**
- * Generate a selection clause for a selected 1D interval.
- * @param {import('@uwdata/mosaic-sql').ExprValue} field The table column or expression to select.
- * @param {Extent | null | undefined} value The selected interval as a [lo, hi] array.
- * @param {object} options Additional clause properties.
- * @param {*} options.source The source component generating this clause.
- * @param {Set<MosaicClient>} [options.clients] The Mosaic clients associated
- *  with this clause. These clients are not filtered by this clause in
- *  cross-filtering contexts.
- * @param {Scale} [options.scale] The scale mapping descriptor.
- * @param {BinMethod} [options.bin] A binning method hint.
- * @param {number} [options.pixelSize=1] The interactive pixel size.
- * @returns {SelectionClause} The generated selection clause.
- */
-export function clauseInterval(field: import("@uwdata/mosaic-sql").ExprValue, value: Extent | null | undefined, { source, clients, bin, scale, pixelSize }: {
-    source: any;
-    clients?: Set<MosaicClient>;
-    scale?: Scale;
-    bin?: BinMethod;
-    pixelSize?: number;
-}): SelectionClause;
-/**
- * Generate a selection clause for multiple selected intervals.
- * @param {import('@uwdata/mosaic-sql').ExprValue[]} fields The table columns or expressions to select.
- * @param {Extent[] | null | undefined} value The selected intervals, as an array of extents.
- * @param {object} options Additional clause properties.
- * @param {*} options.source The source component generating this clause.
- * @param {Set<MosaicClient>} [options.clients] The Mosaic clients associated
- *  with this clause. These clients are not filtered by this clause in
- *  cross-filtering contexts.
- * @param {Scale[]} [options.scales] The scale mapping descriptors,
- *  in an order matching the given *fields* and *value* extents.
- * @param {BinMethod} [options.bin] A binning method hint.
- * @param {number} [options.pixelSize=1] The interactive pixel size.
- * @returns {SelectionClause} The generated selection clause.
- */
-export function clauseIntervals(fields: import("@uwdata/mosaic-sql").ExprValue[], value: Extent[] | null | undefined, { source, clients, bin, scales, pixelSize }: {
-    source: any;
-    clients?: Set<MosaicClient>;
-    scales?: Scale[];
-    bin?: BinMethod;
-    pixelSize?: number;
-}): SelectionClause;
-/**
- * Generate a selection clause for text search matching.
- * @param {import('@uwdata/mosaic-sql').ExprValue} field The table column or expression to select.
- * @param {string | null | undefined} value The selected text search query string.
- * @param {object} options Additional clause properties.
- * @param {*} options.source The source component generating this clause.
- * @param {Set<MosaicClient>} [options.clients] The Mosaic clients associated
- *  with this clause. These clients are not filtered by this clause in
- *  cross-filtering contexts.
- * @param {MatchMethod} [options.method] The
- *  text matching method to use. Defaults to `'contains'`.
- * @returns {SelectionClause} The generated selection clause.
- */
-export function clauseMatch(field: import("@uwdata/mosaic-sql").ExprValue, value: string | null | undefined, { source, clients, method }: {
-    source: any;
-    clients?: Set<MosaicClient>;
-    method?: MatchMethod;
-}): SelectionClause;
-export type SelectionClause = import("./util/selection-types.js").SelectionClause;
-export type Scale = import("./util/selection-types.js").Scale;
-export type Extent = import("./util/selection-types.js").Extent;
-export type MatchMethod = import("./util/selection-types.js").MatchMethod;
-export type BinMethod = import("./util/selection-types.js").BinMethod;
-import type { MosaicClient } from './MosaicClient.js';

package/dist/types/connectors/Connector.d.ts

@@ -1,25 +0,0 @@
-import type { Table } from '@uwdata/flechette';
-export interface QueryRequest {
-    /** The query type. */
-    type?: string;
-    /** A SQL query string. */
-    sql: string;
-}
-export interface ArrowQueryRequest extends QueryRequest {
-    /** The query type. */
-    type?: 'arrow';
-}
-export interface ExecQueryRequest extends QueryRequest {
-    /** The query type. */
-    type: 'exec';
-}
-export interface JSONQueryRequest extends QueryRequest {
-    /** The query type. */
-    type: 'json';
-}
-export interface Connector {
-    /** Issue a query and return the result. */
-    query(query: ArrowQueryRequest): Promise<Table>;
-    query(query: ExecQueryRequest): Promise<void>;
-    query(query: JSONQueryRequest): Promise<Record<string, any>[]>;
-}

package/dist/types/connectors/rest.d.ts

@@ -1,13 +0,0 @@
-/**
- * Connect to a DuckDB server over an HTTP REST interface.
- * @param {object} [options] Connector options.
- * @param {string} [options.uri] The URI for the DuckDB REST server.
- * @param {ExtractionOptions} [options.ipc] Arrow IPC extraction options.
- * @returns {Connector} A connector instance.
- */
-export function restConnector({ uri, ipc, }?: {
-    uri?: string;
-    ipc?: ExtractionOptions;
-}): Connector;
-import type { ExtractionOptions } from '@uwdata/flechette';
-import type { Connector } from './Connector.js';

package/dist/types/connectors/socket.d.ts

@@ -1,100 +0,0 @@
-/**
- * Connect to a DuckDB server over a WebSocket interface.
- * @param {object} [options] Connector options.
- * @param {string} [options.uri] The URI for the DuckDB REST server.
- * @param {ExtractionOptions} [options.ipc] Arrow IPC extraction options.
- * @returns {SocketConnector} A connector instance.
- */
-export function socketConnector(options?: {
-    uri?: string;
-    ipc?: ExtractionOptions;
-}): SocketConnector;
-/**
- * DuckDB socket connector.
- * @implements {Connector}
- */
-export class SocketConnector implements Connector {
-    /**
-     * @param {object} [options] Connector options.
-     * @param {string} [options.uri] The URI for the DuckDB REST server.
-     * @param {ExtractionOptions} [options.ipc] Arrow IPC extraction options.
-     */
-    constructor({ uri, ipc, }?: {
-        uri?: string;
-        ipc?: ExtractionOptions;
-    });
-    _uri: string;
-    _queue: any[];
-    _connected: boolean;
-    _request: any;
-    _ws: WebSocket;
-    _events: {
-        open(): void;
-        close(): void;
-        error(event: any): void;
-        message({ data }: {
-            data: any;
-        }): void;
-    };
-    get connected(): boolean;
-    init(): void;
-    enqueue(query: any, resolve: any, reject: any): void;
-    next(): void;
-    /**
-     * @overload
-     * @param {ArrowQueryRequest} query
-     * @returns {Promise<Table>}
-     *
-     * @overload
-     * @param {ExecQueryRequest} query
-     * @returns {Promise<void>}
-     *
-     * @overload
-     * @param {JSONQueryRequest} query
-     * @returns {Promise<Record<string, any>[]>}
-     *
-     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
-     * @returns {Promise<Table | void | Record<string, any>[]>}}
-     */
-    query(query: ArrowQueryRequest): Promise<Table>;
-    /**
-     * @overload
-     * @param {ArrowQueryRequest} query
-     * @returns {Promise<Table>}
-     *
-     * @overload
-     * @param {ExecQueryRequest} query
-     * @returns {Promise<void>}
-     *
-     * @overload
-     * @param {JSONQueryRequest} query
-     * @returns {Promise<Record<string, any>[]>}
-     *
-     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
-     * @returns {Promise<Table | void | Record<string, any>[]>}}
-     */
-    query(query: ExecQueryRequest): Promise<void>;
-    /**
-     * @overload
-     * @param {ArrowQueryRequest} query
-     * @returns {Promise<Table>}
-     *
-     * @overload
-     * @param {ExecQueryRequest} query
-     * @returns {Promise<void>}
-     *
-     * @overload
-     * @param {JSONQueryRequest} query
-     * @returns {Promise<Record<string, any>[]>}
-     *
-     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
-     * @returns {Promise<Table | void | Record<string, any>[]>}}
-     */
-    query(query: JSONQueryRequest): Promise<Record<string, any>[]>;
-}
-import type { ExtractionOptions } from '@uwdata/flechette';
-import type { Connector } from './Connector.js';
-import type { ArrowQueryRequest } from './Connector.js';
-import type { Table } from '@uwdata/flechette';
-import type { ExecQueryRequest } from './Connector.js';
-import type { JSONQueryRequest } from './Connector.js';

package/dist/types/connectors/wasm.d.ts

@@ -1,135 +0,0 @@
-/**
- * @typedef {object} DuckDBWASMOptions
- * @property {boolean} [log] Flag to enable logging.
- */
-/**
- * @typedef {object} DuckDBWASMConnectorOptions
- * @property {boolean} [log] Flag to enable logging.
- * @property {ExtractionOptions} [ipc]
- *  Arrow IPC extraction options.
- * @property {duckdb.AsyncDuckDB} [duckdb]
- *  Optional pre-existing DuckDB-WASM instance.
- * @property {duckdb.AsyncDuckDBConnection} [connection]
- *  Optional pre-existing DuckDB-WASM connection.
- */
-/**
- * Connect to a DuckDB-WASM instance.
- * @param {DuckDBWASMConnectorOptions} [options] Connector options.
- * @returns {DuckDBWASMConnector} A connector instance.
- */
-export function wasmConnector(options?: DuckDBWASMConnectorOptions): DuckDBWASMConnector;
-/**
- * DuckDB-WASM connector.
- * @implements {Connector}
- */
-export class DuckDBWASMConnector implements Connector {
-    /**
-     * Create a new DuckDB-WASM connector instance.
-     * @param {DuckDBWASMConnectorOptions} [options]
-     */
-    constructor(options?: DuckDBWASMConnectorOptions);
-    /** @type {ExtractionOptions} */
-    _ipc: ExtractionOptions;
-    /** @type {DuckDBWASMOptions} */
-    _options: DuckDBWASMOptions;
-    /** @type {duckdb.AsyncDuckDB} */
-    _db: duckdb.AsyncDuckDB;
-    /** @type {duckdb.AsyncDuckDBConnection} */
-    _con: duckdb.AsyncDuckDBConnection;
-    /** @type {Promise<unknown>} */
-    _loadPromise: Promise<unknown>;
-    /**
-     * Get the backing DuckDB-WASM instance.
-     * Lazily initializes DuckDB-WASM if not already loaded.
-     * @returns {Promise<duckdb.AsyncDuckDB>} The DuckDB-WASM instance.
-     */
-    getDuckDB(): Promise<duckdb.AsyncDuckDB>;
-    /**
-     * Get the backing DuckDB-WASM connection.
-     * Lazily initializes DuckDB-WASM if not already loaded.
-     * @returns {Promise<duckdb.AsyncDuckDBConnection>} The DuckDB-WASM connection.
-     */
-    getConnection(): Promise<duckdb.AsyncDuckDBConnection>;
-    /**
-     * @overload
-     * @param {ArrowQueryRequest} query
-     * @returns {Promise<Table>}
-     *
-     * @overload
-     * @param {ExecQueryRequest} query
-     * @returns {Promise<void>}
-     *
-     * @overload
-     * @param {JSONQueryRequest} query
-     * @returns {Promise<Record<string, any>[]>}
-     *
-     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
-     * @returns {Promise<Table | void | Record<string, any>[]>}}
-     */
-    query(query: ArrowQueryRequest): Promise<Table>;
-    /**
-     * @overload
-     * @param {ArrowQueryRequest} query
-     * @returns {Promise<Table>}
-     *
-     * @overload
-     * @param {ExecQueryRequest} query
-     * @returns {Promise<void>}
-     *
-     * @overload
-     * @param {JSONQueryRequest} query
-     * @returns {Promise<Record<string, any>[]>}
-     *
-     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
-     * @returns {Promise<Table | void | Record<string, any>[]>}}
-     */
-    query(query: ExecQueryRequest): Promise<void>;
-    /**
-     * @overload
-     * @param {ArrowQueryRequest} query
-     * @returns {Promise<Table>}
-     *
-     * @overload
-     * @param {ExecQueryRequest} query
-     * @returns {Promise<void>}
-     *
-     * @overload
-     * @param {JSONQueryRequest} query
-     * @returns {Promise<Record<string, any>[]>}
-     *
-     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
-     * @returns {Promise<Table | void | Record<string, any>[]>}}
-     */
-    query(query: JSONQueryRequest): Promise<Record<string, any>[]>;
-}
-export type DuckDBWASMOptions = {
-    /**
-     * Flag to enable logging.
-     */
-    log?: boolean;
-};
-export type DuckDBWASMConnectorOptions = {
-    /**
-     * Flag to enable logging.
-     */
-    log?: boolean;
-    /**
-     * Arrow IPC extraction options.
-     */
-    ipc?: ExtractionOptions;
-    /**
-     * Optional pre-existing DuckDB-WASM instance.
-     */
-    duckdb?: duckdb.AsyncDuckDB;
-    /**
-     * Optional pre-existing DuckDB-WASM connection.
-     */
-    connection?: duckdb.AsyncDuckDBConnection;
-};
-import type { Connector } from './Connector.js';
-import type { ExtractionOptions } from '@uwdata/flechette';
-import * as duckdb from '@duckdb/duckdb-wasm';
-import type { ArrowQueryRequest } from './Connector.js';
-import type { Table } from '@uwdata/flechette';
-import type { ExecQueryRequest } from './Connector.js';
-import type { JSONQueryRequest } from './Connector.js';

package/dist/types/index-types.d.ts

@@ -1,4 +0,0 @@
-export * from './index.js';
-export * from './types.js';
-export * from './connectors/Connector.js';
-export * from './util/selection-types.js';

package/dist/types/index.d.ts

@@ -1,19 +0,0 @@
-export { MosaicClient } from "./MosaicClient.js";
-export { makeClient } from "./make-client.js";
-export { Priority } from "./QueryManager.js";
-export { restConnector } from "./connectors/rest.js";
-export { socketConnector } from "./connectors/socket.js";
-export { wasmConnector } from "./connectors/wasm.js";
-export { decodeIPC } from "./util/decode-ipc.js";
-export { distinct } from "./util/distinct.js";
-export { isArrowTable } from "./util/is-arrow-table.js";
-export { synchronizer } from "./util/synchronizer.js";
-export { throttle } from "./util/throttle.js";
-export { toDataColumns } from "./util/to-data-columns.js";
-export { queryFieldInfo } from "./util/field-info.js";
-export { jsType } from "./util/js-type.js";
-export { isActivatable } from "./util/is-activatable.js";
-export { Coordinator, coordinator } from "./Coordinator.js";
-export { Selection, isSelection } from "./Selection.js";
-export { Param, isParam } from "./Param.js";
-export { clauseInterval, clauseIntervals, clausePoint, clausePoints, clauseMatch } from "./SelectionClause.js";