buckaroo-js-core 0.8.4 → 0.11.7

package/dist/src/components/DFViewerParts/RowStoreGc.d.ts

@@ -0,0 +1,22 @@
+import { RowStore } from './RowStore';
+import { View } from './Views';
+export interface ActiveWindow {
+    view: View;
+    start: number;
+    end: number;
+}
+export interface PinSpec {
+    views: View[];
+    headSize: number;
+    tailSize: number;
+}
+/**
+ * Visibility-aware GC. For each active window, expand the position
+ * range by `padding`, map through the window's view to get rowids,
+ * union the lot. If `pin` is provided, also union in the first
+ * `headSize` and last `tailSize` rowids of every pinned view.
+ * Everything else is dropped.
+ *
+ * Empty active-window list + no pin spec drops everything.
+ */
+export declare function gcRowStore(rowStore: RowStore, activeWindows: ActiveWindow[], padding: number, pin?: PinSpec): void;

package/dist/src/components/DFViewerParts/RowStoreGc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/DFViewerParts/SeriesSummaryTooltip.d.ts

@@ -0,0 +1,13 @@
+import { DFWhole, TooltipConfig } from './DFWhole';
+import { ITooltipParams } from 'ag-grid-community';
+export declare function getBakedDFViewer(seriesDf: DFWhole): (_props: ITooltipParams) => import("react/jsx-runtime").JSX.Element;
+export declare const getSimpleTooltip: (tooltipField: string) => (props: ITooltipParams) => import("react/jsx-runtime").JSX.Element | undefined;
+interface RealTooltipParams {
+    tooltipField: string;
+    tooltipComponent: (props: ITooltipParams) => React.Component;
+}
+interface EmptyTooltipParams {
+}
+export type CDTooltipParams = RealTooltipParams | EmptyTooltipParams;
+export declare const getTooltipParams: (tooltip_config?: TooltipConfig) => CDTooltipParams;
+export {};

package/dist/src/components/DFViewerParts/SmartRowCache.d.ts

@@ -0,0 +1,83 @@
+import { DFData } from './DFWhole';
+export interface RowRequest {
+    start: number;
+    end: number;
+}
+export type Segment = [number, number];
+export type RequestArgs = RowRequest | true;
+export type SegData = [Segment, DFData];
+export interface PayloadArgs {
+    sourceName: string;
+    start: number;
+    end: number;
+    origEnd: number;
+    sort?: string;
+    sort_direction?: string;
+    request_time?: number;
+    second_request?: PayloadArgs;
+}
+export interface PayloadResponse {
+    key: PayloadArgs;
+    data: DFData;
+    length: number;
+    error_info?: string;
+}
+export declare const getPayloadKey: (payloadArgs: PayloadArgs) => string;
+export declare const getSourcePayloadKey: (payloadArgs: PayloadArgs) => string;
+export declare const mergeSegments: (segments: Segment[], dfs: DFData[], newSegment: Segment, newDF: DFData) => [Segment[], DFData[]];
+export declare const merge: (leftSD: SegData, rightSD: SegData) => SegData;
+export declare const segmentBetween: (test: Segment, segLow: Segment, segHigh: Segment) => boolean;
+export declare const segmentLT: (a: Segment, b: Segment) => boolean;
+export declare const segmentSubset: (outer: Segment, inner: Segment) => boolean;
+export declare const segmentsOverlap: (segmentA: Segment, segmentB: Segment) => boolean;
+export declare const segmentIntersect: (segmentA: Segment, segmentB: Segment) => Segment;
+export declare const minimumFillArgs: (haveSegment: Segment, needSegment: Segment) => RequestArgs;
+export declare const getSliceRange: (haveSegment: Segment, haveDF: DFData, requestSeg: Segment) => DFData;
+export declare const getRange: (segments: Segment[], dfs: DFData[], requestSeg: Segment) => DFData;
+export declare const segmentsSize: (segments: Segment[]) => number;
+export declare const segmentSize: (seg: Segment) => number;
+export declare const segmentMid: (seg: Segment) => number;
+export declare const segmentEndDist: (lastSegment: Segment, extent: Segment) => number;
+export declare const slicedSegmentSize: (segments: Segment[], slice: Segment) => number;
+export declare const segmentFromMidOffset: (midPoint: number, offset: number) => Segment;
+export declare const sizeSlice: (midPoint: number, offset: number, segments: Segment[]) => number;
+export declare const compactSegments: (segments: Segment[], dfs: DFData[], keep: Segment) => [Segment[], DFData[]];
+export declare class SmartRowCache {
+    segments: Segment[];
+    private dfs;
+    sentLength: number;
+    maxSize: number;
+    trimFactor: number;
+    lastRequest: Segment;
+    usedSize(): number;
+    trimCache(): void;
+    getExtents(): Segment;
+    safeGetExtents(): any;
+    addRows(newSegment: Segment, newDf: DFData): void;
+    hasRows(needSeg: Segment): RequestArgs;
+    getRows(range: Segment): DFData;
+}
+export type RequestFN = (pa: PayloadArgs) => void;
+export type FoundRowsCB = (df: DFData, length: number) => void;
+export type FailCB = () => void;
+export declare class KeyAwareSmartRowCache {
+    private srcAccesses;
+    private waitingCallbacks;
+    private reqFn;
+    maxSize: number;
+    trimFactor: number;
+    lastRequest: Segment;
+    reUpDist: number;
+    padding: number;
+    constructor(reqFn: RequestFN);
+    usedSize(): number;
+    debugCacheState(): void;
+    hasRows(pa: PayloadArgs): boolean;
+    getRows(pa: PayloadArgs): DFData;
+    maybeMakeLeadingRequest(pa: PayloadArgs): void;
+    getRequestRows(pa: PayloadArgs, cb: FoundRowsCB, failCb: FailCB): void;
+    ensureRowCacheForPa(pa: PayloadArgs): SmartRowCache;
+    addPayloadResponse(resp: PayloadResponse): void;
+    addErrorResponse(resp: PayloadResponse): void;
+    trim(): void;
+}

package/dist/src/components/DFViewerParts/SmartRowCache.test.d.ts

@@ -0,0 +1,23 @@
+import { Segment } from './SmartRowCache';
+import { DFData } from './DFWhole';
+export declare const segA: Segment;
+export declare const dataA: DFData;
+export declare const segB: Segment;
+export declare const dataB: DFData;
+export declare const segBShort: Segment;
+export declare const dataBShort: DFData;
+export declare const segC: Segment;
+export declare const dataC: DFData;
+export declare const segD: Segment;
+export declare const dataD: DFData;
+export declare const segE: Segment;
+export declare const dataE: DFData;
+export declare const segBD: Segment;
+export declare const dataBD: DFData;
+export declare const segBE: Segment;
+export declare const dataBE: DFData;
+export declare const segAOffset: Segment;
+export declare const segBOffset: Segment;
+export declare const segCOffset: Segment;
+export declare const fullData09: DFData;
+export declare const fullData015: DFData;

package/dist/src/components/DFViewerParts/Styler.d.ts

@@ -0,0 +1,33 @@
+import { CellClassParams } from 'ag-grid-community';
+import { ColorMappingConfig, ColorMapRules, ColorCategoricalRules, ColorWhenNotNullRules, ColorFromColumn, ColorStaticRules } from './DFWhole';
+export declare function getHistoIndex(val: number, histogram_edges: number[]): number;
+export declare function colorMap(cmr: ColorMapRules): {
+    cellStyle: (params: CellClassParams) => {
+        backgroundColor: string;
+    };
+};
+export declare function categoricalColor(cmr: ColorCategoricalRules): {
+    cellStyle: (params: CellClassParams) => {
+        backgroundColor: string;
+    };
+};
+export declare function colorNotNull(cmr: ColorWhenNotNullRules): {
+    cellStyle: (params: CellClassParams) => {
+        backgroundColor: string;
+    };
+};
+export declare function colorFromColumn(cmr: ColorFromColumn): {
+    cellStyle: (params: CellClassParams) => {
+        backgroundColor: any;
+    };
+};
+export declare function colorStatic(cmr: ColorStaticRules): {
+    cellStyle: (params: CellClassParams) => {
+        backgroundColor: string;
+    };
+};
+export declare function getStyler(cmr: ColorMappingConfig): {
+    cellStyle: (params: CellClassParams) => {
+        backgroundColor: any;
+    };
+};

package/dist/src/components/DFViewerParts/TableInfinite.d.ts

@@ -0,0 +1,10 @@
+import { PayloadArgs } from './gridUtils';
+import { Operation } from '../OperationUtils';
+import { PayloadResponse } from './SmartRowCache';
+export declare const InfiniteWrapper: ({ payloadArgs, on_payloadArgs, payloadResponse, operations, }: {
+    payloadArgs: PayloadArgs;
+    on_payloadArgs: (pa: PayloadArgs) => void;
+    payloadResponse: PayloadResponse;
+    operations: Operation[];
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const InfiniteEx: () => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/DFViewerParts/ViewRegistry.d.ts

@@ -0,0 +1,21 @@
+import { View } from './Views';
+/**
+ * Capacity-bounded LRU registry of views, keyed by viewKey().
+ *
+ * Uses the standard JS-Map insertion-order trick: a get/touch deletes
+ * and re-inserts the entry to put it at the MRU end; eviction pops
+ * the first iteration entry (LRU).
+ *
+ * Capacity 0 is allowed — anything added is evicted immediately.
+ */
+export declare class ViewRegistry {
+    private readonly capacity;
+    private readonly map;
+    constructor(capacity: number);
+    size(): number;
+    has(viewKey: string): boolean;
+    get(viewKey: string): View | undefined;
+    add(view: View): View | undefined;
+    delete(viewKey: string): void;
+    keys(): string[];
+}

package/dist/src/components/DFViewerParts/ViewRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/DFViewerParts/Views.d.ts

@@ -0,0 +1,53 @@
+/**
+ * View layer: "what rowid is at position k under this ordering?"
+ *
+ * The RowStore holds row contents keyed by rowid; views answer the
+ * complementary question of which rowid lives where. The renderer
+ * composes:
+ *
+ *   view V at position k  →  rowid r = V.positionAt(k)  →  RowStore.get(r)
+ *
+ * Three kinds, all answering the same contract:
+ *   - IdentityView: position == rowid. No backing array.
+ *   - SortView:     wraps an Int32Array permutation of the dataset.
+ *   - FilterView:   wraps an Int32Array subset of the dataset.
+ *
+ * See docs/smart-row-cache-redesign.md.
+ */
+export type SortDirection = "asc" | "desc";
+export declare const IDENTITY_VIEW_KEY = "identity";
+export declare function sortViewKey(sortKey: string, sortDirection: SortDirection): string;
+export declare function filterViewKey(filterKey: string): string;
+export interface View {
+    length(): number;
+    positionAt(pos: number): number;
+    rowidsInRange(start: number, end: number): number[];
+    viewKey(): string;
+}
+export declare class IdentityView implements View {
+    private readonly _length;
+    constructor(length: number);
+    length(): number;
+    positionAt(pos: number): number;
+    rowidsInRange(start: number, end: number): number[];
+    viewKey(): string;
+}
+export declare class SortView implements View {
+    readonly sortKey: string;
+    readonly sortDirection: SortDirection;
+    readonly rowidOrder: Int32Array;
+    constructor(sortKey: string, sortDirection: SortDirection, rowidOrder: Int32Array);
+    length(): number;
+    positionAt(pos: number): number;
+    rowidsInRange(start: number, end: number): number[];
+    viewKey(): string;
+}
+export declare class FilterView implements View {
+    readonly filterKey: string;
+    readonly rowidSubset: Int32Array;
+    constructor(filterKey: string, rowidSubset: Int32Array);
+    length(): number;
+    positionAt(pos: number): number;
+    rowidsInRange(start: number, end: number): number[];
+    viewKey(): string;
+}

package/dist/src/components/DFViewerParts/Views.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/DFViewerParts/autocleaning.toggle.integration.test.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Integration test: BuckarooInfiniteWidget under an autocleaning toggle.
+ *
+ * Reproduces the user's report from Full-tour.ipynb: "Just toggling the
+ * cleaning method twice triggered React error #300" (Rendered fewer hooks
+ * than expected).
+ *
+ * Production flow this test mirrors:
+ *   1. Widget mounts with summary stats containing histogram + chart values.
+ *   2. User flips cleaning_method in the status bar.
+ *   3. Python regenerates summary stats; new `df_data_dict.summary_stats`
+ *      comes back with values for some columns potentially missing or
+ *      shape-changed.
+ *   4. AG-Grid keeps the same cell-fiber instances and just sets new
+ *      pinnedTopRowData via setGridOption — pushing fresh `value` props
+ *      into the same React fibers used for the pinned cells.
+ *   5. If any cellRenderer's hook count varies by value-shape branch,
+ *      React throws #300 / #310 depending on direction.
+ *
+ * Unlike the existing flash matrix tests (which stub AG-Grid to a `<div/>`
+ * and never actually mount cell renderers), this test installs an AG-Grid
+ * mock that walks `pinnedTopRowData × columnDefs` and renders each cell
+ * through `cellRendererSelector` — the same selector path that ships to
+ * production. That's the only way the bug surfaces in jsdom: AG-Grid's
+ * cell layer is where the hook violation actually fires.
+ */
+export {};

package/dist/src/components/DFViewerParts/gridUtils.d.ts

@@ -0,0 +1,81 @@
+import { CellRendererSelectorResult, ColDef, ColGroupDef, DomLayoutType, ICellRendererParams, IDatasource, SizeColumnsToContentStrategy, SizeColumnsToFitProvidedWidthStrategy, Theme } from 'ag-grid-community';
+import { DFWhole, DisplayerArgs, ColumnConfig, DFViewerConfig, ComponentConfig, NormalColumnConfig, MultiIndexColumnConfig, ColDefOrGroup, DFData, SDFT, PinnedRowConfig } from './DFWhole';
+import { CSSProperties, Dispatch, SetStateAction } from 'react';
+import { CommandConfigT } from '../CommandUtils';
+import { KeyAwareSmartRowCache, PayloadArgs } from './SmartRowCache';
+export declare function getCellRendererorFormatter(dispArgs: DisplayerArgs): ColDef;
+export declare function extractPinnedRows(sdf: DFData, prc: PinnedRowConfig[]): (import('./DFWhole').DFDataRow | undefined)[];
+export declare function extractSingleSeriesSummary(full_summary_stats_df: DFData, col_name: string): DFWhole;
+export declare const getFieldVal: (f: ColumnConfig) => string;
+export declare function baseColToColDef(f: ColumnConfig): ColDef;
+export declare function normalColToColDef(f: NormalColumnConfig): ColDef;
+export declare const getSubChildren: (arr: ColumnConfig[], level: number) => ColumnConfig[][];
+export declare function childColDef(f: MultiIndexColumnConfig, level: number): ColDefOrGroup;
+export declare function multiIndexColToColDef(f: MultiIndexColumnConfig[], level?: number): ColGroupDef;
+export declare function mergeCellClass(cOrig: ColDef | ColGroupDef, classSpec: "headerClass" | "cellClass", extraClass: string): ColDef | ColGroupDef;
+export declare function dfToAgrid(dfviewer_config: DFViewerConfig): (ColDef | ColGroupDef)[];
+export declare function getCellRendererSelector(pinned_rows: PinnedRowConfig[], column_config: ColumnConfig[]): (params: ICellRendererParams<any, any, any>) => CellRendererSelectorResult | undefined;
+export declare function extractSDFT(summaryStatsDf: DFData): SDFT;
+export declare const getPayloadKey: (payloadArgs: PayloadArgs) => string;
+export type CommandConfigSetterT = (setter: Dispatch<SetStateAction<CommandConfigT>>) => void;
+export interface IDisplayArgs {
+    data_key: string;
+    df_viewer_config: DFViewerConfig;
+    summary_stats_key: string;
+}
+export interface TimedIDatasource extends IDatasource {
+    createTime: Date;
+}
+export declare const getDs: (src: KeyAwareSmartRowCache) => TimedIDatasource;
+export type SetColumnFunc = (newCol: [string, string]) => void;
+export type PossibleAutosizeStrategy = SizeColumnsToFitProvidedWidthStrategy | SizeColumnsToContentStrategy;
+interface HeightStyleArgs {
+    numRows: number;
+    pinnedRowLen: number;
+    readonly location: Location;
+    rowHeight?: number;
+    compC?: ComponentConfig;
+}
+export interface HeightStyleI {
+    domLayout: DomLayoutType;
+    inIframe: string;
+    classMode: "short-mode" | "regular-mode";
+    applicableStyle: CSSProperties;
+    maxRowsWithoutScrolling: number;
+}
+export declare const getHeightStyle2: (maxDataPinnedRows: number, maxRows: number, component_config?: ComponentConfig, rowHeight?: number) => HeightStyleI;
+export declare const heightStyle: (hArgs: HeightStyleArgs) => HeightStyleI;
+export declare const getAutoSize: (numColumns: number) => SizeColumnsToFitProvidedWidthStrategy | SizeColumnsToContentStrategy;
+export declare const myThemeDark: Theme;
+export declare const myThemeLight: Theme;
+/** @deprecated Use getThemeForScheme() instead */
+export declare const myTheme: Theme;
+export type ThemeColorConfig = {
+    accentColor?: string;
+    accentHoverColor?: string;
+    backgroundColor?: string;
+    foregroundColor?: string;
+    oddRowBackgroundColor?: string;
+    borderColor?: string;
+    headerBorderColor?: string;
+    headerBackgroundColor?: string;
+    spacing?: number;
+    cellHorizontalPaddingScale?: number;
+    rowVerticalPaddingScale?: number;
+};
+export type ThemeConfig = ThemeColorConfig & {
+    colorScheme?: 'light' | 'dark' | 'auto';
+    light?: ThemeColorConfig;
+    dark?: ThemeColorConfig;
+};
+export declare function resolveColorScheme(osScheme: 'light' | 'dark', themeConfig?: ThemeConfig): 'light' | 'dark';
+/**
+ * Merge scheme-specific color overrides (light/dark sub-dicts) with
+ * top-level color properties.  Returns a flat ThemeConfig suitable for
+ * passing to getThemeForScheme and CSS variable injection.
+ *
+ * Priority: scheme-specific override > top-level color > defaults.
+ */
+export declare function resolveThemeColors(effectiveScheme: 'light' | 'dark', themeConfig?: ThemeConfig): ThemeConfig | undefined;
+export declare function getThemeForScheme(scheme: 'light' | 'dark', themeConfig?: ThemeConfig): Theme;
+export {};

package/dist/src/components/DFViewerParts/gridUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/DFViewerParts/resolveDFData.d.ts

@@ -0,0 +1,29 @@
+import { DFData, DFDataOrPayload } from './DFWhole';
+/**
+ * Synchronously resolve a DFDataOrPayload to DFData.
+ *
+ * - If the input is already a plain DFData array, return it as-is.
+ * - If it is a parquet-b64 payload, decode and parse the parquet into DFData.
+ * - Falls back to an empty array on errors.
+ *
+ * NOTE: hyparquet's parquetRead onComplete may fire asynchronously in some
+ * bundler environments (e.g. esbuild standalone). In such cases this function
+ * returns [] and the result is cached when onComplete fires. Prefer
+ * resolveDFDataAsync() for reliable decoding.
+ */
+export declare function resolveDFData(val: DFDataOrPayload | undefined | null): DFData;
+/**
+ * Asynchronously resolve a DFDataOrPayload to DFData.
+ *
+ * Unlike resolveDFData(), this properly awaits hyparquet's parquetRead
+ * so it works reliably in all bundler environments.
+ */
+export declare function resolveDFDataAsync(val: DFDataOrPayload | undefined | null): Promise<DFData>;
+/**
+ * Pre-resolve all parquet_b64 values in a df_data_dict.
+ *
+ * Returns a new dict where parquet_b64 payloads have been decoded to DFData arrays.
+ * This should be called before passing df_data_dict to React components so that
+ * the synchronous resolveDFData() sees plain arrays and passes them through.
+ */
+export declare function preResolveDFDataDict(dict: Record<string, DFDataOrPayload> | undefined | null): Promise<Record<string, DFDataOrPayload>>;

package/dist/src/components/DFViewerParts/resolveDFData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/DFViewerParts/xorqWindow.dom.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/DFViewerParts/xorqWindow.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{buckaroo_js → dist/src}/components/DependentTabs.d.ts

@@ -1,18 +1,14 @@
-import React, { CSSProperties, Dispatch, SetStateAction } from 'react';
+import { default as React, CSSProperties, Dispatch, SetStateAction } from 'react';
 import { DFWhole } from './DFViewerParts/DFWhole';
 import { Operation } from './OperationUtils';
-export declare function OperationDisplayer({ filledOperations, style }: {
+export declare function OperationDisplayer({ filledOperations, style, }: {
     filledOperations: Operation[];
     style: CSSProperties;
 }): React.JSX.Element;
-export declare function PythonDisplayer({ style, generatedPyCode }: {
+export declare function PythonDisplayer({ style, generatedPyCode, }: {
     style: CSSProperties;
     generatedPyCode: string;
-}): React.JSX.Element;
-export declare function TransformViewer({ style, transformedDf }: {
-    style: CSSProperties;
-    transformedDf: DFWhole;
-}): React.JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 export type OperationResult = {
     transformed_df: DFWhole;
     generated_py_code: string;
@@ -21,13 +17,12 @@ export type OperationResult = {
 export type OrRequesterT = (ops: Operation[]) => void;
 export type getOperationResultSetterT = (setter: Dispatch<SetStateAction<OperationResult>>) => OrRequesterT;
 export declare const baseOperationResults: OperationResult;
-export declare function TabComponent({ currentTab, _setTab, tabName }: {
+export declare function TabComponent({ currentTab, _setTab, tabName, }: {
     currentTab: any;
     _setTab: any;
     tabName: any;
 }): JSX.Element;
-export declare function DependentTabs({ filledOperations, operationResult }: {
+export declare function DependentTabs({ filledOperations, operation_result, }: {
     filledOperations: Operation[];
-    operationResult: OperationResult;
-}): React.JSX.Element;
-//# sourceMappingURL=DependentTabs.d.ts.map
+    operation_result: OperationResult;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/MessageBox.d.ts

@@ -0,0 +1,8 @@
+export declare function MessageBox({ messages, }: {
+    messages: Array<{
+        time?: string;
+        type?: string;
+        message?: string;
+        [key: string]: any;
+    }>;
+}): import("react/jsx-runtime").JSX.Element | null;

package/{buckaroo_js → dist/src}/components/OperationDetail.d.ts

@@ -1,16 +1,14 @@
 import { Operation, OperationEventFunc } from './OperationUtils';
 import { ActualArg, CommandArgSpec } from './CommandUtils';
-import React from 'react';
-export declare const OperationDetail: ({ command, setCommand, columns, commandPatterns }: {
+export declare const OperationDetail: ({ command, setCommand, columns, commandPatterns, }: {
     command: Operation;
     setCommand: OperationEventFunc;
     columns: string[];
     commandPatterns: CommandArgSpec;
-}) => React.JSX.Element;
-export declare const ArgGetters: ({ command, fullPattern, setCommand, columns }: {
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ArgGetters: ({ command, fullPattern, setCommand, columns, }: {
     command: Operation;
     fullPattern: ActualArg[];
     setCommand: OperationEventFunc;
     columns: string[];
-}) => React.JSX.Element;
-//# sourceMappingURL=OperationDetail.d.ts.map
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/OperationExamples.d.ts

@@ -0,0 +1,8 @@
+import { Operation, OperationDefaultArgs } from './OperationUtils';
+import { CommandArgSpec, CommandConfigT } from './CommandUtils';
+export declare const sampleOperations: Operation[];
+export declare const manyOperations: Operation[];
+export declare const dataCleaningOps: Operation[];
+export declare const bakedOperationDefaults: OperationDefaultArgs;
+export declare const bakedArgSpecs: CommandArgSpec;
+export declare const bakedCommandConfig: CommandConfigT;

package/{buckaroo_js → dist/src}/components/OperationUtils.d.ts

@@ -8,10 +8,10 @@ export type OperationSingleColumn = [SymbolT, SymbolDf, string];
 export type OperationSingleArg = [SymbolT, SymbolDf, string, Atom];
 export type OperationTwoArg = [SymbolT, SymbolDf, string, Atom, Atom];
 export type Operation = OperationSingleColumn | OperationSingleArg | OperationTwoArg;
+export declare const getOperationKey: (ops: Operation[], idx: number) => string;
 export type SetOperationFunc = (newCommand: Operation) => void;
 export type SetOperationsFunc = (newCommands: Operation[]) => void;
 export type OperationDefaultArgs = Record<string, Operation>;
 export declare const bakedOperations: Operation[];
 export type OperationEventFunc = (newCommand: Operation) => void;
 export type NoArgEventFunc = () => void;
-//# sourceMappingURL=OperationUtils.d.ts.map

package/dist/src/components/Operations.d.ts

@@ -0,0 +1,14 @@
+import { Operation, SetOperationsFunc } from './OperationUtils';
+import { CommandConfigT } from './CommandUtils';
+export declare const OperationAdder: ({ column, addOperationCb, defaultArgs, }: {
+    column: string;
+    addOperationCb: any;
+    defaultArgs: any;
+}) => JSX.Element;
+export declare const OperationViewer: ({ operations, setOperations, activeColumn, allColumns, command_config, }: {
+    operations: Operation[];
+    setOperations: SetOperationsFunc;
+    activeColumn: string;
+    allColumns: string[];
+    command_config: CommandConfigT;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Operations.test.d.ts

@@ -0,0 +1,4 @@
+import { CommandConfigT } from './CommandUtils';
+import { Operation } from './OperationUtils';
+export declare const getTestOperations: () => Operation[];
+export declare const getTestCommandConfig: () => CommandConfigT;

package/dist/src/components/OperationsList.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { Operation, SetOperationsFunc } from './OperationUtils';
+export interface OperationsListProps {
+    operations: Operation[];
+    setOperations: SetOperationsFunc;
+    activeKey: string;
+    setActiveKey: React.Dispatch<React.SetStateAction<string>>;
+}
+export declare const OperationsList2: React.FC<OperationsListProps>;

package/dist/src/components/StatusBar.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { DFMeta, BuckarooOptions, BuckarooState } from './WidgetTypes';
+import { CustomCellEditorProps } from 'ag-grid-react';
+import { ThemeConfig } from './DFViewerParts/gridUtils';
+export type setColumFunc = (newCol: string) => void;
+export declare const fakeSearchCell: (_params: any) => import("react/jsx-runtime").JSX.Element;
+export declare const SearchEditor: React.MemoExoticComponent<({ value, onValueChange, stopEditing }: CustomCellEditorProps) => import("react/jsx-runtime").JSX.Element>;
+export declare function StatusBar({ dfMeta, buckarooState, setBuckarooState, buckarooOptions, heightOverride, themeConfig }: {
+    dfMeta: DFMeta;
+    buckarooState: BuckarooState;
+    setBuckarooState: React.Dispatch<React.SetStateAction<BuckarooState>>;
+    buckarooOptions: BuckarooOptions;
+    heightOverride?: number;
+    themeConfig?: ThemeConfig;
+}): import("react/jsx-runtime").JSX.Element;

package/{buckaroo_js → dist/src}/components/WidgetTypes.d.ts

@@ -6,7 +6,7 @@ export interface DFMeta {
 }
 export interface BuckarooOptions {
     sampled: string[];
-    auto_clean: string[];
+    cleaning_method: string[];
     post_processing: string[];
     df_display: string[];
     show_commands: string[];
@@ -15,11 +15,10 @@ export type QuickAtom = number | string;
 export type QuickArg = QuickAtom[];
 export interface BuckarooState {
     sampled: string | false;
-    auto_clean: string | false;
+    cleaning_method: string | false;
     quick_command_args: Record<string, QuickArg>;
     post_processing: string | false;
     df_display: string;
     show_commands: string | false;
 }
-export type BKeys = keyof BuckarooOptions;
-//# sourceMappingURL=WidgetTypes.d.ts.map
+export type BKeys = "sampled" | "cleaning_method" | "post_processing" | "df_display";

package/dist/src/components/useColorScheme.d.ts

@@ -0,0 +1,7 @@
+type ColorScheme = 'light' | 'dark';
+/**
+ * React hook that reactively tracks the user's OS color scheme preference.
+ * Re-renders the component when the preference changes.
+ */
+export declare function useColorScheme(): ColorScheme;
+export {};