@uwdata/mosaic-core 0.17.0 → 0.19.0

package/src/util/is-arrow-table.js

@@ -1,10 +0,0 @@
-/**
- * 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) {
-  return typeof values?.getChild === 'function';
-}

package/src/util/selection-types.ts

@@ -1,137 +0,0 @@
-import { ExprNode } from '@uwdata/mosaic-sql';
-import { MosaicClient } from '../MosaicClient.js';
-
-/**
- * Selection clause metadata to guide possible query optimizations.
- * Sub-interfaces provide more information about the specifics of a
- * given selection based on the selection type.
- */
-export interface ClauseMetadata {
-  /**
-   * The selection type, such as `'point'`, `'interval'`, or `'match'`.
-   */
-  type: string;
-}
-
-/**
- * Selection clause metadata indicating selection of one or more discrete
- * point values, typically based on equality or is distinctiveness checks.
- */
-export interface PointMetadata extends ClauseMetadata {
-  type: 'point';
-}
-
-/** Text search matching methods. */
-export type MatchMethod =
-  | 'contains'
-  | 'prefix'
-  | 'suffix'
-  | 'regexp'
-  | (string & {});
-
-/**
- * Selection clause metadata indicating text search matching.
- */
-export interface MatchMetadata extends ClauseMetadata {
-  type: MatchMethod;
-  /** The text search matching method used. */
-  method?: 'contains' | 'prefix' | 'suffix' | 'regexp' | (string & {});
-}
-
-/** Quantitative scale types. */
-export type ScaleType =
-  | 'identity'
-  | 'linear'
-  | 'log'
-  | 'sqrt'
-  | 'pow'
-  | 'symlog'
-  | 'time'
-  | 'utc';
-
-/** A data value interval extent. */
-export type Extent = [number, number] | [Date, Date];
-
-/**
- * Descriptor for a scale that maps a data domain to screen pixels.
- */
-export interface Scale {
-  /** The scale type, such as `'linear'`, `'log'`, etc. */
-  type: ScaleType;
-  /** The scale domain, as an array of start and end data values. */
-  domain: Extent;
-  /**
-   * The scale range, as an array of start and end screen pixels.
-   * The range may be omitted for *identity* scales.
-   */
-  range?: [number, number];
-  /** The base of the logarithm. For `'log'` scales only. */
-  base?: number;
-  /** The constant parameter. For `'symlog'` scales only. */
-  constant?: number;
-  /** The exponent parameter. For `'pow'` scales only. */
-  exponent?: number;
-}
-
-/** A binning method name. */
-export type BinMethod = 'floor' | 'ceil' | 'round';
-
-/**
- * Selection clause metadata for one or more selected intervals. This
- * metadata can be used to determine appropriate data-space binning
- * schemes that correspond to pixel-level bins in screen space.
- */
-export interface IntervalMetadata extends ClauseMetadata {
-  type: 'interval';
-  /**
-   * The interactive pixel size used by the generating component.
-   * Values larger than one indicate intervals that "snap-to" values
-   * greater than a single pixel. If unspecified, assumed to be `1`.
-   */
-  pixelSize?: number;
-  /**
-   * An array of one or more scale descriptors that describe the
-   * mapping from data values to screen pixels.
-   */
-  scales?: Scale[];
-  /**
-   * A hint for the binning method to use when discretizing the
-   * interval domain. If unspecified, the default is `'floor'`.
-   */
-  bin?: BinMethod
-}
-
-/**
- * A selection clause representing filtering criteria
- * to apply within a Mosiac Selection.
- */
-export interface SelectionClause {
-  /**
-   * A unique identifier (according to object equality) for the source
-   * component that generated this clause. In many cases, this is a
-   * reference to the originating component itself.
-   */
-  source: any;
-  /**
-   * A set of Mosaic clients associated with this clause that should not
-   * be updated when this clause is applied in a cross-filtering context.
-   */
-  clients?: Set<MosaicClient>;
-  /**
-   * A selected value associated with this clause. For example, for a 1D
-   * interval selection clause the value may be a [lo, hi] array.
-   */
-  value: any;
-  /**
-   * A predicate SQL expression suitable for use in a query WHERE clause.
-   * The predicate should apply filtering criteria consistent with this
-   * clause's *value* property.
-   */
-  predicate: ExprNode | null;
-  /**
-   * Optional clause metadata that varies based on the selection type.
-   * The metadata can be used to optimize selection queries, for example
-   * by creating materialized views of pre-aggregated data when applicable.
-   */
-  meta?: ClauseMetadata;
-}

package/src/util/synchronizer.js

@@ -1,47 +0,0 @@
-/**
- * Create a new synchronizer instance to aid synchronization
- * of updates on multiple pending operations.
- */
-export function synchronizer() {
-  const set = new Set;
-  let done;
-  let promise = new Promise(resolve => done = resolve);
-
-  return {
-    /**
-     * Mark an item as pending.
-     * @param {*} item An item to synchronize on.
-     */
-    pending(item) {
-      set.add(item);
-    },
-    /**
-     * Mark a pending item as ready, indicating it is
-     * ready for a synchronized update.
-     * @param {*} item An item to synchronize on.
-     * @returns {boolean} True if the synchronizer is ready to
-     *  resolve, false otherwise.
-     */
-    ready(item) {
-      set.delete(item);
-      return set.size === 0;
-    },
-    /**
-     * Resolve the current synchronization cycle, causing the synchronize
-     * promise to resolve and thereby trigger downstream updates.
-     */
-    resolve() {
-      promise = new Promise(resolve => {
-        done();
-        done = resolve;
-      });
-    },
-    /**
-     * The promise for the current synchronization cycle.
-     * @return {Promise} The synchronization promise.
-     */
-    get promise() {
-      return promise;
-    }
-  }
-}

package/src/util/throttle.js

@@ -1,54 +0,0 @@
-const NIL = {};
-
-/**
- * Throttle invocations of a callback function. The callback must return
- * a Promise. Upon repeated invocation, the callback will not be invoked
- * until a prior Promise resolves. If multiple invocations occurs while
- * waiting, only the most recent invocation will be pending.
- * @template E, T
- * @param {(event: E) => Promise<T>} callback The callback function.
- * @param {boolean} [debounce=true] Flag indicating if invocations
- *  should also be debounced within the current animation frame.
- * @returns {(event: E) => void} A new function that throttles
- *  access to the callback.
- */
-export function throttle(callback, debounce = false) {
-  let curr;
-  let next;
-  let pending = NIL;
-
-  function invoke(event) {
-    curr = callback(event)
-      .catch(() => {})
-      .finally(() => {
-        if (next) {
-          const { value } = next;
-          next = null;
-          invoke(value);
-        } else {
-          curr = null;
-        }
-      });
-  }
-
-  function enqueue(event) {
-    next = { event };
-  }
-
-  function process(event) {
-    curr ? enqueue(event) : invoke(event);
-  }
-
-  function delay(event) {
-    if (pending !== event) {
-      requestAnimationFrame(() => {
-        const e = pending;
-        pending = NIL;
-        process(e);
-      });
-    }
-    pending = event;
-  }
-
-  return debounce ? delay : process;
-}

package/src/util/to-data-columns.js

@@ -1,60 +0,0 @@
-import { isArrowTable } from './is-arrow-table.js';
-
-/**
- * @typedef {Array | Int8Array | Uint8Array | Uint8ClampedArray
- *  | Int16Array | Uint16Array | Int32Array | Uint32Array
- *  | Float32Array | Float64Array
- * } Arrayish - an Array or TypedArray
- */
-
-/**
- * @typedef {
- *  | { numRows: number, columns: Record<string,Arrayish> }
- *  | { numRows: number, values: Arrayish; }
- * } DataColumns
-*/
-
-/**
- * Convert input data to a set of column arrays.
- * @param {any} data The input data.
- * @returns {DataColumns} An object with named column arrays.
- */
-export function toDataColumns(data) {
-  return isArrowTable(data)
-    ? arrowToColumns(data)
-    : arrayToColumns(data);
-}
-
-/**
- * Convert an Arrow table to a set of column arrays.
- * @param {import('@uwdata/flechette').Table} data An Arrow Table.
- * @returns {DataColumns} An object with named column arrays.
- */
-function arrowToColumns(data) {
-  const { numRows } = data;
-  return { numRows, columns: data.toColumns() };
-}
-
-/**
- * Convert an array of values to a set of column arrays.
- * If the array values are objects, build out named columns.
- * We use the keys of the first object as the column names.
- * Otherwise, use a special "values" array.
- * @param {object[]} data An array of data objects.
- * @returns {DataColumns} An object with named column arrays.
- */
-function arrayToColumns(data) {
-  const numRows = data.length;
-  if (typeof data[0] === 'object') {
-    const names = numRows ? Object.keys(data[0]) : [];
-    const columns = {};
-    if (names.length > 0) {
-      names.forEach(name => {
-        columns[name] = data.map(d => d[name]);
-      });
-    }
-    return { numRows, columns };
-  } else {
-    return { numRows, values: data };
-  }
-}

package/src/util/void-logger.js

@@ -1,13 +0,0 @@
-/* eslint-disable no-unused-vars */
-export function voidLogger() {
-  return {
-    debug(..._) {},
-    info(..._) {},
-    log(..._) {},
-    warn(..._) {},
-    error(..._) {},
-    group(label) {},
-    groupCollapsed(label) {},
-    groupEnd() {}
-  };
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "include": ["src/**/*"],
-  "compilerOptions": {
-    "emitDeclarationOnly": true,
-    "outDir": "dist"
-  },
-  "references": [{ "path": "../sql" }]
-}

package/vitest.config.ts

@@ -1,3 +0,0 @@
-import { defineConfig } from 'vite';
-
-export default defineConfig({});