@vuu-ui/vuu-utils 0.11.2 → 0.12.0

package/types/context-definitions/{DataSourceContext.d.ts → DataContext.d.ts}

@@ -2,7 +2,7 @@ import type { DataSource, DataSourceConstructorProps, ServerAPI, TableSchema } f
 export type DataSourceConstructor = {
     new (props: DataSourceConstructorProps): DataSource;
 };
-export interface DataSourceContextProps {
+export interface DataContextProps {
     VuuDataSource: DataSourceConstructor;
     dataSourceExtensions?: unknown;
     isLocalData: boolean;
@@ -16,4 +16,4 @@ export interface DataSourceContextProps {
      */
     tableSchemas?: Record<string, TableSchema>;
 }
-export declare const DataSourceContext: import("react").Context<DataSourceContextProps>;
+export declare const DataContext: import("react").Context<DataContextProps>;

package/types/context-definitions/DataProvider.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from "react";
+import { DataContextProps } from "./DataContext";
+export declare const DataProvider: ({ children, getServerAPI, isLocalData, VuuDataSource, }: Omit<DataContextProps, "isLocalData"> & {
+    children: ReactNode;
+    isLocalData?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useData: () => DataContextProps;
+export declare const useDataSourceExtensions: () => unknown;

package/types/context-definitions/DataSourceProvider.d.ts

@@ -1,8 +1,12 @@
+import { DataSource } from "@vuu-ui/vuu-data-types";
 import { ReactNode } from "react";
-import { DataSourceContextProps } from "./DataSourceContext";
-export declare const DataSourceProvider: ({ children, getServerAPI, isLocalData, VuuDataSource, }: Omit<DataSourceContextProps, "isLocalData"> & {
+export interface DataSourceContextProps {
+    dataSource?: DataSource;
+}
+export declare const DataSourceContext: import("react").Context<DataSourceContextProps>;
+export declare const DataSourceProvider: ({ children, dataSource, }: {
     children: ReactNode;
-    isLocalData?: boolean;
+    dataSource: DataSource;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const useDataSource: () => DataSourceContextProps;
-export declare const useDataSourceExtensions: () => unknown;
+export declare function useDataSource(throwIfNoDataSource: true): DataSource;
+export declare function useDataSource(throwIfNoDataSource: false | undefined): DataSource | undefined;

package/types/datasource/BaseDataSource.d.ts

@@ -1,22 +1,23 @@
-import type { DataSource, DataSourceConfig, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, SubscribeCallback, SubscribeProps, WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
+import type { DataSource, DataSourceConfig, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceSubscribeCallback, DataSourceSubscribeProps, WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
 import { LinkDescriptorWithLabel, VuuAggregation, VuuRange, VuuSort } from "@vuu-ui/vuu-protocol-types";
 import { EventEmitter } from "../event-emitter";
 import { DataSourceConfigChanges } from "./datasource-utils";
+import { Range } from "../range-utils";
 export type RuntimeConfig = WithBaseFilter<WithFullConfig> & {
     visualLink?: LinkDescriptorWithLabel;
 };
 export declare abstract class BaseDataSource extends EventEmitter<DataSourceEvents> implements Pick<DataSource, "config"> {
     #private;
     viewport: string;
-    protected _clientCallback: SubscribeCallback | undefined;
+    protected _clientCallback: DataSourceSubscribeCallback | undefined;
     protected _config: RuntimeConfig;
     protected _impendingConfig: RuntimeConfig | undefined;
-    protected _range: VuuRange;
+    protected _range: Range;
     protected _size: number;
     protected _title: string | undefined;
     private awaitingConfirmationOfConfigChanges;
     constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, sort, title, viewport, }: Omit<DataSourceConstructorProps, "table">);
-    subscribe({ baseFilterSpec, columns, aggregations, range, sort, groupBy, filterSpec, viewport, }: SubscribeProps, callback: SubscribeCallback): void;
+    subscribe({ baseFilterSpec, columns, aggregations, range, sort, groupBy, filterSpec, viewport, }: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): void;
     get aggregations(): VuuAggregation[];
     set aggregations(aggregations: VuuAggregation[]);
     get baseFilter(): DataSourceFilter | undefined;
@@ -32,8 +33,8 @@ export declare abstract class BaseDataSource extends EventEmitter<DataSourceEven
     set impendingConfig(config: WithBaseFilter<WithFullConfig>);
     get pageCount(): number;
     set pageCount(pageCount: number);
-    get range(): VuuRange;
-    set range(range: VuuRange);
+    get range(): Range;
+    set range(range: Range);
     get size(): number;
     set size(size: number);
     get sort(): VuuSort;

package/types/filters/filter-utils.d.ts

@@ -45,10 +45,11 @@ export declare const stripFilterFromColumns: (columns: RuntimeColumnDescriptor[]
     colHeaderContentRenderer?: string;
     colHeaderLabelRenderer?: string;
     getIcon?: (row: import("@vuu-ui/vuu-data-types").DataSourceRow) => string | undefined;
+    groupable?: boolean;
     hidden?: boolean;
     maxWidth?: number;
     minWidth?: number;
-    pin?: import("@vuu-ui/vuu-table-types").PinLocation;
+    pin?: import("@vuu-ui/vuu-table-types").PinLocation | false;
     source?: "client" | "server";
     editable?: boolean;
     editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit;

package/types/group-utils.d.ts

@@ -1,3 +1,10 @@
-import { RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
 import { VuuGroupBy } from "@vuu-ui/vuu-protocol-types";
-export declare function addGroupColumn(groupBy: VuuGroupBy, column: RuntimeColumnDescriptor): string[];
+export declare function addGroupColumn(groupBy: VuuGroupBy, column: ColumnDescriptor): string[];
+export declare const removeGroupColumn: (groupBy: VuuGroupBy, column: ColumnDescriptor) => string[];
+export type ColumnGroupStatus = "no-groupby" | "single-groupby-other-column" | "single-groupby" | "multi-groupby-other-columns" | "multi-groupby-includes-column";
+/**
+ * Given a VuuGroupby definition and a column, determine whether the given column
+ * is included in the grouping and if so, in what position/direction.
+ */
+export declare const getGroupStatus: (columnName: string, groupBy?: VuuGroupBy) => ColumnGroupStatus;

package/types/index.d.ts

@@ -61,6 +61,7 @@ export * from "./user-types";
 export * from "./useLayoutEffectSkipFirst";
 /** Context declarations hosted in utils to minimize intra package dependencies */
 export * from "./ShellContext";
-export * from "./context-definitions/DataSourceContext";
-export * from "./context-definitions/DataSourceProvider";
+export * from "./context-definitions/DataContext";
+export * from "./context-definitions/DataProvider";
+export { DataSourceProvider, useDataSource, } from "./context-definitions/DataSourceProvider";
 export * from "./context-definitions/WorkspaceContext";

package/types/logging-utils.d.ts

@@ -41,4 +41,5 @@ export declare const logger: (category: string) => {
     error: (message: string) => void;
 };
 export declare const getLoggingConfigForWorker: () => string;
+export declare const logUnhandledMessage: (message: never, context?: string) => void;
 export {};

package/types/menu-utils.d.ts

@@ -1,22 +1,6 @@
-import { ContextMenuGroupItemDescriptor, ContextMenuItemDescriptor, DataSourceRow, MenuRpcResponse, OpenDialogActionWithSchema } from "@vuu-ui/vuu-data-types";
-import { ShowNotificationAction, VuuMenu, VuuMenuItem, VuuRpcMenuRequest, VuuRpcResponse } from "@vuu-ui/vuu-protocol-types";
-import { ColumnDescriptor, TableMenuLocation, VuuCellMenuItem, VuuRowMenuItem } from "@vuu-ui/vuu-table-types";
-import { type ColumnMap } from "./column-utils";
-export type VuuServerMenuOptions = {
-    columnMap: ColumnMap;
-    columnName: string;
-    columns: ColumnDescriptor[];
-    row: DataSourceRow;
-    selectedRows: DataSourceRow[];
-    viewport: string;
-};
-export declare const isRoot: (menu: VuuMenu) => boolean;
-export declare const isCellMenu: (options: VuuMenuItem) => options is VuuCellMenuItem;
-export declare const isRowMenu: (options: VuuMenuItem) => options is VuuRowMenuItem;
-export declare const isSelectionMenu: (options: VuuMenuItem) => options is VuuMenuItem;
+import { MenuRpcResponse, OpenDialogActionWithSchema } from "@vuu-ui/vuu-data-types";
+import { ShowNotificationAction, VuuRpcResponse } from "@vuu-ui/vuu-protocol-types";
+import { ContextMenuGroupItemDescriptor, ContextMenuItemDescriptor } from "@vuu-ui/vuu-context-menu";
 export declare const isGroupMenuItemDescriptor: (menuItem?: ContextMenuItemDescriptor) => menuItem is ContextMenuGroupItemDescriptor;
-export declare const isTableLocation: (location: string) => location is TableMenuLocation;
-export declare const buildMenuDescriptorFromVuuMenu: (menu: VuuMenu | VuuMenuItem, tableLocation: TableMenuLocation, options: VuuServerMenuOptions) => ContextMenuItemDescriptor | undefined;
-export declare const getMenuRpcRequest: (options: VuuMenuItem) => Omit<VuuRpcMenuRequest, "vpId">;
 export declare const isOpenBulkEditResponse: (rpcResponse: Partial<VuuRpcResponse>) => rpcResponse is MenuRpcResponse<OpenDialogActionWithSchema>;
 export declare const hasShowNotificationAction: (res: Partial<VuuRpcResponse>) => res is MenuRpcResponse<ShowNotificationAction>;

package/types/moving-window.d.ts

@@ -1,6 +1,6 @@
 import { DataSourceRow } from "@vuu-ui/vuu-data-types";
-import { WindowRange } from "@vuu-ui/vuu-utils";
 import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+import { WindowRange } from "./range-utils";
 export declare class MovingWindow {
     #private;
     data: DataSourceRow[];

package/types/range-utils.d.ts

@@ -1,17 +1,23 @@
-export interface VuuRange {
-    from: number;
-    to: number;
-    bufferSize?: number;
-    reset?: boolean;
-}
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
 interface FromToRange {
     from: number;
     to: number;
 }
-export declare const NULL_RANGE: VuuRange;
-export declare const rangesAreSame: (r1: VuuRange | undefined, r2: VuuRange | undefined) => boolean;
+export interface Range extends VuuRange {
+    equals: (vuuRange: VuuRange) => boolean;
+    firstRowInViewport: number;
+    lastRowInViewport: number;
+    renderBufferSize?: number;
+    reset: Range;
+    rowCount?: number;
+}
+export interface RangeOptions {
+    renderBufferSize?: number;
+    rowCount?: number;
+}
+export declare const Range: (from: number, to: number, rangeOptions?: RangeOptions) => Range;
+export declare const NULL_RANGE: Range;
 export declare function getFullRange({ from, to }: VuuRange, bufferSize?: number, totalRowCount?: number): FromToRange;
-export declare function resetRange({ from, to, bufferSize }: VuuRange): VuuRange;
 export declare const withinRange: (value: number, { from, to }: VuuRange) => boolean;
 export declare const rangeNewItems: ({ from: from1, to: to1 }: VuuRange, newRange: VuuRange) => VuuRange;
 export declare class WindowRange {

package/types/sort-utils.d.ts

@@ -1,5 +1,11 @@
-import { ColumnDescriptor, RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
 import { VuuSort, VuuSortType } from "@vuu-ui/vuu-protocol-types";
 export declare const toggleOrApplySort: ({ sortDefs }: VuuSort, { name: column }: ColumnDescriptor, extendSort?: boolean, sortType?: VuuSortType) => VuuSort;
-export declare const setSortColumn: ({ sortDefs }: VuuSort, column: RuntimeColumnDescriptor, sortType?: "A" | "D") => VuuSort;
-export declare const addSortColumn: ({ sortDefs }: VuuSort, column: RuntimeColumnDescriptor, sortType?: "A" | "D") => VuuSort;
+export declare const setSortColumn: ({ sortDefs }: VuuSort, column: ColumnDescriptor, sortType?: "A" | "D") => VuuSort;
+export declare const addSortColumn: ({ sortDefs }: VuuSort, column: ColumnDescriptor, sortType?: "A" | "D") => VuuSort;
+export type ColumnSortStatus = "no-sort" | "sort-other-column" | "single-sort-asc" | "single-sort-desc" | "multi-sort-includes-column-asc" | "multi-sort-includes-column-desc";
+/**
+ * Given a VuuSort definition and a column, determine whether the given column
+ * is included in the sort and if so, in what position/direction.
+ */
+export declare const getSortStatus: (columnName: string, vuuSort?: VuuSort) => ColumnSortStatus;

package/cjs/context-definitions/DataSourceContext.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var React = require('react');
-
-const getServerAPI = () => {
-  throw Error("no DataSourceProvider has been installed");
-};
-class NullDataSource {
-  constructor(_) {
-    throw Error("no DataSourceProvider has been installed");
-  }
-}
-const DataSourceContext = React.createContext({
-  isLocalData: false,
-  getServerAPI,
-  VuuDataSource: NullDataSource
-});
-
-exports.DataSourceContext = DataSourceContext;
-//# sourceMappingURL=DataSourceContext.js.map

package/cjs/context-definitions/DataSourceContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataSourceContext.js","sources":["../../src/context-definitions/DataSourceContext.tsx"],"sourcesContent":["import type {\n  DataSource,\n  DataSourceConstructorProps,\n  ServerAPI,\n  TableSchema,\n} from \"@vuu-ui/vuu-data-types\";\nimport { createContext } from \"react\";\n\nexport type DataSourceConstructor = {\n  new (props: DataSourceConstructorProps): DataSource;\n};\n\nexport interface DataSourceContextProps {\n  VuuDataSource: DataSourceConstructor;\n  dataSourceExtensions?: unknown;\n  isLocalData: boolean;\n  getServerAPI: () => Promise<\n    Pick<ServerAPI, \"getTableList\" | \"getTableSchema\" | \"rpcCall\">\n  >;\n  /**\n   * A tableSchema would normally be requested via the serverAPI.\n   * schemas can be injected, in which case these 'local' schemas\n   * will be returned from the getTableSchema API call.\n   * The key is formed from concatenation of module and tableName\n   * from VuuTable e.g 'SIMUL:instruments'\n   */\n  tableSchemas?: Record<string, TableSchema>;\n}\n\nconst getServerAPI = () => {\n  throw Error(\"no DataSourceProvider has been installed\");\n};\n\nclass NullDataSource {\n  constructor(_: DataSourceConstructorProps) {\n    throw Error(\"no DataSourceProvider has been installed\");\n  }\n}\n\nexport const DataSourceContext = createContext<DataSourceContextProps>({\n  isLocalData: false,\n  getServerAPI,\n  VuuDataSource: NullDataSource as DataSourceConstructor,\n});\n"],"names":["createContext"],"mappings":";;;;AA6BA,MAAM,eAAe,MAAM;AACzB,EAAA,MAAM,MAAM,0CAA0C,CAAA;AACxD,CAAA;AAEA,MAAM,cAAe,CAAA;AAAA,EACnB,YAAY,CAA+B,EAAA;AACzC,IAAA,MAAM,MAAM,0CAA0C,CAAA;AAAA;AAE1D;AAEO,MAAM,oBAAoBA,mBAAsC,CAAA;AAAA,EACrE,WAAa,EAAA,KAAA;AAAA,EACb,YAAA;AAAA,EACA,aAAe,EAAA;AACjB,CAAC;;;;"}

package/esm/context-definitions/DataSourceContext.js

@@ -1,18 +0,0 @@
-import { createContext } from 'react';
-
-const getServerAPI = () => {
-  throw Error("no DataSourceProvider has been installed");
-};
-class NullDataSource {
-  constructor(_) {
-    throw Error("no DataSourceProvider has been installed");
-  }
-}
-const DataSourceContext = createContext({
-  isLocalData: false,
-  getServerAPI,
-  VuuDataSource: NullDataSource
-});
-
-export { DataSourceContext };
-//# sourceMappingURL=DataSourceContext.js.map

package/esm/context-definitions/DataSourceContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataSourceContext.js","sources":["../../src/context-definitions/DataSourceContext.tsx"],"sourcesContent":["import type {\n  DataSource,\n  DataSourceConstructorProps,\n  ServerAPI,\n  TableSchema,\n} from \"@vuu-ui/vuu-data-types\";\nimport { createContext } from \"react\";\n\nexport type DataSourceConstructor = {\n  new (props: DataSourceConstructorProps): DataSource;\n};\n\nexport interface DataSourceContextProps {\n  VuuDataSource: DataSourceConstructor;\n  dataSourceExtensions?: unknown;\n  isLocalData: boolean;\n  getServerAPI: () => Promise<\n    Pick<ServerAPI, \"getTableList\" | \"getTableSchema\" | \"rpcCall\">\n  >;\n  /**\n   * A tableSchema would normally be requested via the serverAPI.\n   * schemas can be injected, in which case these 'local' schemas\n   * will be returned from the getTableSchema API call.\n   * The key is formed from concatenation of module and tableName\n   * from VuuTable e.g 'SIMUL:instruments'\n   */\n  tableSchemas?: Record<string, TableSchema>;\n}\n\nconst getServerAPI = () => {\n  throw Error(\"no DataSourceProvider has been installed\");\n};\n\nclass NullDataSource {\n  constructor(_: DataSourceConstructorProps) {\n    throw Error(\"no DataSourceProvider has been installed\");\n  }\n}\n\nexport const DataSourceContext = createContext<DataSourceContextProps>({\n  isLocalData: false,\n  getServerAPI,\n  VuuDataSource: NullDataSource as DataSourceConstructor,\n});\n"],"names":[],"mappings":";;AA6BA,MAAM,eAAe,MAAM;AACzB,EAAA,MAAM,MAAM,0CAA0C,CAAA;AACxD,CAAA;AAEA,MAAM,cAAe,CAAA;AAAA,EACnB,YAAY,CAA+B,EAAA;AACzC,IAAA,MAAM,MAAM,0CAA0C,CAAA;AAAA;AAE1D;AAEO,MAAM,oBAAoB,aAAsC,CAAA;AAAA,EACrE,WAAa,EAAA,KAAA;AAAA,EACb,YAAA;AAAA,EACA,aAAe,EAAA;AACjB,CAAC;;;;"}