@malloydata/render 0.0.289 → 0.0.290

package/.storybook/malloy-stories-indexer.ts

@@ -140,9 +140,8 @@ export function viteMalloyStoriesPlugin(): PluginOption {
           : `
           import script from '${id}?raw';
           import {createLoader} from './util';
-          import {copyMalloyRenderHTML} from '../component/copy-to-html';
           import './themes.css';
-          import '../component/render-webcomponent';
+          import {MalloyRenderer} from '../api/malloy-renderer';
 
           const meta = {
             title: "Malloy Next/${modelStoriesMeta.componentName}",
@@ -150,24 +149,30 @@ export function viteMalloyStoriesPlugin(): PluginOption {
               const parent = document.createElement('div');
               parent.style.height = 'calc(100vh - 40px)';
               parent.style.position = 'relative';
-              const el = document.createElement('malloy-render');
-              if (classes) el.classList.add(classes);
-              el.malloyResult = context.loaded['result'];
-              el.tableConfig = {
-                enableDrill: true
-              };
-
-
-              el.onInitialState = (state) => {
-                console.log("Malloy render initial state", state);
-              };
 
               const button = document.createElement('button');
               button.innerHTML = "Copy HTML";
-              button.addEventListener("click", () => copyMalloyRenderHTML(el));
+              button.addEventListener("click", () => viz.copyToHTML());
+               parent.appendChild(button);
+
+              const targetElement = document.createElement('div');
+              if(classes) targetElement.classList.add(classes);
+              targetElement.style.height = '100%';
+              targetElement.style.width = '100%';
+              parent.appendChild(targetElement);
+
+              const renderer = new MalloyRenderer();
+              const viz = renderer.createViz({
+                // modelDef: context.loaded['result'].modelDef
+              }, {
+                onError: (error) => {
+                  console.log("Malloy render error", error);
+                }
+              });
+              viz.setResult(context.loaded['result']);
+              console.log('initial state', viz.getMetadata());
+              viz.render(targetElement);
 
-              parent.appendChild(button);
-              parent.appendChild(el);
               return parent;
             },
             loaders: [createLoader(script)],

package/API_MIGRATION.md

@@ -0,0 +1,189 @@
+# Malloy Render API Migration Guide
+
+## Overview
+
+This document describes the migration from the web component-based API to the new JavaScript API for `@malloydata/render`.
+
+## New JavaScript API
+
+### Basic Usage
+
+```javascript
+import {MalloyRenderer} from '@malloydata/render';
+
+// Set up a global renderer with options
+const renderer = new MalloyRenderer({
+  onClick: payload => console.log('Click:', payload),
+  onDrill: drillData => console.log('Drill:', drillData),
+  tableConfig: {
+    rowLimit: 1000,
+    shouldFillWidth: true,
+    enableDrill: true,
+  },
+});
+
+// Create a viz instance
+const viz = renderer.createViz();
+
+// Pass in data
+viz.setResult(malloyResult);
+
+// Get metadata about the query renderers
+viz.getMetadata();
+
+// Render to a DOM element
+const targetElement = document.getElementById('malloy_chart');
+viz.render(targetElement);
+
+// Update results and re-render into the same DOM node
+viz.setResult(nextMalloyResult);
+viz.render();
+
+// Remove from DOM element, dispose of component
+viz.remove();
+```
+
+### API Reference
+
+#### `MalloyRenderer`
+
+The main renderer class that manages global configuration.
+
+```typescript
+class MalloyRenderer {
+  constructor(options?: MalloyRendererOptions);
+  createViz(additionalOptions?: Partial<MalloyRendererOptions>): MalloyViz;
+  updateOptions(newOptions: Partial<MalloyRendererOptions>): void;
+  getOptions(): MalloyRendererOptions;
+}
+```
+
+#### `MalloyViz`
+
+Represents an individual visualization instance.
+
+```typescript
+class MalloyViz {
+  constructor(options: MalloyRendererOptions);
+  setResult(malloyResult: Malloy.Result): void;
+  render(targetElement?: HTMLElement): void;
+  remove(): void;
+  updateOptions(newOptions: Partial<MalloyRendererOptions>): void;
+  getMetadata(): RenderFieldMetadata | null;
+  getHTML(): Promise<string>;
+  copyToHTML(): Promise<void>;
+  static addStylesheet(styles: string): void;
+}
+```
+
+#### Types
+
+```typescript
+interface MalloyRendererOptions {
+  onClick?: (payload: MalloyClickEventPayload) => void;
+  onDrill?: (drillData: DrillData) => void;
+  onError?: (error: Error) => void;
+  vegaConfigOverride?: VegaConfigHandler;
+  tableConfig?: Partial<TableConfig>;
+  dashboardConfig?: Partial<DashboardConfig>;
+  modalElement?: HTMLElement;
+  scrollEl?: HTMLElement;
+}
+```
+
+## Migration from Web Component API
+
+### Before (Web Component)
+
+```html
+<malloy-render></malloy-render>
+
+<script>
+  const element = document.querySelector('malloy-render');
+  element.malloyResult = result;
+  element.onClick = payload => console.log(payload);
+</script>
+```
+
+### After (JavaScript API)
+
+```javascript
+import {MalloyRenderer} from '@malloydata/render';
+
+const renderer = new MalloyRenderer(globalRenderOptions);
+
+const viz = renderer.createViz(vizRenderOptions);
+viz.setResult(result);
+viz.render(document.querySelector('#my-container'));
+```
+
+## CSS Changes
+
+### Before (Shadow DOM)
+
+CSS was injected into shadow root using special methods:
+
+```javascript
+// Old approach - no longer needed
+config.addCSSToShadowRoot(css);
+```
+
+### After (Native DOM)
+
+Components now import CSS naturally:
+
+```javascript
+// New approach
+import './component.css';
+```
+
+CSS selectors that used `:host` are now scoped to the container ".malloy-render":
+
+```css
+/* Before */
+:host {
+  font-family: var(--malloy-render--font-family);
+}
+
+/* After - automatically scoped */
+.malloy-render {
+  font-family: var(--malloy-render--font-family);
+}
+```
+
+The renderer will continue to expose CSS variables for customizing the theme, but optionally you can add your own CSS to target internals. The latter is not recommended as internals will change over time.
+
+## Breaking Changes
+
+1. **Web Component Removed**: The `<malloy-render>` web component is no longer available
+2. **CSS Handling**: No ShadowRoot boundaries around CSS
+3. **Import Changes**: New imports for the JavaScript API
+4. **DOM Structure**: Renders directly into provided element instead of shadow root
+5. **HTML Export**: New methods `getHTML()` and `copyToHTML()` for exporting visualizations
+
+## Backward Compatibility
+
+The old exports are still available for existing code:
+
+```javascript
+// Legacy exports still work
+import {HTMLView, JSONView, getDataTree} from '@malloydata/render';
+```
+
+## Implementation Details
+
+### Under the Hood
+
+- Uses SolidJS components for rendering
+- Uses `solid-js/web` `render()` function to mount to DOM
+- CSS is injected into document head with `data-malloy-viz` attribute
+- No web component infrastructure required
+- Supports HTML export functionality for copying visualizations
+
+## Migration Steps
+
+1. **Replace web component usage** with JavaScript API
+2. **Update imports** to use new API classes
+3. **Update CSS handling** if you were using custom styles
+4. **Test thoroughly** - behavior should be identical but integration is different
+5. **Update HTML export** if you were using the old export methods

package/dist/api/malloy-renderer.d.ts

@@ -0,0 +1,9 @@
+import type { MalloyRendererOptions } from './types';
+import { MalloyViz } from './malloy-viz';
+export declare class MalloyRenderer {
+    private globalOptions;
+    constructor(options?: MalloyRendererOptions);
+    createViz(additionalOptions?: Partial<MalloyRendererOptions>): MalloyViz;
+    updateOptions(newOptions: Partial<MalloyRendererOptions>): void;
+    getOptions(): MalloyRendererOptions;
+}

package/dist/api/malloy-viz.d.ts

@@ -0,0 +1,19 @@
+import type { MalloyRendererOptions } from '@/api/types';
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import { RenderFieldMetadata } from '@/render-field-metadata';
+export declare class MalloyViz {
+    private options;
+    private disposeFn;
+    private targetElement;
+    private result;
+    private metadata;
+    constructor(options: MalloyRendererOptions);
+    static addStylesheet(styles: string): void;
+    getHTML(): Promise<string>;
+    copyToHTML(): Promise<void>;
+    setResult(malloyResult: Malloy.Result): void;
+    render(targetElement?: HTMLElement): void;
+    remove(): void;
+    updateOptions(newOptions: Partial<MalloyRendererOptions>): void;
+    getMetadata(): RenderFieldMetadata | null;
+}

package/dist/api/types.d.ts

@@ -0,0 +1,12 @@
+import type { DashboardConfig, DrillData, MalloyClickEventPayload, TableConfig, VegaConfigHandler } from '../component/types';
+export type { RenderFieldMetadata } from '@/render-field-metadata';
+export interface MalloyRendererOptions {
+    onClick?: (payload: MalloyClickEventPayload) => void;
+    onDrill?: (drillData: DrillData) => void;
+    vegaConfigOverride?: VegaConfigHandler;
+    tableConfig?: Partial<TableConfig>;
+    dashboardConfig?: Partial<DashboardConfig>;
+    modalElement?: HTMLElement;
+    scrollEl?: HTMLElement;
+    onError?: (error: Error) => void;
+}

package/dist/component/dashboard/dashboard.d.ts

@@ -1,4 +1,4 @@
-import type { RecordOrRepeatedRecordCell } from '../../data_tree';
+import type { RecordOrRepeatedRecordCell } from '@/data_tree';
 export declare function Dashboard(props: {
     data: RecordOrRepeatedRecordCell;
     scrollEl?: HTMLElement;

package/dist/component/malloy-modal/malloy-modal.d.ts

@@ -4,10 +4,3 @@ export declare function MalloyModal(props: {
     children?: JSXElement;
     ref?: HTMLDivElement | ((el: HTMLDivElement) => void);
 }): JSX.Element;
-declare module 'solid-js' {
-    namespace JSX {
-        interface IntrinsicElements {
-            'malloy-modal': any;
-        }
-    }
-}

package/dist/component/render-result-metadata.d.ts

@@ -1,8 +1,8 @@
 import type { Tag } from '@malloydata/malloy-tag';
 import type { VegaChartProps, VegaConfigHandler } from './types';
-import type { ResultStore } from './result-store/result-store';
+import type { ResultStore } from '@/component/result-store/result-store';
 import type { Runtime } from 'vega';
-import { type RootCell } from '../data_tree';
+import type { RootField } from '@/data_tree';
 export type GetResultMetadataOptions = {
     getVegaConfigOverride?: VegaConfigHandler;
     parentSize: {
@@ -18,7 +18,7 @@ export interface FieldVegaInfo {
 export interface RenderMetadata {
     store: ResultStore;
     vega: Record<string, FieldVegaInfo>;
-    root: RootCell;
+    rootField: RootField;
     parentSize: {
         width: number;
         height: number;
@@ -26,5 +26,5 @@ export interface RenderMetadata {
     renderAs: string;
     sizingStrategy: 'fill' | 'fixed';
 }
-export declare function getResultMetadata(root: RootCell, options?: GetResultMetadataOptions): RenderMetadata;
+export declare function getResultMetadata(rootField: RootField, options?: GetResultMetadataOptions): RenderMetadata;
 export declare function shouldRenderChartAs(tag: Tag): string | undefined;

package/dist/component/render.d.ts

@@ -1,49 +1,31 @@
 import type { Accessor } from 'solid-js';
-import './render.css';
-import type { ComponentOptions, ICustomElement } from 'component-register';
 import type { DashboardConfig, DrillData, MalloyClickEventPayload, TableConfig, VegaConfigHandler } from './types';
 export type { DrillData } from './types';
 import type * as Malloy from '@malloydata/malloy-interfaces';
-import type { ModelDef, QueryResult } from '@malloydata/malloy';
-import { Result } from '@malloydata/malloy';
 export type MalloyRenderProps = {
-    malloyResult?: Malloy.Result;
-    result?: Result;
-    queryResult?: QueryResult;
-    modelDef?: ModelDef;
+    result?: Malloy.Result;
+    element: HTMLElement;
     scrollEl?: HTMLElement;
     modalElement?: HTMLElement;
     onClick?: (payload: MalloyClickEventPayload) => void;
     onDrill?: (drillData: DrillData) => void;
+    onError?: (error: Error) => void;
     vegaConfigOverride?: VegaConfigHandler;
     tableConfig?: Partial<TableConfig>;
     dashboardConfig?: Partial<DashboardConfig>;
 };
-type MalloyRenderApiState = {
-    sizingStrategy: 'fill' | 'fixed';
-    renderAs: string;
-};
-export type MalloyRenderApi = {
-    onInitialState?: (state: MalloyRenderApiState) => void;
-    __experimental: MalloyRenderApiState;
-};
-export type MalloyCustomElement = HTMLElement & ICustomElement & MalloyRenderProps & MalloyRenderApi;
 export declare const useConfig: () => {
     tableConfig: Accessor<TableConfig>;
     dashboardConfig: Accessor<DashboardConfig>;
-    element: MalloyCustomElement;
-    stylesheet: CSSStyleSheet;
-    addCSSToShadowRoot: (css: string) => void;
-    addCSSToDocument: (id: string, css: string) => void;
     onClick?: (payload: MalloyClickEventPayload) => void;
     onDrill?: (drillData: DrillData) => void;
     vegaConfigOverride?: VegaConfigHandler;
     modalElement?: HTMLElement;
 };
-export declare function MalloyRender(props: MalloyRenderProps, { element }: ComponentOptions): import("solid-js").JSX.Element;
+export declare function MalloyRender(props: MalloyRenderProps): import("solid-js").JSX.Element;
 export declare function MalloyRenderInner(props: {
     result: Malloy.Result;
-    element: MalloyCustomElement;
+    element: HTMLElement;
     scrollEl?: HTMLElement;
     vegaConfigOverride?: VegaConfigHandler;
 }): import("solid-js").JSX.Element;

package/dist/component/util.d.ts

@@ -1,5 +1,17 @@
+import { type Accessor, type Setter } from 'solid-js';
 export declare function getTextWidthCanvas(text: string, font: string, canvasToUse?: HTMLCanvasElement): number;
 export declare function getTextWidthDOM(text: string, styles: Record<string, string>): number;
 export declare function clamp(s: number, e: number, v: number): number;
 export declare function getRangeSize(range: [number, number]): number;
-export declare function createRAFSignal<T>(initialValue: T): readonly [import("solid-js").Accessor<T>, (value: Exclude<T, Function> | ((prev: T) => T)) => void];
+export declare function createRAFSignal<T>(initialValue: T): readonly [Accessor<T>, (this: unknown, value: Exclude<T, Function> | ((prev: T) => T)) => void];
+export type ResizeDirectiveValue = [
+    Accessor<{
+        width: number;
+        height: number;
+    }>,
+    Setter<{
+        width: number;
+        height: number;
+    }>
+];
+export declare function resize(el: HTMLElement, value: Accessor<ResizeDirectiveValue>): void;

package/dist/data_tree/cells/atomic.d.ts

@@ -0,0 +1,75 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import type { BooleanField, DateField, Field, JSONField, NumberField, SQLNativeField, StringField, TimestampField } from '../fields';
+import { CellBase } from './base';
+import type { Cell, NestCell } from '.';
+export declare class NullCell extends CellBase {
+    readonly cell: Malloy.CellWithNullCell;
+    readonly field: Field;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithNullCell, field: Field, parent: NestCell | undefined);
+    get value(): null;
+    get literalValue(): Malloy.LiteralValue | undefined;
+}
+export declare class NumberCell extends CellBase {
+    readonly cell: Malloy.CellWithNumberCell;
+    readonly field: NumberField;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithNumberCell, field: NumberField, parent: NestCell | undefined);
+    get value(): number;
+    compareTo(other: Cell): 1 | 0 | -1;
+    get literalValue(): Malloy.LiteralValue | undefined;
+}
+export declare class DateCell extends CellBase {
+    readonly cell: Malloy.CellWithDateCell;
+    readonly field: DateField;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithDateCell, field: DateField, parent: NestCell | undefined);
+    get value(): Date;
+    get timeframe(): Malloy.DateTimeframe | undefined;
+    compareTo(other: Cell): 1 | 0 | -1;
+    get literalValue(): Malloy.LiteralValue | undefined;
+}
+export declare class TimestampCell extends CellBase {
+    readonly cell: Malloy.CellWithTimestampCell;
+    readonly field: TimestampField;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithTimestampCell, field: TimestampField, parent: NestCell | undefined);
+    get value(): Date;
+    get timeframe(): Malloy.TimestampTimeframe | undefined;
+    compareTo(other: Cell): 1 | 0 | -1;
+    get literalValue(): Malloy.LiteralValue | undefined;
+}
+export declare class JSONCell extends CellBase {
+    readonly cell: Malloy.CellWithJSONCell;
+    readonly field: JSONField;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithJSONCell, field: JSONField, parent: NestCell | undefined);
+    get value(): any;
+    compareTo(other: Cell): 1 | 0 | -1;
+}
+export declare class SQLNativeCell extends CellBase {
+    readonly cell: Malloy.CellWithSQLNativeCell;
+    readonly field: SQLNativeField;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithSQLNativeCell, field: SQLNativeField, parent: NestCell | undefined);
+    get value(): any;
+    compareTo(other: Cell): 1 | 0 | -1;
+}
+export declare class StringCell extends CellBase {
+    readonly cell: Malloy.CellWithStringCell;
+    readonly field: StringField;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithStringCell, field: StringField, parent: NestCell | undefined);
+    get value(): string;
+    compareTo(other: Cell): number;
+    get literalValue(): Malloy.LiteralValue | undefined;
+}
+export declare class BooleanCell extends CellBase {
+    readonly cell: Malloy.CellWithBooleanCell;
+    readonly field: BooleanField;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.CellWithBooleanCell, field: BooleanField, parent: NestCell | undefined);
+    get value(): boolean;
+    compareTo(other: Cell): 1 | 0 | -1;
+    get literalValue(): Malloy.LiteralValue | undefined;
+}

package/dist/data_tree/cells/base.d.ts

@@ -0,0 +1,41 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import type { Cell, NestCell, RecordCell } from '.';
+import type { Field } from '../fields';
+import { ArrayCell, BooleanCell, DateCell, JSONCell, NullCell, NumberCell, RepeatedRecordCell, StringCell, TimestampCell, type TimeCell, type RecordOrRepeatedRecordCell, type CellValue } from '.';
+import type { DrillEntry } from '../types';
+export declare abstract class CellBase {
+    readonly cell: Malloy.Cell;
+    readonly field: Field;
+    readonly parent: NestCell | undefined;
+    constructor(cell: Malloy.Cell, field: Field, parent: NestCell | undefined);
+    get literalValue(): Malloy.LiteralValue | undefined;
+    abstract get value(): CellValue;
+    isNull(): this is NullCell;
+    isArray(): this is ArrayCell;
+    isRecord(): this is RecordCell;
+    isRepeatedRecord(): this is RepeatedRecordCell;
+    isRecordOrRepeatedRecord(): this is RecordOrRepeatedRecordCell;
+    isNest(): this is NestCell;
+    isNumber(): this is NumberCell;
+    isDate(): this is DateCell;
+    isTime(): this is TimeCell;
+    isJSON(): this is JSONCell;
+    isString(): this is StringCell;
+    isTimestamp(): this is TimestampCell;
+    isBoolean(): this is BooleanCell;
+    asCell(): Cell;
+    root(): Cell;
+    private getPathInfo;
+    getParentRecord(levelsUp: number): RecordCell;
+    getRelativeCell(relativeDataPath: string): Cell | undefined;
+    cellAt(path: string[] | string): Cell;
+    cellAtPath(path: string[]): Cell;
+    compareTo(_other: Cell): number;
+    canDrill(): boolean;
+    getStableDrillQuery(): Malloy.Query | undefined;
+    getStableDrillClauses(): Malloy.DrillOperation[] | undefined;
+    getDrillExpressions(): string[];
+    getDrillEntries(): DrillEntry[];
+    getStableDrillQueryMalloy(): string | undefined;
+    getDrillQueryMalloy(): string;
+}

package/dist/data_tree/cells/index.d.ts

@@ -0,0 +1,14 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import { type Field } from '../fields';
+import { ArrayCell, RecordCell, RepeatedRecordCell } from './nest';
+import { BooleanCell, DateCell, JSONCell, NullCell, NumberCell, SQLNativeCell, StringCell, TimestampCell } from './atomic';
+export { ArrayCell, RecordCell, RepeatedRecordCell, RootCell } from './nest';
+export { BooleanCell, DateCell, JSONCell, NullCell, NumberCell, SQLNativeCell, StringCell, TimestampCell, } from './atomic';
+export type NestCell = ArrayCell | RecordCell;
+export type RecordOrRepeatedRecordCell = RepeatedRecordCell | RecordCell;
+export type TimeCell = DateCell | TimestampCell;
+export type Cell = ArrayCell | RecordCell | NullCell | NumberCell | DateCell | JSONCell | StringCell | TimestampCell | BooleanCell | SQLNativeCell;
+export type CellValue = string | number | boolean | Date | Cell[] | Record<string, Cell> | null;
+export declare const Cell: {
+    from(cell: Malloy.Cell, field: Field, parent: NestCell): Cell;
+};

package/dist/data_tree/cells/nest.d.ts

@@ -0,0 +1,44 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import type { ArrayField, RecordField, RepeatedRecordField, RootField } from '../fields';
+import type { RenderPlugin } from '../plugins';
+import type { FieldRegistry } from '../types';
+import { Cell, type CellValue } from '.';
+import { CellBase } from './base';
+import type { NestCell } from '.';
+export declare class ArrayCell extends CellBase {
+    readonly cell: Malloy.CellWithArrayCell;
+    readonly field: ArrayField;
+    readonly parent: NestCell | undefined;
+    readonly values: Cell[];
+    constructor(cell: Malloy.CellWithArrayCell, field: ArrayField, parent: NestCell | undefined);
+    get value(): Cell[];
+}
+export declare class RepeatedRecordCell extends ArrayCell {
+    readonly cell: Malloy.CellWithArrayCell;
+    readonly field: RepeatedRecordField;
+    readonly parent: NestCell | undefined;
+    readonly rows: RecordCell[];
+    readonly fieldValueSets: Map<string, Set<CellValue>>;
+    private plugins;
+    private registry?;
+    constructor(cell: Malloy.CellWithArrayCell, field: RepeatedRecordField, parent: NestCell | undefined, plugins?: RenderPlugin[], registry?: FieldRegistry);
+    get value(): RecordCell[];
+}
+export declare class RootCell extends RepeatedRecordCell {
+    readonly cell: Malloy.CellWithArrayCell;
+    readonly field: RootField;
+    constructor(cell: Malloy.CellWithArrayCell, field: RootField, plugins?: RenderPlugin[], registry?: FieldRegistry);
+}
+export declare class RecordCell extends CellBase {
+    readonly cell: Malloy.CellWithRecordCell;
+    readonly field: RecordField;
+    readonly parent: NestCell | undefined;
+    readonly cells: Record<string, Cell>;
+    constructor(cell: Malloy.CellWithRecordCell, field: RecordField, parent: NestCell | undefined);
+    get rows(): RecordCell[];
+    get value(): Record<string, Cell>;
+    column(name: string): Cell;
+    get columns(): Cell[];
+    allCellValues(): Record<string, CellValue>;
+    cellAtPath(path: string[]): Cell;
+}

package/dist/data_tree/drilling.d.ts

@@ -0,0 +1,11 @@
+import * as Malloy from '@malloydata/malloy-interfaces';
+import type { Cell } from './cells';
+import type { DrillEntry, DrillValue } from './types';
+export declare function canDrill(cell: Cell): boolean;
+export declare function getStableDrillQuery(cell: Cell): Malloy.Query | undefined;
+export declare function getStableDrillClauses(cell: Cell): Malloy.DrillOperation[] | undefined;
+export declare function getDrillValues(cell: Cell): DrillValue[];
+export declare function getDrillExpressions(cell: Cell): string[];
+export declare function getDrillEntries(cell: Cell): DrillEntry[];
+export declare function getStableDrillQueryMalloy(cell: Cell): string | undefined;
+export declare function getDrillQueryMalloy(cell: Cell): string;

package/dist/data_tree/fields/atomic.d.ts

@@ -0,0 +1,67 @@
+import type { NestField } from '.';
+import type { BooleanFieldInfo, DateFieldInfo, FieldRegistry, JSONFieldInfo, NumberFieldInfo, SQLNativeFieldInfo, StringFieldInfo, TimestampFieldInfo } from '../types';
+import { FieldBase } from './base';
+export declare class NumberField extends FieldBase {
+    readonly field: NumberFieldInfo;
+    min: number | undefined;
+    max: number | undefined;
+    private _maxString;
+    constructor(field: NumberFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    registerValue(value: number): void;
+    fieldAtPath(path: string[]): import(".").Field;
+    get minNumber(): number | undefined;
+    get maxNumber(): number | undefined;
+    get maxString(): string | undefined;
+}
+export declare class DateField extends FieldBase {
+    readonly field: DateFieldInfo;
+    min: Date | undefined;
+    max: Date | undefined;
+    private _maxString;
+    constructor(field: DateFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    get timeframe(): import("@malloydata/malloy-interfaces").DateTimeframe | undefined;
+    registerValue(value: Date): void;
+    get minValue(): Date | undefined;
+    get maxValue(): Date | undefined;
+    get maxString(): string | undefined;
+    get minNumber(): number | undefined;
+    get maxNumber(): number | undefined;
+}
+export declare class TimestampField extends FieldBase {
+    readonly field: TimestampFieldInfo;
+    min: Date | undefined;
+    max: Date | undefined;
+    private _maxString;
+    constructor(field: TimestampFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    get timeframe(): import("@malloydata/malloy-interfaces").TimestampTimeframe | undefined;
+    registerValue(value: Date): void;
+    get minValue(): Date | undefined;
+    get maxValue(): Date | undefined;
+    get maxString(): string | undefined;
+}
+export declare class StringField extends FieldBase {
+    readonly field: StringFieldInfo;
+    min: string | undefined;
+    max: string | undefined;
+    private _maxString;
+    constructor(field: StringFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    registerValue(value: string): void;
+    get minValue(): string | undefined;
+    get maxValue(): string | undefined;
+    get maxString(): string | undefined;
+}
+export declare class SQLNativeField extends FieldBase {
+    readonly field: SQLNativeFieldInfo;
+    constructor(field: SQLNativeFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+}
+export declare class JSONField extends FieldBase {
+    readonly field: JSONFieldInfo;
+    constructor(field: JSONFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+}
+export declare class BooleanField extends FieldBase {
+    readonly field: BooleanFieldInfo;
+    private _maxString;
+    constructor(field: BooleanFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    get maxString(): string | undefined;
+    registerValue(value: boolean): void;
+}