@trilogy-data/trilogy-studio-components 0.1.0

package/dist/dashboards/mapSpec.d.ts

@@ -0,0 +1,431 @@
+import { Row, ResultColumn, ChartConfig } from '../editors/results';
+/**
+ * Main function to create USA map specification
+ */
+export declare const createMapSpec: (config: ChartConfig, data: readonly Row[], columns: Map<string, ResultColumn>, isMobile: boolean, intChart: Array<Partial<ChartConfig>>, currentTheme?: string) => {
+    projection: {
+        type: string;
+    };
+    layer: ({
+        data: {
+            url: string;
+            format: {
+                type: string;
+                feature: string;
+            };
+        };
+        mark: {
+            type: string;
+            fill: string;
+            stroke: string;
+        };
+    } | {
+        mark: {
+            type: string;
+            tooltip: boolean;
+        };
+        params: ({
+            name: string;
+            select: {
+                type: string;
+                on: string;
+                clear: string;
+            };
+            value?: undefined;
+        } | {
+            name: string;
+            select: string;
+            value: Partial<ChartConfig>[];
+        })[];
+        encoding: {
+            longitude: {
+                field: string | undefined;
+                type: string;
+            };
+            latitude: {
+                field: string | undefined;
+                type: string;
+            };
+            size: {
+                field: string;
+                type: string;
+                title: string;
+                scale: {
+                    type: string;
+                };
+            } | undefined;
+            color: any;
+            tooltip: any[];
+        };
+    })[];
+} | {
+    $schema: string;
+    width: string;
+    height: string;
+    layer: {
+        data: {
+            sequence: {
+                start: number;
+                stop: number;
+                as: string;
+            };
+            name: string;
+        };
+        mark: {
+            type: string;
+            clip: boolean;
+            height: {
+                expr: string;
+            };
+            width: {
+                expr: string;
+            };
+        };
+        encoding: {
+            url: {
+                field: string;
+                type: string;
+            };
+            x: {
+                field: string;
+                scale: null;
+                type: string;
+            };
+            y: {
+                field: string;
+                scale: null;
+                type: string;
+            };
+        };
+        transform: ({
+            calculate: string;
+            as: string;
+            flatten?: undefined;
+            filter?: undefined;
+        } | {
+            flatten: string[];
+            calculate?: undefined;
+            as?: undefined;
+            filter?: undefined;
+        } | {
+            filter: string;
+            calculate?: undefined;
+            as?: undefined;
+            flatten?: undefined;
+        })[];
+    }[];
+    projection?: undefined;
+    params?: undefined;
+} | {
+    projection: {
+        type: string;
+        scale: {
+            expr: string;
+        };
+        center: number[];
+    };
+    params: ({
+        name: string;
+        value: number;
+        expr?: undefined;
+    } | {
+        name: string;
+        expr: string;
+        value?: undefined;
+    })[];
+    layer: ({
+        data: {
+            sequence: {
+                start: number;
+                stop: number;
+                as: string;
+            };
+            name: string;
+        };
+        mark: {
+            type: string;
+            clip: boolean;
+            height: {
+                expr: string;
+            };
+            width: {
+                expr: string;
+            };
+        };
+        encoding: {
+            url: {
+                field: string;
+                type: string;
+            };
+            x: {
+                field: string;
+                scale: null;
+                type: string;
+            };
+            y: {
+                field: string;
+                scale: null;
+                type: string;
+            };
+        };
+        transform: ({
+            calculate: string;
+            as: string;
+            flatten?: undefined;
+            filter?: undefined;
+        } | {
+            flatten: string[];
+            calculate?: undefined;
+            as?: undefined;
+            filter?: undefined;
+        } | {
+            filter: string;
+            calculate?: undefined;
+            as?: undefined;
+            flatten?: undefined;
+        })[];
+    } | {
+        mark: {
+            type: string;
+            tooltip: boolean;
+        };
+        params: ({
+            name: string;
+            select: {
+                type: string;
+                on: string;
+                clear: string;
+            };
+            value?: undefined;
+        } | {
+            name: string;
+            select: string;
+            value: Partial<ChartConfig>[];
+        })[];
+        encoding: {
+            longitude: {
+                field: string;
+                type: string;
+            };
+            latitude: {
+                field: string;
+                type: string;
+            };
+            size: {
+                field: string;
+                type: string;
+                title: string;
+                scale: {
+                    type: string;
+                };
+                legend: {
+                    orient: string;
+                };
+            } | undefined;
+            color: any;
+            tooltip: any[];
+        };
+    })[];
+    $schema?: undefined;
+    width?: undefined;
+    height?: undefined;
+} | {
+    $schema: string;
+    width: string;
+    height: string;
+    projection: {
+        type: string;
+    };
+    layer: ({
+        data: {
+            url: string;
+            format: {
+                type: string;
+                feature: string;
+            };
+        };
+        mark: {
+            type: string;
+            fill: string;
+            stroke: string;
+        };
+    } | {
+        data: {
+            url: string;
+            format: {
+                type: string;
+                feature: string;
+            };
+        };
+        mark: {
+            type: string;
+        };
+        params: ({
+            name: string;
+            select: {
+                type: string;
+                on: string;
+                clear: string;
+            };
+            value?: undefined;
+        } | {
+            name: string;
+            select: string;
+            value: Partial<ChartConfig>[];
+        })[];
+        encoding: {
+            color: {};
+            opacity: {
+                condition: {
+                    param: string;
+                    value: number;
+                };
+                value: number;
+            };
+            stroke: {
+                condition: {
+                    param: string;
+                    empty: boolean;
+                    value: string;
+                };
+                value: null;
+            };
+            strokeWidth: {
+                condition: {
+                    param: string;
+                    empty: boolean;
+                    value: number;
+                };
+                value: number;
+            };
+            tooltip: any[];
+        };
+        transform: ({
+            lookup: string;
+            from: {
+                data: {
+                    values: {
+                        id: number;
+                        abbr: string;
+                    }[] | {
+                        id: number;
+                        name: string;
+                    }[];
+                };
+                key: string;
+                fields: string[];
+            };
+        } | {
+            lookup: string;
+            from: {
+                data: {
+                    values: readonly Readonly<Record<string, any>>[] | null;
+                };
+                key: string | undefined;
+                fields: (string | undefined)[];
+            };
+        })[];
+    })[];
+} | {
+    $schema: string;
+    width: string;
+    height: string;
+    layer: ({
+        data: {
+            url: string;
+            format: {
+                type: string;
+                feature: string;
+            };
+        };
+        transform: {
+            filter: string;
+        }[];
+        mark: {
+            type: string;
+            fill: string;
+            stroke: string;
+            strokeWidth: number;
+        };
+        projection: {
+            type: string;
+        };
+        params?: undefined;
+        encoding?: undefined;
+    } | {
+        data: {
+            url: string;
+            format: {
+                type: string;
+                feature: string;
+            };
+        };
+        transform: {
+            lookup: string;
+            from: {
+                data: {
+                    values: {
+                        id: number | null;
+                    }[];
+                };
+                key: string;
+                fields: (string | undefined)[];
+            };
+        }[];
+        params: ({
+            name: string;
+            select: {
+                type: string;
+                on: string;
+                clear: string;
+            };
+            value?: undefined;
+        } | {
+            name: string;
+            select: string;
+            value: Partial<ChartConfig>[];
+        })[];
+        mark: {
+            type: string;
+            fill?: undefined;
+            stroke?: undefined;
+            strokeWidth?: undefined;
+        };
+        projection: {
+            type: string;
+        };
+        encoding: {
+            color: {};
+            opacity: {
+                condition: {
+                    param: string;
+                    value: number;
+                };
+                value: number;
+            };
+            tooltip: any[];
+            stroke: {
+                condition: {
+                    param: string;
+                    empty: boolean;
+                    value: string;
+                };
+                value: string;
+            };
+            strokeWidth: {
+                condition: {
+                    param: string;
+                    empty: boolean;
+                    value: number;
+                };
+                value: number;
+            };
+        };
+    })[];
+    config: {
+        view: {
+            stroke: null;
+        };
+    };
+};
+//# sourceMappingURL=mapSpec.d.ts.map

package/dist/dashboards/mapSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapSpec.d.ts","sourceRoot":"","sources":["../../dashboards/mapSpec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAiiBxE;;GAEG;AACH,eAAO,MAAM,aAAa,WAChB,WAAW,QACb,SAAS,GAAG,EAAE,WACX,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,YACxB,OAAO,YACP,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,iBACvB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkKrB,CAAA"}

package/dist/dashboards/pointSpec.d.ts

@@ -0,0 +1,27 @@
+import { Row, ResultColumn, ChartConfig } from '../editors/results';
+interface VegaTransform {
+    type: string;
+    [key: string]: any;
+}
+interface VegaMark {
+    name?: string;
+    type: string;
+    transform?: VegaTransform[];
+    [key: string]: any;
+}
+export interface VegaSpec {
+    marks?: VegaMark[];
+    [key: string]: any;
+}
+export declare function addLabelTransformToTextMarks(spec: VegaSpec, labelTransform?: VegaTransform): VegaSpec;
+export declare const createPointChartSpec: (config: ChartConfig, columns: Map<string, ResultColumn>, tooltipFields: any[], selectedValues: {
+    [key: string]: string | number | Array<any>;
+}[], currentTheme?: string, isMobile?: boolean, data?: readonly Row[]) => {
+    layer: any[];
+    encoding: {
+        x: import('./types').FieldEncodingOutput;
+        y: import('./types').FieldEncodingOutput;
+    };
+};
+export {};
+//# sourceMappingURL=pointSpec.d.ts.map

package/dist/dashboards/pointSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointSpec.d.ts","sourceRoot":"","sources":["../../dashboards/pointSpec.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAChE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGrD,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,UAAU,QAAQ;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,aAAa,EAAE,CAAA;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAA;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,cAAc,CAAC,EAAE,aAAa,GAC7B,QAAQ,CAoDV;AA8BD,eAAO,MAAM,oBAAoB,WACvB,WAAW,WACV,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,iBACnB,GAAG,EAAE,kBACJ;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;CAAE,EAAE,iBACnD,MAAM,aACV,OAAO,SACX,SAAS,GAAG,EAAE;;;;;;CA+ErB,CAAA"}

package/dist/dashboards/prompts.d.ts

@@ -0,0 +1,31 @@
+import { CellType } from './base';
+/**
+ * Parses a JSON string into a PromptDashboard object
+ * @param jsonString The JSON string to parse
+ * @returns A PromptDashboard object
+ * @throws Error if the JSON is invalid or doesn't match the expected structure
+ */
+export declare function parseDashboardSpec(jsonString: string): PromptDashboard;
+export interface PromptLayoutItem {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    id: string;
+}
+export interface PromptGridItemData {
+    type: CellType;
+    content: string;
+    name: string;
+    width?: number;
+    height?: number;
+}
+export interface PromptDashboard {
+    name: string;
+    layout: PromptLayoutItem[];
+    gridItems: Record<string, PromptGridItemData>;
+    description: string;
+}
+export declare const DASHBOARD_PROMPT = "You are a world-class dashboard designer and analyst who produces striking insights. Given this typescript template format for a dashboard config, and a list of available fields,\ngenerate a JSON spec that can be imported into these typescript objects that will appropriately visualize data for the provided prompt.\n\nYou build information dense by clear dashboards, in the style of the New York Times or Edward Tufte. Focus on laying out content for an interactive, click based exploration; do not\nmention anything related to global dashboard filters, however.\n\nAppropriately mix in description and markdown to explain the data and the visualizations and how the dashboard should be used. \n\nThe horizontal grid components are sized on a 0-20 scale, which will respond to width. Rows are 30 pixels high. Markdown components should be at least 3 rows high, but make them higher\nif you judge appropriate. \n\nMake the dashboard comprehensive to explore the user question. If the user asks for something detailed, it should typically be 5-8 rows (5-10 cells); otherwise 3-6 is appropriate (4-6 cells). \n\nFor the chart and table types, in the content, write a a prompt for the data you want to visualize. A data engineer\nwill transform this into a real SQL query based on knowledge of the underlying database.\n\nThe prompt should be descriptive and precise to ensure they understand your intent, but should avoid being too 'SQL' - speak business.\n\nThey only have access to the same general concepts as you will be given below, so plan appropriately\nand do not ask them for something they will be unable to answer with that data.\n\nFor markdown, you can directly fill in the appropriate markdown syntax. Markdown cells are static and will not run/fetch data. The other\ntwo cells will be populated by queries. \n\nTypescript format \"\nexport const CELL_TYPES = {\n    CHART: 'chart',\n    MARKDOWN: 'markdown',\n    TABLE: 'table',\n  } as const\n  \nexport type CellType = (typeof CELL_TYPES)[keyof typeof CELL_TYPES]\n\nexport interface PromptLayoutItem {\n  x: number\n  y: number\n  w: number\n  h: number\n  id: string\n}\n\n// This contains details about the layout\n// the \nexport interface PromptGridItemData {\n  type: CellType\n  content: string\n  name: string\n  width?: number\n  height?: number\n}\n\nexport interface PromptDashboard {\n  name: string\n  layout: PromptLayoutItem[]\n  // the key here will associate a grid item with a layout item (in the id field)\n  gridItems: Record<string, PromptGridItemData>\n  description: string\n}\n\n\"\n\n";
+export declare function generateDashboardPrompt(prompt: string, fields: string): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/dashboards/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../dashboards/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,QAAQ,CAAA;AACtC;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAwFtE;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,EAAE,EAAE,MAAM,CAAA;CACX;AAID,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,gBAAgB,EAAE,CAAA;IAE1B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;IAC7C,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,gBAAgB,ohFA6D5B,CAAA;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAS9E"}

package/dist/dashboards/spec.d.ts

@@ -0,0 +1,19 @@
+import { Row, ResultColumn, ChartConfig } from '../editors/results';
+/**
+ * Create a base chart specification
+ */
+export declare const createBaseSpec: (data: readonly Row[] | null) => {
+    $schema: string;
+    data: {
+        values: readonly Readonly<Record<string, any>>[] | null;
+    };
+    width: string;
+    height: string;
+    config: {
+        scale: {
+            bandPaddingInner: number;
+        };
+    };
+};
+export declare const generateVegaSpec: (data: readonly Row[] | null, config: ChartConfig, columns: Map<string, ResultColumn>, chartSelection: Object[] | null, isMobile?: boolean, title?: string, currentTheme?: "light" | "dark" | "", containerHeight?: number, containerWidth?: number) => any;
+//# sourceMappingURL=spec.d.ts.map

package/dist/dashboards/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../dashboards/spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAChE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAA;AA8CrD;;GAEG;AACH,eAAO,MAAM,cAAc,SAAU,SAAS,GAAG,EAAE,GAAG,IAAI;;;;;;;;;;;;CAYzD,CAAA;AAmCD,eAAO,MAAM,gBAAgB,SACrB,SAAS,GAAG,EAAE,GAAG,IAAI,UACnB,WAAW,WACV,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,kBAClB,MAAM,EAAE,GAAG,IAAI,aACrB,OAAO,UACV,MAAM,iBACC,OAAO,GAAG,MAAM,GAAG,EAAE,oBAClB,MAAM,mBACP,MAAM,QAwRvB,CAAA"}

package/dist/dashboards/treeSpec.d.ts

@@ -0,0 +1,3 @@
+import { Row, ResultColumn, ChartConfig } from '../editors/results';
+export declare const createTreemapSpec: (config: ChartConfig, data: readonly Row[] | null, columns: Map<string, ResultColumn>, tooltipFields: any[], encoding: any) => {};
+//# sourceMappingURL=treeSpec.d.ts.map

package/dist/dashboards/treeSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeSpec.d.ts","sourceRoot":"","sources":["../../dashboards/treeSpec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGxE,eAAO,MAAM,iBAAiB,WACpB,WAAW,QACb,SAAS,GAAG,EAAE,GAAG,IAAI,WAClB,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,iBACnB,GAAG,EAAE,YACV,GAAG,OAoId,CAAA"}

package/dist/dashboards/types.d.ts

@@ -0,0 +1,70 @@
+export type FieldType = 'nominal' | 'temporal' | 'ordinal' | 'quantitative';
+export interface FieldEncodingOutput {
+    /** The field name to encode (required when fieldName is provided) */
+    field?: string;
+    /** The Vega-Lite field type */
+    type?: FieldType;
+    /** Human-readable title for the field (derived from description or field name) */
+    title?: string;
+    /** Format hint for displaying values (e.g., date formats, number formats) */
+    format?: string;
+    /** Format type for parsing values */
+    formatType?: string;
+    /** Sorting configuration for the field */
+    sort?: string[] | {
+        field: string;
+        order: 'ascending' | 'descending';
+    } | {
+        field?: string;
+        order?: 'ascending' | 'descending';
+    };
+    /** Scale configuration for the encoding */
+    scale?: {
+        /** Scale type (e.g., 'linear', 'log', 'sqrt') */
+        type?: string;
+        /** Whether to include zero in the scale domain */
+        zero?: boolean;
+        /** Other scale properties */
+        [key: string]: any;
+    };
+    /** Axis configuration properties */
+    axis?: {
+        /** Axis title */
+        title?: string;
+        /** Axis labels configuration */
+        labels?: boolean;
+        /** Tick configuration */
+        ticks?: boolean;
+        /** Grid lines configuration */
+        grid?: boolean;
+        /** Other axis properties */
+        [key: string]: any;
+    };
+    /** Legend configuration properties */
+    legend?: {
+        /** Legend orientation */
+        orient?: 'left' | 'right' | 'top' | 'bottom';
+        /** Legend title orientation */
+        titleOrient?: 'left' | 'right' | 'top' | 'bottom' | 'center';
+        /** Legend direction */
+        direction?: 'horizontal' | 'vertical';
+        /** Legend title font size */
+        titleFontSize?: number;
+        /** Number of ticks in legend */
+        tickCount?: number;
+        /** Specific values to show in legend */
+        values?: any[];
+        /** Format for legend values */
+        format?: string;
+        /** Format type for legend values */
+        formatType?: string;
+        /** Other legend properties */
+        [key: string]: any;
+    } | null;
+    /**
+     * Additional properties that may be merged from axisOptions parameter
+     * This allows for any additional Vega-Lite encoding properties
+     */
+    [key: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/dashboards/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../dashboards/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,cAAc,CAAA;AAE3E,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd,+BAA+B;IAC/B,IAAI,CAAC,EAAE,SAAS,CAAA;IAEhB,kFAAkF;IAClF,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,0CAA0C;IAC1C,IAAI,CAAC,EACD,MAAM,EAAE,GACR;QACE,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE,WAAW,GAAG,YAAY,CAAA;KAClC,GACD;QACE,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,KAAK,CAAC,EAAE,WAAW,GAAG,YAAY,CAAA;KACnC,CAAA;IAEL,2CAA2C;IAC3C,KAAK,CAAC,EAAE;QACN,iDAAiD;QACjD,IAAI,CAAC,EAAE,MAAM,CAAA;QAEb,kDAAkD;QAClD,IAAI,CAAC,EAAE,OAAO,CAAA;QAEd,6BAA6B;QAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB,CAAA;IAED,oCAAoC;IACpC,IAAI,CAAC,EAAE;QACL,iBAAiB;QACjB,KAAK,CAAC,EAAE,MAAM,CAAA;QAEd,gCAAgC;QAChC,MAAM,CAAC,EAAE,OAAO,CAAA;QAEhB,yBAAyB;QACzB,KAAK,CAAC,EAAE,OAAO,CAAA;QAEf,+BAA+B;QAC/B,IAAI,CAAC,EAAE,OAAO,CAAA;QAEd,4BAA4B;QAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB,CAAA;IAED,sCAAsC;IACtC,MAAM,CAAC,EAAE;QACP,yBAAyB;QACzB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAA;QAE5C,+BAA+B;QAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAA;QAE5D,uBAAuB;QACvB,SAAS,CAAC,EAAE,YAAY,GAAG,UAAU,CAAA;QAErC,6BAA6B;QAC7B,aAAa,CAAC,EAAE,MAAM,CAAA;QAEtB,gCAAgC;QAChC,SAAS,CAAC,EAAE,MAAM,CAAA;QAElB,wCAAwC;QACxC,MAAM,CAAC,EAAE,GAAG,EAAE,CAAA;QAEd,+BAA+B;QAC/B,MAAM,CAAC,EAAE,MAAM,CAAA;QAEf,oCAAoC;QACpC,UAAU,CAAC,EAAE,MAAM,CAAA;QAEnB,8BAA8B;QAC9B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB,GAAG,IAAI,CAAA;IAER;;;OAGG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB"}

package/dist/data/connectionHistoryStorage.d.ts

@@ -0,0 +1,25 @@
+export interface QueryRecord {
+    id: number;
+    connectionName: string;
+    query: string;
+    generatedQuery?: string | null;
+    timestamp: string;
+    executionTime: number;
+    status: 'success' | 'error';
+    errorMessage?: string | null;
+    resultSize?: number;
+    resultColumns?: number;
+}
+declare class QueryHistoryStorage {
+    private dbName;
+    private storeName;
+    private db;
+    constructor();
+    private _initDB;
+    addQuery(connectionName: string, queryData: Omit<QueryRecord, 'id' | 'connectionName' | 'timestamp'>): Promise<number>;
+    getQueriesForConnection(connectionName: string, limit?: number): Promise<QueryRecord[]>;
+    clearConnectionHistory(connectionName: string): Promise<void>;
+    private _enforceHistorySizeLimit;
+}
+export default QueryHistoryStorage;
+//# sourceMappingURL=connectionHistoryStorage.d.ts.map

package/dist/data/connectionHistoryStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionHistoryStorage.d.ts","sourceRoot":"","sources":["../../data/connectionHistoryStorage.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,SAAS,GAAG,OAAO,CAAA;IAC3B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAID,cAAM,mBAAmB;IACvB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,EAAE,CAAoB;;YAUhB,OAAO;IAiCR,QAAQ,CACnB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,gBAAgB,GAAG,WAAW,CAAC,GAClE,OAAO,CAAC,MAAM,CAAC;IA0CL,uBAAuB,CAClC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,MAAyB,GAC/B,OAAO,CAAC,WAAW,EAAE,CAAC;IAmCZ,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAiC5D,wBAAwB;CAkDvC;AAED,eAAe,mBAAmB,CAAA"}

package/dist/data/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const KeySeparator = "+";
+export declare function rsplit(str: string, delimiter: string): [string, string];
+export declare function lastSegment(key: string, delimiter: string | null): string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/data/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../data/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,MAAM,CAAA;AAE/B,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcvE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAKzE"}

package/dist/data/credentialHelpers.d.ts

@@ -0,0 +1,30 @@
+export interface Credential {
+    label: string;
+    type: CredentialType;
+    value: string;
+}
+export interface EncryptedData {
+    encryptedValue: string;
+    iv: string;
+    salt: string;
+}
+export type CredentialType = 'connection' | 'llm';
+export declare const DEFAULT_PBKDF2_ITERATIONS = 250000;
+export declare const SALT_LENGTH_BYTES = 16;
+export declare const IV_LENGTH_BYTES = 12;
+export declare const CREDENTIAL_PREFIX = "trilogy_studio_";
+export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
+export declare function base64ToArrayBuffer(base64: string): Uint8Array;
+export declare class CredentialError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class DecryptionError extends CredentialError {
+    constructor(message?: string, cause?: unknown);
+}
+export interface CredentialManagerOptions {
+    pbkdf2Iterations?: number;
+    credentialPrefix?: string;
+    useCredentialManagementApi?: boolean;
+}
+//# sourceMappingURL=credentialHelpers.d.ts.map