@altertable/data-app 0.64.0 → 0.66.0

package/dist/types/react/ui/shortcuts.d.ts

@@ -9,6 +9,12 @@ export type Shortcut = {
     key: string;
 };
 export declare const shortcuts: {
+    readonly annotate: {
+        readonly modifier: 'mod';
+        readonly shift: true;
+        readonly code: 'Period';
+        readonly key: '.';
+    };
     readonly refresh: {
         readonly modifier: 'alt';
         readonly code: 'KeyR';
@@ -29,4 +35,4 @@ export declare function shortcutLabel({ modifier, shift, key }: Shortcut): strin
 export declare function ariaKeyShortcuts({ modifier, shift, key }: Shortcut): string;
 export declare function isEditingTarget(target: EventTarget | null): boolean;
 /** Bind a page-level shortcut. Ignored while typing or while a modal layer is open. */
-export declare function useShortcut(shortcut: Shortcut, action: () => void, enabled?: boolean): void;
+export declare function useShortcut(shortcut: Shortcut, action: () => void, enabled?: boolean, allowWhileEditing?: boolean): void;

package/dist/types/react/view-runtime.d.ts

@@ -0,0 +1,29 @@
+import type { DataContext } from './ui/data-context.js';
+import type { ReactNode } from 'react';
+import type { DataView, DisplayedSnapshot } from '../core/data-view.js';
+import type { DisclosedQuery } from '../core/contract.js';
+import type { EmptyContent } from './ui/presentation.js';
+export type ViewResult<Data, Input> = {
+    dataContext: DataContext;
+    view: DataView<Data, Input>;
+    snapshot?: DisplayedSnapshot<Data, Input>;
+    refetch: () => unknown;
+    cancel: () => unknown;
+    refreshing: boolean;
+    queries?: DisclosedQuery[];
+    controls?: ReactNode;
+    emptyFallback: EmptyContent;
+};
+/** The executor is private; declarations expose data composition, not subscription hooks. */
+export declare class DeclaredView<Data, Input, Definition = unknown> {
+    #private;
+    constructor(useResult: () => ViewResult<Data, Input>, definition?: Definition);
+    static definition<Data, Input, Definition>(view: DeclaredView<Data, Input, Definition>): Definition;
+    static useResult<Data, Input>(view: DeclaredView<Data, Input>): ViewResult<Data, Input>;
+}
+export declare function useDeclaredResult<Data, Input>(view: DeclaredView<Data, Input>): ViewResult<Data, Input>;
+export declare const PrimaryViewContext: import("react").Context<{
+    declaration: object;
+    result: ViewResult<unknown, unknown>;
+} | null>;
+export declare function getViewDefinition<Data, Input, Definition>(view: DeclaredView<Data, Input, Definition>): Definition;

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

@@ -1,3 +1,4 @@
+import type { DataContext } from './ui/data-context.js';
 import type { EmptyContent } from './ui/presentation.js';
 import type { AppVariableValues, DateRangeVariable, VariableCollection } from '../core/variables.js';
 import type { DateRangeRequest } from '../core/contract.js';
@@ -16,21 +17,37 @@ export type ViewDate<Variables extends VariableCollection, Input> = {
 export type ViewBindings<Variables extends VariableCollection, Input> = Partial<{
     [Key in keyof Variables]: (input: Input) => ResolvedVariables<Variables>[Key];
 }>;
+type SameViewInput<Variables extends VariableCollection, Input> = [
+    ResolvedVariables<Variables>
+] extends [Input] ? [Input] extends [ResolvedVariables<Variables>] ? [Input] extends [Record<string, never>] ? true : [keyof Input] extends [keyof Variables] ? true : false : false : false;
+type ViewInputMapping<Variables extends VariableCollection, Input> = SameViewInput<Variables, Input> extends true ? {
+    input?: (values: ResolvedVariables<Variables>) => Input;
+} : {
+    input: (values: ResolvedVariables<Variables>) => Input;
+};
 export type DataViewDefinition<Name extends string, Variables extends VariableCollection, Input, Data> = {
     operation: Name;
-    variables: Variables;
-    input: (values: ResolvedVariables<Variables>) => Input;
+    dataContext: DataContext;
     bindings?: ViewBindings<Variables, Input>;
     /** App-owned semantics: measured zero need not mean an empty result. */
     isEmpty: (data: Data) => boolean;
-    empty: EmptyContent;
-} & ({
+    /** Inherited by DataSection unless it supplies its own copy. */
+    emptyFallback: EmptyContent;
+} & (keyof Variables extends never ? {
+    variables?: Variables;
+} : {
+    variables: Variables;
+}) & ViewInputMapping<NoInfer<Variables>, Input> & ({
     date: ViewDate<Variables, Input>;
     describeInput?: (input: Input) => string;
 } | {
     date?: never;
     describeInput: (input: Input) => string;
 });
+export type ResolvedDataViewDefinition<Name extends string, Variables extends VariableCollection, Input, Data> = Omit<DataViewDefinition<Name, Variables, Input, Data>, 'variables' | 'input'> & {
+    variables: Variables;
+    input: (values: ResolvedVariables<Variables>) => Input;
+};
 export declare function describeViewInput<Input>(definition: {
     variables: VariableCollection;
     bindings?: Partial<Record<string, (input: Input) => unknown>>;

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 {};