@fjader/svelte 0.2.0 → 0.2.2

package/dist/query-engine/index.js

@@ -5,24 +5,33 @@
  *   import { setQueryContext } from './';
  *   setQueryContext(wasm.getConnection());  // Promise OK — resolves lazily
  *
- * Usage in spec renderer:
- *   context.set('query-engine', new QueryEngine(connection));
- *   context.set('filter-groups', new FilterGroupRegistry());
+ * Usage outside a component (the spec renderer), passing contexts to mount():
+ *   const { filterGroups } = createQueryServices(queryEngine);
+ *   context.set('query-engine', queryEngine);
+ *   context.set('filter-groups', filterGroups);
  */
 import { setContext, getContext } from 'svelte';
 import { QueryEngine } from './QueryEngine';
 import { FilterGroupRegistry } from './FilterGroupRegistry.svelte';
 import { tableSchemaService } from '../data/TableSchemaService.svelte';
+/**
+ * Create the FilterGroupRegistry for an engine and wire both to the schema
+ * service. Brushes and toggles reach the engine only through this wiring:
+ * a FilterGroup without an engine updates its selection but never re-queries.
+ */
+export function createQueryServices(queryEngine) {
+    const filterGroups = new FilterGroupRegistry();
+    filterGroups.setEngine(queryEngine);
+    tableSchemaService.setQueryEngine(queryEngine);
+    return { queryEngine, filterGroups };
+}
 /**
  * Create QueryEngine + FilterGroupRegistry and set Svelte contexts.
  * Call this synchronously in a component's <script> block.
  * Accepts a Promise<DuckDBConnection> — queries defer until it resolves.
  */
 export function setQueryContext(connection) {
-    const queryEngine = new QueryEngine(connection);
-    const filterGroups = new FilterGroupRegistry();
-    filterGroups.setEngine(queryEngine);
-    tableSchemaService.setQueryEngine(queryEngine);
+    const { queryEngine, filterGroups } = createQueryServices(new QueryEngine(connection));
     setContext('query-engine', queryEngine);
     setContext('filter-groups', filterGroups);
     return { queryEngine, filterGroups };

package/dist/spec/index.js

@@ -17,8 +17,7 @@
 import { mount, unmount } from 'svelte';
 import { ScaleRegistry } from '../scales/ScaleRegistry.svelte';
 import { GPUCoordinator } from '../gpu/GPUCoordinator.svelte';
-import { FilterGroupRegistry } from '../query-engine/FilterGroupRegistry.svelte';
-import { tableSchemaService } from '../data/TableSchemaService.svelte';
+import { createQueryServices } from '../query-engine';
 import { getOrCreateQueryEngine, loadData } from './LazyQueryEngine';
 import LayoutFromSpec from './LayoutFromSpec.svelte';
 /**
@@ -47,8 +46,7 @@ export async function render(target, spec, options = {}) {
     }
     // 4. Build context map — injected into Svelte mount() so child components
     //    find these via getContext() calls (same keys as initFjader())
-    const filterGroups = new FilterGroupRegistry();
-    tableSchemaService.setQueryEngine(queryEngine);
+    const { filterGroups } = createQueryServices(queryEngine);
     const context = new Map();
     context.set('query-engine', queryEngine);
     context.set('filter-groups', filterGroups);

package/dist/types.d.ts

@@ -338,12 +338,34 @@ export interface ChartContext {
     readonly fxDomain?: DimValue[] | null;
     readonly config: ChartConfig;
     onChartClick: ((event: PointerEvent) => void) | null;
-    onInteractorPointerDown: ((event: PointerEvent, innerPoint: Point) => boolean) | null;
+    /**
+     * A press, offered to the interactor before the chart pans. `target` is the
+     * element under the pointer, which a brush reads for the handle it is on
+     * (brushHandleAt); `innerPoint` is in plot-area coordinates. Returns true when
+     * the interactor takes the press. Called again when the chart re-routes a
+     * press under way (reroutePress).
+     */
+    onInteractorPointerDown: ((target: Element, pointerId: number, innerPoint: Point) => boolean) | null;
     /** Every pointer move but a pan; `innerPoint` is the pointer in plot-area coordinates (a
      *  shared buffer: read it before calling back into the layout). Returns true when the
      *  interactor handled the move (a drag it captured). */
     onInteractorPointerMove: ((event: PointerEvent, innerPoint: Point) => boolean) | null;
     onInteractorPointerUp: ((event: PointerEvent) => boolean) | null;
+    /**
+     * End the interactor's drag where it is, as a pointer up would but without
+     * treating a drag that never moved as a click (which clears a brush). The
+     * chart calls it when it re-routes the press.
+     */
+    onInteractorDragEnd: (() => void) | null;
+    /**
+     * Route the press under way again, as if it began now where the pointer is:
+     * end what it is doing (a pan, or the interactor's drag), then offer it to
+     * the interactor and pan if declined, as a new press would be. Brushes call
+     * it when Space changes, since one press can outlast that: with three-finger
+     * drag on a trackpad it goes on for seconds after the fingers lift. Without a
+     * press under way it does nothing.
+     */
+    reroutePress: () => void;
     /**
      * Selection sources to activate when the pointer enters the chart, so their
      * preagg tables exist before the first gesture. Interactors add their

package/package.json

@@ -18,7 +18,7 @@
 		"type": "git",
 		"url": "git+https://github.com/dlyngman/fjader.git"
 	},
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"type": "module",
 	"svelte": "./dist/index.js",
 	"exports": {