@altertable/data-app 0.65.0 → 0.67.0

package/dist/types/react/widgets.d.ts

@@ -0,0 +1,79 @@
+import { type Dataset, type Metric, type ViewSource } from './bindings.js';
+import { type MetricWidgetProps as DisplayMetricProps } from './ui/MetricWidget.js';
+import { type TableWidgetProps as DisplayTableProps, type TableDisplayMode } from './ui/TableWidget.js';
+import { type VisualizationWidgetProps as DisplayVisualProps, type VisualizationWidgetView as DisplayVisualizationView } from './ui/VisualizationWidget.js';
+import { type TextWidgetProps as DisplayTextProps } from './ui/TextWidget.js';
+import { type DataValueProps as DisplayValueProps } from './ui/DataValue.js';
+import type { MetricValues } from '../core/reading.js';
+import type { MetricDefinition } from './ui/metric.js';
+import type { ReactNode } from 'react';
+import type { DataReading } from '../core/reading.js';
+export type MetricWidgetProps<Data = unknown, Input = unknown> = Omit<Extract<DisplayMetricProps, {
+    metric: MetricDefinition;
+}>, 'metric' | 'reading'> & {
+    metric: Metric<Data, Input>;
+    source: ViewSource<Data, Input>;
+};
+export declare function MetricWidget<Data, Input>({ metric, source, ...presentation }: MetricWidgetProps<Data, Input>): import("react").JSX.Element;
+type BoundTableProps<Row> = Extract<DisplayTableProps<Row>, {
+    reading: DataReading<readonly Row[]>;
+}>;
+type TablePresentation<Row> = Pick<BoundTableProps<Row>, 'title' | 'columns' | 'rowKey' | 'reading' | 'evidence' | 'emptyFallback'>;
+export type TableWidgetProps<Row, Data = unknown, Input = unknown> = Omit<BoundTableProps<Row>, keyof TablePresentation<Row> | 'limit' | 'pagination'> & TableDisplayMode & {
+    dataset: Dataset<Data, Input, Row>;
+    source: ViewSource<Data, Input>;
+    title?: ReactNode;
+};
+export declare function TableWidget<Row, Data, Input>({ dataset, source, title, ...presentation }: TableWidgetProps<Row, Data, Input>): import("react").JSX.Element;
+type BoundVisual<Row> = Extract<DisplayVisualProps<readonly Row[]>, {
+    reading: DataReading<readonly Row[]>;
+}>;
+export type VisualizationWidgetView<Row> = DisplayVisualizationView<readonly Row[]>;
+type VisualContent<Row> = {
+    children: (rows: readonly Row[]) => ReactNode;
+    views?: never;
+    viewLabel?: never;
+    initialView?: never;
+} | {
+    children?: never;
+    views: readonly VisualizationWidgetView<Row>[];
+    viewLabel: string;
+    initialView?: string;
+};
+export type VisualizationWidgetProps<Row, Data = unknown, Input = unknown> = Omit<BoundVisual<Row>, 'reading' | 'isEmpty' | 'emptyFallback' | 'evidence' | 'title' | 'children' | 'views' | 'viewLabel' | 'initialView'> & VisualContent<Row> & {
+    dataset: Dataset<Data, Input, Row>;
+    source: ViewSource<Data, Input>;
+    title?: ReactNode;
+};
+export declare function VisualizationWidget<Row, Data, Input>({ dataset, source, title, ...presentation }: VisualizationWidgetProps<Row, Data, Input>): import("react").JSX.Element;
+type NarrativeBinding<Data, Input, Row> = {
+    metric: Metric<Data, Input>;
+    dataset?: never;
+    source: ViewSource<Data, Input>;
+    children?: (values: MetricValues) => ReactNode;
+} | {
+    metric?: never;
+    dataset: Dataset<Data, Input, Row>;
+    source: ViewSource<Data, Input>;
+    children: (rows: readonly Row[]) => ReactNode;
+};
+export type TextWidgetProps<Data = unknown, Input = unknown, Row = never> = Omit<Extract<DisplayTextProps<unknown>, {
+    reading: DataReading<unknown>;
+}>, 'reading' | 'evidence' | 'children' | 'title' | 'emptyFallback'> & NarrativeBinding<Data, Input, Row> & {
+    title?: ReactNode;
+};
+export declare function TextWidget<Data, Input, Row>(props: TextWidgetProps<Data, Input, Row>): import("react").JSX.Element;
+type InlinePresentation = Omit<DisplayValueProps<unknown>, 'reading' | 'children' | 'loadingFallback'> & {
+    loadingFallback?: ReactNode;
+};
+export type DataValueProps<Data = unknown, Input = unknown, Row = never> = InlinePresentation & ((NarrativeBinding<Data, Input, Row> & {
+    scope?: never;
+}) | {
+    metric?: never;
+    dataset?: never;
+    source?: never;
+    scope: DataReading<string>;
+    children?: (scope: string) => ReactNode;
+});
+export declare function DataValue<Data, Input, Row>(props: DataValueProps<Data, Input, Row>): import("react").JSX.Element;
+export {};

package/dist/types/server/handler.d.ts

@@ -1,13 +1,13 @@
-import { type DataOperations, type Lakehouse } from '../core/contract.js';
+import { type DataOperations, type Lakehouse, type QueryParameters } from '../core/contract.js';
 /** Authorization result for one viewer request. A hosted adapter must scope its lakehouse client. */
 export type RequestAccess = {
     lakehouse: Lakehouse;
-    canDiscloseSql: boolean;
+    /** Trusted values shared across queries; each query uses only its declared keys. */
+    queryParams?: QueryParameters;
 };
 /**
  * Execute named operations on the server. The app supplies operations and viewer authorization.
  * JSON, Origin, and Fetch Metadata checks reject cross-site browser POSTs; they do not
- * authenticate another local process. SQL is returned only when both the operation and
- * authorization result permit disclosure.
+ * authenticate another local process. Query evidence accompanies every result.
  */
 export declare function createDataHandler(operations: DataOperations, authorize: (request: Request, operation: string) => Promise<RequestAccess>): (request: Request) => Promise<Response>;