@uwdata/mosaic-core 0.11.0 → 0.12.0

package/dist/types/SelectionClause.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @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[][] | 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[][] | 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} 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, { 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[]} 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[], { 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} 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, { 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 { MosaicClient } from './MosaicClient.js';

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

@@ -0,0 +1,17 @@
+export function restConnector(uri?: string): {
+    /**
+     * Query the DuckDB server.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json' | 'create-bundle' | 'load-bundle'} [query.type] The query type.
+     * @param {string} [query.sql] A SQL query string.
+     * @param {string[]} [query.queries] The queries used to create a bundle.
+     * @param {string} [query.name] The name of a bundle to create or load.
+     * @returns the query result
+     */
+    query(query: {
+        type?: "exec" | "arrow" | "json" | "create-bundle" | "load-bundle";
+        sql?: string;
+        queries?: string[];
+        name?: string;
+    }): Promise<any>;
+};

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

@@ -0,0 +1,18 @@
+export function socketConnector(uri?: string): {
+    readonly connected: boolean;
+    /**
+     * Query the DuckDB server.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json' | 'create-bundle' | 'load-bundle'} [query.type] The query type.
+     * @param {string} [query.sql] A SQL query string.
+     * @param {string[]} [query.queries] The queries used to create a bundle.
+     * @param {string} [query.name] The name of a bundle to create or load.
+     * @returns the query result
+     */
+    query(query: {
+        type?: "exec" | "arrow" | "json" | "create-bundle" | "load-bundle";
+        sql?: string;
+        queries?: string[];
+        name?: string;
+    }): Promise<any>;
+};

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

@@ -0,0 +1,16 @@
+export function wasmConnector(options?: {}): {
+    getDuckDB: () => Promise<duckdb.AsyncDuckDB>;
+    getConnection: () => Promise<duckdb.AsyncDuckDBConnection>;
+    /**
+     * Query the DuckDB-WASM instance.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type.
+     * @param {string} query.sql A SQL query string.
+     * @returns the query result
+     */
+    query: (query: {
+        type?: "exec" | "arrow" | "json";
+        sql: string;
+    }) => Promise<import("@uwdata/flechette").Table | Record<string, any>[]>;
+};
+import * as duckdb from '@duckdb/duckdb-wasm';

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+export { MosaicClient } from "./MosaicClient.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 type ClauseMetadata = import("./util/selection-types.js").ClauseMetadata;
+export type PointMetadata = import("./util/selection-types.js").PointMetadata;
+export type MatchMethod = import("./util/selection-types.js").MatchMethod;
+export type MatchMetadata = import("./util/selection-types.js").MatchMetadata;
+export type ScaleType = import("./util/selection-types.js").ScaleType;
+export type Extent = import("./util/selection-types.js").Extent;
+export type Scale = import("./util/selection-types.js").Scale;
+export type BinMethod = import("./util/selection-types.js").BinMethod;
+export type IntervalMetadata = import("./util/selection-types.js").IntervalMetadata;
+export type SelectionClause = import("./util/selection-types.js").SelectionClause;
+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";

package/dist/types/preagg/PreAggregator.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @typedef {object} PreAggregateOptions
+ * @property {string} [schema] Database schema (namespace) in which to write
+ *  pre-aggregated materialzied views (default 'mosaic').
+ * @property {boolean} [options.enabled=true] Flag to enable or disable the
+ *  pre-aggregation. This flag can be updated later via the `enabled` property.
+ */
+/**
+ * Build and query optimized pre-aggregated materaialized views, for fast
+ * computation of groupby aggregate queries over compatible client queries
+ * and selections. The materialized views contains pre-aggregated data for a
+ * Mosaic client, subdivided by possible query values from an active selection
+ * clause. These materialized views are database tables that can be queried
+ * for rapid updates.
+ *
+ * Compatible client queries must consist of only groupby dimensions and
+ * supported aggregate functions. Compatible selections must contain an active
+ * clause that exposes metadata for an interval or point value predicate.
+ *
+ * Materialized views are written to a dedicated schema (namespace) that
+ * can be set using the *schema* constructor option. This schema acts as a
+ * persistent cache, and materialized view tables may be used across sessions.
+ * The `dropSchema` method issues a query to remove *all* tables within this
+ * schema. This may be needed if the original tables have updated data, but
+ * should be used with care.
+ */
+export class PreAggregator {
+    /**
+     * Create a new manager of materialized views of pre-aggregated data.
+     * @param {import('../Coordinator.js').Coordinator} coordinator A Mosaic coordinator.
+     * @param {PreAggregateOptions} [options] Pre-aggregation options.
+     */
+    constructor(coordinator: import("../Coordinator.js").Coordinator, { schema, enabled }?: PreAggregateOptions);
+    /** @type {Map<import('../MosaicClient.js').MosaicClient, PreAggregateInfo | Skip | null>} */
+    entries: Map<import("../MosaicClient.js").MosaicClient, PreAggregateInfo | {
+        skip: boolean;
+        result: any;
+    } | null>;
+    active: any;
+    mc: import("../Coordinator.js").Coordinator;
+    _schema: string;
+    _enabled: boolean;
+    /**
+     * Set the enabled state of this manager. If false, any local state is
+     * cleared and subsequent request calls will return null until re-enabled.
+     * This method has no effect on any pre-aggregated tables already in the
+     * database.
+     * @param {boolean} [state] The enabled state to set.
+     */
+    set enabled(state: boolean);
+    /**
+     * Get the enabled state of this manager.
+     * @returns {boolean} The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Set the database schema used for pre-aggregated materialized view tables.
+     * Upon changes, any local state is cleared. This method does _not_ drop any
+     * existing materialized views, use `dropSchema` before changing the schema
+     * to also remove existing materalized views in the database.
+     * @param {string} [schema] The schema name to set.
+     */
+    set schema(schema: string);
+    /**
+     * Get the database schema used for pre-aggregated materialized view tables.
+     * @returns {string} The current schema name.
+     */
+    get schema(): string;
+    /**
+     * Issues a query through the coordinator to drop the current schema for
+     * pre-aggregated materialized views. *All* materialized view tables in the
+     * schema will be removed and local state is cleared. Call this method if
+     * the underlying base tables have been updated, causing materialized view
+     * to become stale and inaccurate. Use this method with care! Once dropped,
+     * the schema will be repopulated by future pre-aggregation requests.
+     * @returns A query result promise.
+     */
+    dropSchema(): import("../util/query-result.js").QueryResult;
+    /**
+     * Clear the cache of pre-aggregation entries for the current active
+     * selection clause. This method does _not_ drop any existing materialized
+     * views. Use `dropSchema` to remove existing materialized view tables from
+     * the database.
+     */
+    clear(): void;
+    /**
+     * Return pre-aggregation information for the active state of a
+     * client-selection pair, or null if the client has unstable filters.
+     * This method has multiple possible side effects, including materialized
+     * view creation and updating internal caches.
+     * @param {import('../MosaicClient.js').MosaicClient} client A Mosaic client.
+     * @param {import('../Selection.js').Selection} selection A Mosaic selection
+     *  to filter the client by.
+     * @param {import('../util/selection-types.js').SelectionClause} activeClause
+     *  A representative active selection clause for which to (possibly) generate
+     *  materialized views of pre-aggregates.
+     * @returns {PreAggregateInfo | Skip | null} Information and query generator
+     * for pre-aggregated tables, or null if the client has unstable filters.
+     */
+    request(client: import("../MosaicClient.js").MosaicClient, selection: import("../Selection.js").Selection, activeClause: import("../util/selection-types.js").SelectionClause): PreAggregateInfo | {
+        skip: boolean;
+        result: any;
+    } | null;
+}
+/**
+ * Metadata and query generator for materialized views of pre-aggregated data.
+ * This object provides the information needed to generate and query the
+ * materialized views for a client-selection pair relative to a specific
+ * active clause and selection state.
+ */
+export class PreAggregateInfo {
+    /**
+     * Create a new pre-aggregation information instance.
+     * @param {object} options Options object.
+     * @param {string} options.table The materialized view table name.
+     * @param {string} options.create The table creation query.
+     * @param {*} options.active Active column information.
+     * @param {SelectQuery} options.select Base query for requesting updates
+     *  using a pre-aggregated materialized view.
+     */
+    constructor({ table, create, active, select }: {
+        table: string;
+        create: string;
+        active: any;
+        select: SelectQuery;
+    });
+    /**
+     * The name of the materialized view.
+     * @type {string}
+     */
+    table: string;
+    /**
+     * The SQL query used to generate the materialized view.
+     * @type {string}
+     */
+    create: string;
+    /**
+     * A result promise returned for the materialized view creation query.
+     * @type {Promise | null}
+     */
+    result: Promise<any> | null;
+    /**
+     * Definitions and predicate function for the active columns,
+     * which are dynamically filtered by the active clause.
+     */
+    active: any;
+    /**
+     * Select query (sans where clause) for materialized views.
+     * @type {SelectQuery}
+     */
+    select: SelectQuery;
+    /**
+     * Boolean flag indicating a client that should be skipped.
+     * This value is always false for a created materialized view.
+     * @type {boolean}
+     */
+    skip: boolean;
+    /**
+     * Generate a materialized view query for the given predicate.
+     * @param {import('@uwdata/mosaic-sql').ExprNode} predicate The current
+     *  active clause predicate.
+     * @returns {SelectQuery} A materialized view query.
+     */
+    query(predicate: import("@uwdata/mosaic-sql").ExprNode): SelectQuery;
+}
+export type PreAggregateOptions = {
+    /**
+     * Database schema (namespace) in which to write
+     * pre-aggregated materialzied views (default 'mosaic').
+     */
+    schema?: string;
+    /**
+     * Flag to enable or disable the
+     * pre-aggregation. This flag can be updated later via the `enabled` property.
+     */
+    enabled?: boolean;
+};
+import { SelectQuery } from '@uwdata/mosaic-sql';

package/dist/types/preagg/preagg-columns.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Determine pre-aggregation columns for a given Mosaic client.
+ * @param {MosaicClient} client The Mosaic client.
+ * @returns An object with necessary column data to generate pre-aggregated
+ *  columns, or null if the client can't be optimized or the client query
+ *  contains an invalid or unsupported expression.
+ */
+export function preaggColumns(client: MosaicClient): {
+    group: string[];
+    preagg: Record<string, ExprNode>;
+    output: Record<string, ExprNode>;
+};
+import { MosaicClient } from '../MosaicClient.js';
+import { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/preagg/sufficient-statistics.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Determine sufficient statistics to preaggregate the given node. This
+ * method populates the *preagg* and *aggrs* arguments with necessary
+ * information for preaggregation optimization.
+ * @param {AggregateNode} node An aggregate function.
+ * @param {Record<string, ExprNode>} preagg Map of column names to
+ *  expressions to include in the preaggregation table.
+ * @returns {ExprNode} Output aggregate expression that uses preaggregated
+ *  sufficient statistics to service updates.
+ */
+export function sufficientStatistics(node: AggregateNode, preagg: Record<string, ExprNode>, avg: any): ExprNode;
+import { AggregateNode } from '@uwdata/mosaic-sql';
+import { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/util/AsyncDispatch.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Event dispatcher supporting asynchronous updates. If an event handler
+ * callback returns a Promise, the dispatcher waits for all such Promises
+ * to settle before dispatching future events of the same type.
+ */
+export class AsyncDispatch {
+    _callbacks: Map<any, any>;
+    /**
+     * Add an event listener callback for the provided event type.
+     * @param {string} type The event type.
+     * @param {(value: *) => void | Promise} callback The event handler
+     *  callback function to add. If the callback has already been
+     *  added for the event type, this method has no effect.
+     */
+    addEventListener(type: string, callback: (value: any) => void | Promise<any>): void;
+    /**
+     * Remove an event listener callback for the provided event type.
+     * @param {string} type The event type.
+     * @param {(value: *) => void | Promise} callback The event handler
+     *  callback function to remove.
+     */
+    removeEventListener(type: string, callback: (value: any) => void | Promise<any>): void;
+    /**
+     * Lifecycle method that returns the event value to emit.
+     * This default implementation simply returns the input value as-is.
+     * Subclasses may override this method to implement custom transformations
+     * prior to emitting an event value to all listeners.
+     * @param {string} type The event type.
+     * @param {*} value The event value.
+     * @returns The (possibly transformed) event value to emit.
+     */
+    willEmit(type: string, value: any): any;
+    /**
+     * Lifecycle method that returns a filter function for updating the
+     * queue of unemitted event values prior to enqueueing a new value.
+     * This default implementation simply returns null, indicating that
+     * any other unemitted event values should be dropped (that is, all
+     * queued events are filtered).
+     * @param {string} type The event type.
+     * @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.
+     */
+    emitQueueFilter(type: string, value: any): (value: any) => boolean | null;
+    /**
+     * Cancel all unemitted event values for the given event type.
+     * @param {string} type The event type.
+     */
+    cancel(type: string): void;
+    /**
+     * Returns a promise that resolves when any pending updates complete for
+     * the event of the given type currently being processed. The Promise will
+     * resolve immediately if the queue for the given event type is empty.
+     * @param {string} type The event type to wait for.
+     * @returns {Promise} A pending event promise.
+     */
+    pending(type: string): Promise<any>;
+    /**
+     * Emit an event value to listeners for the given event type.
+     * If a previous emit has not yet resolved, the event value
+     * will be queued to be emitted later.
+     * The actual event value given to listeners will be the result
+     * of passing the input value through the emitValue() method.
+     * @param {string} type The event type.
+     * @param {*} value The event value.
+     */
+    emit(type: string, value: any): void;
+}
+/**
+ * Queue for managing unemitted event values.
+ */
+export class DispatchQueue {
+    /**
+     * Clear the queue state of all event values.
+     */
+    clear(): void;
+    next: any;
+    /**
+     * Indicate if the queue is empty.
+     * @returns {boolean} True if queue is empty, false otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Add a new value to the queue, and optionally filter the
+     * current queue content in response.
+     * @param {*} value The value to add.
+     * @param {(value: *) => boolean} [filter] An optional filter
+     *  function to apply to existing queue content. If unspecified
+     *  or falsy, all previously queued values are removed. Otherwise,
+     *  the provided function is applied to all queue entries. The
+     *  entry is retained if the filter function returns a truthy value,
+     *  otherwise the entry is removed.
+     */
+    enqueue(value: any, filter?: (value: any) => boolean): void;
+    /**
+     * Remove and return the next queued event value.
+     * @returns {*} The next event value in the queue.
+     */
+    dequeue(): any;
+}

package/dist/types/util/cache.d.ts

@@ -0,0 +1,13 @@
+export function lruCache({ max, ttl }?: {
+    max?: number;
+    ttl?: number;
+}): {
+    get(key: any): any;
+    set(key: any, value: any): any;
+    clear(): void;
+};
+export function voidCache(): {
+    get: () => any;
+    set: (key: any, value: any) => any;
+    clear: () => void;
+};

package/dist/types/util/decode-ipc.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decode Arrow IPC bytes to a table instance, with an option to map date and
+ * timestamp values to JS Date objects.
+ * @param {ArrayBuffer | Uint8Array} data Arrow IPC bytes.
+ * @returns {import('@uwdata/flechette').Table} A table instance.
+ */
+export function decodeIPC(data: ArrayBuffer | Uint8Array): import("@uwdata/flechette").Table;

package/dist/types/util/distinct.d.ts

@@ -0,0 +1,2 @@
+export function distinct(a: any, b: any): boolean;
+export function distinctArray(a: any, b: any): boolean;

package/dist/types/util/field-info.d.ts

@@ -0,0 +1,13 @@
+export function queryFieldInfo(mc: any, fields: any): Promise<any[]>;
+export const Count: "count";
+export const Nulls: "nulls";
+export const Max: "max";
+export const Min: "min";
+export const Distinct: "distinct";
+export namespace Stats {
+    export { Count };
+    export { Nulls };
+    export { Max };
+    export { Min };
+    export { Distinct };
+}

package/dist/types/util/hash.d.ts

@@ -0,0 +1 @@
+export function fnv_hash(v: any): number;

package/dist/types/util/is-arrow-table.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Test if a value is a Flechette Arrow table.
+ * We use a "duck typing" approach and check for a getChild function.
+ * @param {*} values The value to test
+ * @returns {values is import('@uwdata/flechette').Table}
+ *  true if the value duck types as Arrow data
+ */
+export function isArrowTable(values: any): values is import("@uwdata/flechette").Table;

package/dist/types/util/js-type.d.ts

@@ -0,0 +1 @@
+export function jsType(type: any): "string" | "number" | "date" | "boolean" | "array" | "object";

package/dist/types/util/priority-queue.d.ts

@@ -0,0 +1,37 @@
+export class PriorityQueue {
+    /**
+     * Create a new priority queue instance.
+     * @param {number} ranks An integer number of rank-order priority levels.
+     */
+    constructor(ranks: number);
+    queue: {
+        head: any;
+        tail: any;
+    }[];
+    /**
+     * Indicate if the queue is empty.
+     * @returns {boolean} true if empty, false otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Insert an item into the queue with a given priority rank.
+     * @param {*} item The item to add.
+     * @param {number} rank The integer priority rank.
+     * Priority ranks are integers starting at zero.
+     * Lower ranks indicate higher priority.
+     */
+    insert(item: any, rank: number): void;
+    /**
+     * Remove a set of items from the queue, regardless of priority rank.
+     * If a provided item is not in the queue it will be ignored.
+     * @param {(item: *) => boolean} test A predicate function to test
+     * if an item should be removed (true to drop, false to keep).
+     */
+    remove(test: (item: any) => boolean): void;
+    /**
+     * Remove and return the next highest priority item.
+     * @returns {*} The next item in the queue,
+     * or undefined if this queue is empty.
+     */
+    next(): any;
+}

package/dist/types/util/query-result.d.ts

@@ -0,0 +1,44 @@
+export const QueryState: Readonly<{
+    pending: symbol;
+    ready: symbol;
+    error: symbol;
+    done: symbol;
+}>;
+/**
+ * A query result Promise that can allows external callers
+ * to resolve or reject the Promise.
+ */
+export class QueryResult extends Promise<any> {
+    /**
+     * Create a new query result Promise.
+     */
+    constructor();
+    _resolve: any;
+    _reject: any;
+    _state: symbol;
+    _value: any;
+    /**
+     * Resolve the result Promise with a prepared value or the provided value.
+     * This method will only succeed if either a value is provided or the promise is ready.
+     * @param {*} value The result value.
+     * @returns {this}
+     */
+    fulfill(value: any): this;
+    /**
+     * Prepare to resolve with the provided value.
+     * @param {*} value The result value.
+     * @returns {this}
+     */
+    ready(value: any): this;
+    /**
+     * Rejects the result Promise with the provided error.
+     * @param {*} error The error value.
+     * @returns {this}
+     */
+    reject(error: any): this;
+    /**
+     * Returns the state of this query result.
+     * @returns {symbol}
+     */
+    get state(): symbol;
+}