feat: Add publish package

packages/core/src/Coordinator.js

@@ -3,11 +3,13 @@
 /** @import { QueryResult } from './util/query-result.js' */
 /** @import { SelectionClause } from './util/selection-types.js' */
 /** @import { MosaicClient } from './MosaicClient.js' */
+/** @import { ClauseSource } from './util/selection-types.js' */
 /** @import { Selection } from './Selection.js' */
 /** @import { Logger, QueryType } from './types.js' */
 import { socketConnector } from './connectors/socket.js';
 import { PreAggregator } from './preagg/PreAggregator.js';
 import { voidLogger } from './util/void-logger.js';
+import { isClauseSource } from './util/is-clause-source.js';
 import { QueryManager, Priority } from './QueryManager.js';
 
 /**
@@ -75,6 +77,7 @@ export class Coordinator {
       this.filterGroups = new Map;
       this.clients?.forEach(client => this.disconnect(client));
       this.clients = new Set;
+      this.clauseSources = new Set;
     }
     if (cache) this.manager.cache().clear();
   }
@@ -222,6 +225,22 @@ export class Coordinator {
       : Promise.resolve(client.update());
   }
 
+  /**
+   * Register a clause source with the coordinator.
+   * @param {ClauseSource} clauseSource The clause source to register.
+   */
+  connectClauseSource(clauseSource) {
+    this.clauseSources.add(clauseSource);
+  }
+
+  /**
+   * Deregister a clause source from the coordinator.
+   * @param {ClauseSource} clauseSource The clause source to deregister.
+   */
+  disconnectClauseSource(clauseSource) {
+    this.clauseSources.delete(clauseSource);
+  }
+
   /**
    * Connect a client to the coordinator.
    * @param {MosaicClient} client The Mosaic client to connect.
@@ -244,6 +263,11 @@ export class Coordinator {
 
     // connect filter selection
     connectSelection(this, client.filterBy, client);
+
+    // Connect this client as a clause source if necessary
+    if (isClauseSource(client)) {
+      this.connectClauseSource(client);
+    }
   }
 
   /**
@@ -256,6 +280,11 @@ export class Coordinator {
     clients.delete(client);
     client.coordinator = null;
 
+    // Remove direct clause sources
+    if (isClauseSource(client)) {
+      this.disconnectClauseSource(client);
+    }
+
     const group = filterGroups.get(client.filterBy);
     if (group) {
       group.clients.delete(client);

packages/core/src/QueryManager.js

@@ -115,8 +115,8 @@ export class QueryManager {
 
   /**
    * Get or set the current query cache.
-   * @param {Cache | boolean} [value]
-   * @returns {Cache}
+   * @param {Cache | boolean} [value] The cache instance or `true` to create an LRU cache.
+   * @returns {Cache} The cache instance.
    */
   cache(value) {
     return value !== undefined

packages/core/src/index.js

@@ -25,4 +25,4 @@ 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 { isClauseSource } from './util/is-clause-source.js';

packages/core/src/types.ts

@@ -53,23 +53,20 @@ export interface ColumnDescription {
   null: 'YES' | 'NO'
 }
 
-/**
- * Interface for components that perform selection activation.
- */
-export interface Activatable {
-  /**
-   * Activate the selection that this component publishes to.
-   */
-  activate(): void;
-}
-
 /**
  * Interface for cache implementations.
  */
 export interface Cache {
+  /** Retrieves a value from the cache. */
   get(key: string): any;
+  /** Stores a value in the cache and returns it. */
   set(key: string, value: any): any;
+  /** Clears all entries in the cache. */
   clear(): void;
+  /** Exports the cache as a Map where keys are strings and values are Arrow IPC binary format (Uint8Array), or null if the cache is empty. */
+  export(): Map<string, Uint8Array> | null;
+  /** Imports the cache from a Map where keys are strings and values are Arrow IPC binary format (Uint8Array). */
+  import(data: Map<string, Uint8Array>): void;
 }
 
 /**

packages/core/src/util/cache.js

@@ -1,31 +1,35 @@
 /** @import { Cache } from '../types.js' */
+import { tableToIPC } from "@uwdata/flechette";
+import { decodeIPC } from "./decode-ipc.js";
 
 const requestIdle = typeof requestIdleCallback !== 'undefined'
   ? requestIdleCallback
   : setTimeout;
 
 /**
  * Create a new cache that ignores all values.
- * @returns {Cache}
+ * @returns {Cache} A void cache that doesn't store or retrieve values.
  */
 export function voidCache() {
   return {
     get: () => undefined,
     set: (key, value) => value,
-    clear: () => {}
+    clear: () => {},
+    export: () => null,
+    import: () => {}
   };
 }
 
 /**
  * Create a new cache that uses an LRU eviction policy.
  * @param {object} [options] Cache options.
- * @param {number} [options.max] Maximum number of cache entries.
- * @param {number} [options.ttl] Time-to-live for cache entries.
- * @returns {Cache}
+ * @param {number} [options.max=1000] Maximum number of cache entries.
+ * @param {number} [options.ttl=10800000] Time-to-live for cache entries in ms (default: 3 hours).
+ * @returns {Cache} An LRU cache instance.
  */
 export function lruCache({
-  max = 1000, // max entries
-  ttl = 3 * 60 * 60 * 1000 // time-to-live, default 3 hours
+  max = 1000,
+  ttl = 3 * 60 * 60 * 1000
 } = {}) {
   let cache = new Map;
 
@@ -55,19 +59,31 @@ export function lruCache({
     }
   }
 
+  function get(key) {
+    const entry = cache.get(key);
+    if (entry) {
+      entry.last = performance.now();
+      return entry.value;
+    }
+  }
+
+  function set(key, value) {
+    cache.set(key, { last: performance.now(), value });
+    if (cache.size > max) requestIdle(evict);
+    return value;
+  }
+
   return {
-    get(key) {
-      const entry = cache.get(key);
-      if (entry) {
-        entry.last = performance.now();
-        return entry.value;
-      }
-    },
-    set(key, value) {
-      cache.set(key, { last: performance.now(), value });
-      if (cache.size > max) requestIdle(evict);
-      return value;
+    get,
+    set,
+    clear() { cache = new Map; },
+    export() {
+      return new Map(Array.from(cache).map(([key, entry]) => [key, tableToIPC(entry.value, {})]));
     },
-    clear() { cache = new Map; }
+    import(data) {
+      for (const [key, entry] of data) {
+        set(key, decodeIPC(entry));
+      }
+    }
   };
 }

packages/core/src/util/is-clause-source.js

@@ -0,0 +1,12 @@
+/**
+ * Test if a value implements the ClauseSource interface.
+ * @param {*} value The value to test.
+ * @returns {value is import('./selection-types.js').ClauseSource}
+ */
+export function isClauseSource(value) {
+  return typeof value?.activate === 'function' && // Activate exists
+    value.activate.length === 0 && // No arguments
+    typeof value?.reset === 'function' && // Reset exists
+    value.reset.length === 0 && // No arguments
+    typeof value?.clause === 'function'; // Clause exists
+}

packages/core/src/util/selection-types.ts

@@ -135,3 +135,29 @@ export interface SelectionClause {
    */
   meta?: ClauseMetadata;
 }
+
+/**
+ * Interface for components that perform selection activation.
+ */
+export interface ClauseSource {
+  /**
+   * Activate the selection that this component publishes to.
+   * Optionally, no-op
+   */
+  activate: () => void;
+
+  /**
+   * Reset this component and respective selection(s) removing all published clauses.
+   * Optionally, no-op
+   */
+  reset: () => void;
+
+
+  /**
+   * Get the selection clause that this component publishes.
+   * Note: this function **must** be callable with no arguments
+   * 
+   * @param {...unknown} args - Any number of arguments that may be needed to construct the clause.
+   */
+  clause: (...args: unknown[]) => SelectionClause;
+}

packages/inputs/src/Menu.js

@@ -149,22 +149,25 @@ export class Menu extends Input {
     }
   }
 
+  clause(value) {
+    return clausePoint(this.field, value ?? 0, { source: this });
+  }
+
   reset() {
     this.select.selectedIndex = this.from ? 0 : -1;
   }
 
   activate() {
     if (isSelection(this.selection)) {
-      this.selection.activate(clausePoint(this.field, 0, { source: this }));
+      this.selection.activate(this.clause());
     }
   }
 
   publish(value) {
-    const { selection, field } = this;
+    const { selection } = this;
     if (isSelection(selection)) {
       if (value === '') value = undefined; // 'All' option
-      const clause = clausePoint(field, value, { source: this });
-      selection.update(clause);
+      selection.update(this.clause(value));
     } else if (isParam(selection)) {
       selection.update(value);
     }

packages/inputs/src/Slider.js

@@ -196,6 +196,8 @@ export class Slider extends Input {
     }
   }
 
+  reset() { /* No-op */ }
+
   activate() {
     if (isSelection(this.selection)) {
       this.selection.activate(this.clause(0));

packages/inputs/src/Table.js

@@ -275,6 +275,10 @@ export class Table extends Input {
     }
   }
 
+  reset() {
+    this.currentRow = -1;
+  }
+
   sort(event, column) {
     if (column === this.sortColumn) {
       this.sortDesc = !this.sortDesc;

packages/inputs/src/input.js

@@ -16,8 +16,8 @@ export function input(InputClass, ...params) {
 
 /**
  * Base class for input components.
- * @import {Activatable} from '@uwdata/mosaic-core'
- * @implements {Activatable}
+ * @import {ClauseSource} from '@uwdata/mosaic-core'
+ * @implements {ClauseSource}
  */
 export class Input extends MosaicClient {
   /**
@@ -37,4 +37,13 @@ export class Input extends MosaicClient {
   activate() {
     // subclasses should override
   }
+
+  reset() {
+    // subclasses should override
+  }
+
+  clause() {
+    // subclasses should override
+    return null;
+  }
 }

packages/inputs/tsconfig.json

@@ -6,6 +6,7 @@
     "emitDeclarationOnly": true,
     "outDir": "dist/types",
     "module": "node16",
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "strictFunctionTypes": true
   }
 }

packages/plot/src/interactors/Interval1D.js

@@ -7,8 +7,8 @@ import { invert } from './util/invert.js';
 import { sanitizeStyles } from './util/sanitize-styles.js';
 
 /**
- * @import {Activatable} from '@uwdata/mosaic-core'
- * @implements {Activatable}
+ * @import {ClauseSource} from '@uwdata/mosaic-core'
+ * @implements {ClauseSource}
  */
 export class Interval1D {
   constructor(mark, {
@@ -28,6 +28,9 @@ export class Interval1D {
     this.style = style && sanitizeStyles(style);
     this.brush = channel === 'y' ? brushY() : brushX();
     this.brush.on('brush end', ({ selection }) => this.publish(selection));
+
+    // Register with coordinator
+    mark.coordinator?.connectClauseSource(this);
   }
 
   reset() {
@@ -36,7 +39,7 @@ export class Interval1D {
   }
 
   activate() {
-    this.selection.activate(this.clause(this.value || [0, 1]));
+    this.selection.activate(this.clause());
   }
 
   publish(extent) {
@@ -55,7 +58,9 @@ export class Interval1D {
 
   clause(value) {
     const { mark, pixelSize, field, scale } = this;
-    return clauseInterval(field, value, {
+    const clauseValue = value || this.value || [0, 1];
+
+    return clauseInterval(field, clauseValue, {
       source: this,
       clients: this.peers ? mark.plot.markSet : new Set().add(mark),
       scale,