@vuu-ui/vuu-data-remote 4.1.0 → 5.0.0-alpha.1

package/src/VuuAuthProvider.js

@@ -1,78 +0,0 @@
-import { getCookieValue } from "@vuu-ui/vuu-utils";
-import { parseVuuUserFromToken } from "./authenticate.js";
-class VuuAuthProvider {
-    authEndpoint;
-    constructor(authEndpoint){
-        this.authEndpoint = authEndpoint;
-    }
-    login = async (username, password)=>{
-        const date = new Date();
-        const days = 1;
-        date.setTime(date.getTime() + 24 * days * 3600000);
-        if (username && password) {
-            const { token } = await this.getVuuTokenWithUsernameAndPassword(username, password);
-            document.cookie = `vuu-auth-user=${username};expires=${date.toUTCString()};path=/`;
-            document.cookie = `vuu-auth-password=${password};expires=${date.toUTCString()};path=/`;
-            document.cookie = `vuu-auth-token=${token};expires=${date.toUTCString()};path=/`;
-            return this.redirectToApplication();
-        }
-        {
-            const userName = getCookieValue("vuu-auth-user");
-            const password = getCookieValue("vuu-auth-password");
-            if (!userName || !password) return this.redirectToLoginPage();
-            {
-                const { authorizations, token } = await this.getVuuTokenWithUsernameAndPassword(userName, password);
-                document.cookie = `vuu-auth-token=${token};expires=${date.toUTCString()};path=/`;
-                return {
-                    authorizations,
-                    user: {
-                        userName
-                    },
-                    token
-                };
-            }
-        }
-    };
-    async getVuuTokenWithUsernameAndPassword(username, password) {
-        const response = await fetch(this.authEndpoint, {
-            method: "POST",
-            credentials: "include",
-            headers: {
-                "Content-Type": "application/json",
-                "access-control-allow-origin": location.host
-            },
-            body: JSON.stringify({
-                username,
-                password
-            })
-        });
-        if (response.ok) {
-            const vuuAuthToken = response.headers.get("vuu-auth-token");
-            if ("string" == typeof vuuAuthToken && vuuAuthToken.length > 0) {
-                const { authorizations } = parseVuuUserFromToken(vuuAuthToken);
-                return {
-                    authorizations,
-                    token: vuuAuthToken
-                };
-            }
-            throw Error("Authentication failed auth token not returned by server");
-        }
-        throw Error(`Authentication failed, ${response.status}`);
-    }
-    clear() {
-        document.cookie = "vuu-auth-user= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
-        document.cookie = "vuu-auth-password= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
-        document.cookie = "vuu-auth-token= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
-    }
-    redirectToLoginPage() {
-        window.location.href = "login.html";
-    }
-    redirectToApplication() {
-        window.location.href = "index.html";
-    }
-    logout() {
-        this.clear();
-        this.redirectToLoginPage();
-    }
-}
-export { VuuAuthProvider };

package/src/VuuAuthenticator.js

@@ -1,36 +0,0 @@
-import ConnectionManager from "./ConnectionManager.js";
-const VuuAuthTokenIssuePolicy = {
-    BearerToken: "bearer-token",
-    UsernamePassword: "username-password"
-};
-class VuuAuthenticator {
-    authProvider;
-    authTokenIssuePolicy;
-    websocketUrl;
-    constructor({ authProvider, authTokenIssuePolicy = VuuAuthTokenIssuePolicy.BearerToken, websocketUrl }){
-        this.authProvider = authProvider;
-        this.authTokenIssuePolicy = authTokenIssuePolicy;
-        this.websocketUrl = websocketUrl;
-    }
-    openWebsocketConnection = async (vuuToken)=>{
-        await ConnectionManager.connect({
-            url: this.websocketUrl,
-            token: vuuToken
-        }, true);
-    };
-    login = async ()=>{
-        const { authorizations, user, token, websocket = true } = await this.authProvider.login();
-        if (token && user) {
-            if (websocket) await this.openWebsocketConnection(token);
-            return [
-                user,
-                authorizations
-            ];
-        }
-        throw Error("[VuuAuthenticator] login failed");
-    };
-    logout = ()=>{
-        this.authProvider.logout();
-    };
-}
-export { VuuAuthTokenIssuePolicy, VuuAuthenticator };

package/src/authenticate.js

@@ -1,50 +0,0 @@
-const defaultAuthUrl = "api/authn";
-const isValidVuuUser = (response)=>"object" == typeof response && null !== response && "name" in response && "authorizations" in response && "string" == typeof response.name && Array.isArray(response.authorizations);
-const parseVuuUserFromToken = (token)=>{
-    const [base64EncodedVuuUser] = token.split(".");
-    const jsonString = atob(base64EncodedVuuUser);
-    const response = JSON.parse(jsonString);
-    if (isValidVuuUser(response)) return response;
-    throw Error("auth token does not containe VuuUser");
-};
-const getVuuAuthToken = async (authUrl, token)=>{
-    const response = await fetch(authUrl, {
-        headers: {
-            Authorization: `Bearer ${token}`
-        }
-    });
-    if (!response.ok) throw Error("Authentication error: Auth token failure");
-    const json = await response.json();
-    const vuuUser = parseVuuUserFromToken(json.token);
-    return {
-        authorizations: vuuUser.authorizations,
-        token: json.token
-    };
-};
-const authenticate = async (username, password, authUrl = defaultAuthUrl)=>fetch(authUrl, {
-        method: "POST",
-        credentials: "include",
-        headers: {
-            "Content-Type": "application/json",
-            "access-control-allow-origin": location.host
-        },
-        body: JSON.stringify({
-            username,
-            password
-        })
-    }).then((response)=>{
-        if (response.ok) {
-            const authToken = response.headers.get("vuu-auth-token");
-            if ("string" == typeof authToken && authToken.length > 0) try {
-                return {
-                    token: authToken,
-                    user: parseVuuUserFromToken(authToken)
-                };
-            } catch (e) {
-                throw Error("Authentication error:  vuu auth token decoding failed.");
-            }
-            throw Error("Authentication failed auth token not returned by server");
-        }
-        throw Error(`Authentication failed ${response.status} ${response.statusText}`);
-    });
-export { authenticate, getVuuAuthToken, parseVuuUserFromToken };

package/types/LostConnectionHandler.d.ts

@@ -1,28 +0,0 @@
-import { VuuAuthenticator } from "./VuuAuthenticator";
-interface RetryOptions {
-    interval: number;
-    next: () => void;
-    remaining: number;
-}
-declare class RetryOptionsImpl implements RetryOptions {
-    private retryIntervals;
-    private ind;
-    constructor(retryIntervals: number[]);
-    next(): void;
-    get remaining(): number;
-    get interval(): number;
-}
-export declare function RetryOptions(retryIntervals: number[]): RetryOptionsImpl;
-export declare class RetryGenerator {
-    private vuuAuth;
-    private options;
-    constructor(vuuAuth: VuuAuthenticator, options: RetryOptions);
-    [Symbol.asyncIterator](): AsyncGenerator<"connected" | "connection-failed">;
-}
-export declare class LostConnectionHandler {
-    private vuuAuth;
-    private retryIntervals;
-    constructor(vuuAuth: VuuAuthenticator, retryIntervals?: number[]);
-    reconnect(): Promise<"connected" | "connection-failed">;
-}
-export {};

package/types/VuuAuthProvider.d.ts

@@ -1,39 +0,0 @@
-export type User = {
-    userName: string;
-};
-export interface AuthProvider {
-    login: (username?: string, password?: string) => Promise<{
-        authorizations: string[];
-        token: string;
-        user: User;
-        websocket?: boolean;
-    }>;
-    logout: () => void;
-}
-/**
- * The Vuu AuthProvider is a simple Demoware auth provider that
- * grabs username and pasdsword from. a simple login form and
- * exchanges these for a Vuu Token. Password is manipulated in
- * plain text, hence not suitable for real world usage.
- *
- * This AuthProvider is used by the login panel, which sets
- * user credentials in cookies.
- * It is then used by the application itself to retrieve the
- * credentials and login to vuu.
- */
-export declare class VuuAuthProvider implements AuthProvider {
-    private authEndpoint;
-    constructor(authEndpoint: string);
-    login: (username?: string, password?: string) => Promise<{
-        authorizations: string[];
-        user: {
-            userName: string;
-        };
-        token: string;
-    }>;
-    private getVuuTokenWithUsernameAndPassword;
-    private clear;
-    private redirectToLoginPage;
-    private redirectToApplication;
-    logout(): void;
-}

package/types/VuuAuthenticator.d.ts

@@ -1,21 +0,0 @@
-import { ValueOf } from "@vuu-ui/vuu-utils";
-import { User, type AuthProvider } from "./VuuAuthProvider";
-export declare const VuuAuthTokenIssuePolicy: {
-    readonly BearerToken: "bearer-token";
-    readonly UsernamePassword: "username-password";
-};
-export type VuuAuthTokenIssuePolicy = ValueOf<typeof VuuAuthTokenIssuePolicy>;
-export interface VuuAuthenticatorConstructorOptions {
-    authProvider: AuthProvider;
-    authTokenIssuePolicy?: VuuAuthTokenIssuePolicy;
-    websocketUrl: string;
-}
-export declare class VuuAuthenticator {
-    private authProvider;
-    private authTokenIssuePolicy;
-    private websocketUrl;
-    constructor({ authProvider, authTokenIssuePolicy, websocketUrl, }: VuuAuthenticatorConstructorOptions);
-    private openWebsocketConnection;
-    login: () => Promise<[User, string[]] | never>;
-    logout: () => void;
-}

package/types/authenticate.d.ts

@@ -1,15 +0,0 @@
-import type { VuuUser } from "@vuu-ui/vuu-protocol-types";
-/**
- * The auth token returned from authn call encodes (Base64) a VuuUser
- * within the first part of the token.
- */
-export declare const parseVuuUserFromToken: (token: string) => VuuUser;
-export type AuthenticationResponse = {
-    token: string;
-    user: VuuUser;
-};
-export declare const getVuuAuthToken: (authUrl: string, token: string) => Promise<{
-    authorizations: string[];
-    token: string;
-}>;
-export declare const authenticate: (username: string, password: string, authUrl?: string) => Promise<AuthenticationResponse>;

package/types/src/ConnectionManager.d.ts

@@ -1,36 +0,0 @@
-import { ConnectOptions, DataSourceCallbackMessage, ServerAPI } from "@vuu-ui/vuu-data-types";
-import { EventEmitter } from "@vuu-ui/vuu-utils";
-import { ConnectionStatus, WebSocketConnectionEvents } from "./WebSocketConnection";
-import { ConnectionQualityMetrics } from "@vuu-ui/vuu-data-types";
-export type PostMessageToClientCallback = (msg: DataSourceCallbackMessage) => void;
-export type ConnectionEvents = WebSocketConnectionEvents & {
-    "connection-metrics": (message: ConnectionQualityMetrics) => void;
-};
-declare class ConnectionManager extends EventEmitter<ConnectionEvents> {
-    #private;
-    private constructor();
-    static get instance(): ConnectionManager;
-    get connectionStatus(): ConnectionStatus;
-    get connected(): boolean;
-    /**
-     * Open a connection to the VuuServer. This method opens the websocket connection
-     * and logs in. It can be called from whichever client code has access to the auth
-     * token (eg. the login page, or just a hardcoded login script in a sample).
-     * This will unblock any DataSources which may have already tried to subscribe to data,
-     * but lacked access to the auth token.
-     *
-     * @param serverUrl
-     * @param token
-     */
-    connect(options: ConnectOptions, throwOnRejected?: boolean): Promise<"connected" | "connection-failed" | "reconnected" | "rejected">;
-    disableActiveSubscriptions(): void;
-    enableActiveSubscriptions(): void;
-    private handleMessageFromWorker;
-    get serverAPI(): Promise<ServerAPI>;
-    private connectedServerAPI;
-    private asyncRequest;
-    disconnect(): Promise<"disconnected" | "rejected">;
-    destroy(): void;
-}
-declare const _default: ConnectionManager;
-export default _default;

package/types/src/DedicatedWorker.d.ts

@@ -1,9 +0,0 @@
-import { ConnectOptions, VuuUIMessageIn, VuuUIMessageOut, WithRequestId } from "@vuu-ui/vuu-data-types";
-import { SelectRequest, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcMenuRequest, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
-export declare class DedicatedWorker {
-    #private;
-    constructor(onMessage: (msg: VuuUIMessageIn) => void);
-    connect(options: ConnectOptions): Promise<"connected" | "reconnected" | "rejected">;
-    send(message: VuuUIMessageOut | WithRequestId<VuuCreateVisualLink | VuuRemoveVisualLink | VuuRpcServiceRequest | VuuRpcMenuRequest | SelectRequest>): Promise<void>;
-    terminate(): Promise<void>;
-}

package/types/src/LostConnectionHandler.d.ts

@@ -1,28 +0,0 @@
-import { VuuAuthenticator } from "./VuuAuthenticator";
-interface RetryOptions {
-    interval: number;
-    next: () => void;
-    remaining: number;
-}
-declare class RetryOptionsImpl implements RetryOptions {
-    private retryIntervals;
-    private ind;
-    constructor(retryIntervals: number[]);
-    next(): void;
-    get remaining(): number;
-    get interval(): number;
-}
-export declare function RetryOptions(retryIntervals: number[]): RetryOptionsImpl;
-export declare class RetryGenerator {
-    private vuuAuth;
-    private options;
-    constructor(vuuAuth: VuuAuthenticator, options: RetryOptions);
-    [Symbol.asyncIterator](): AsyncGenerator<"connected" | "connection-failed">;
-}
-export declare class LostConnectionHandler {
-    private vuuAuth;
-    private retryIntervals;
-    constructor(vuuAuth: VuuAuthenticator, retryIntervals?: number[]);
-    reconnect(): Promise<"connected" | "connection-failed">;
-}
-export {};

package/types/src/VuuAuthProvider.d.ts

@@ -1,39 +0,0 @@
-export type User = {
-    userName: string;
-};
-export interface AuthProvider {
-    login: (username?: string, password?: string) => Promise<{
-        authorizations: string[];
-        token: string;
-        user: User;
-        websocket?: boolean;
-    }>;
-    logout: () => void;
-}
-/**
- * The Vuu AuthProvider is a simple Demoware auth provider that
- * grabs username and pasdsword from. a simple login form and
- * exchanges these for a Vuu Token. Password is manipulated in
- * plain text, hence not suitable for real world usage.
- *
- * This AuthProvider is used by the login panel, which sets
- * user credentials in cookies.
- * It is then used by the application itself to retrieve the
- * credentials and login to vuu.
- */
-export declare class VuuAuthProvider implements AuthProvider {
-    private authEndpoint;
-    constructor(authEndpoint: string);
-    login: (username?: string, password?: string) => Promise<{
-        authorizations: string[];
-        user: {
-            userName: string;
-        };
-        token: string;
-    }>;
-    private getVuuTokenWithUsernameAndPassword;
-    private clear;
-    private redirectToLoginPage;
-    private redirectToApplication;
-    logout(): void;
-}

package/types/src/VuuAuthenticator.d.ts

@@ -1,21 +0,0 @@
-import { ValueOf } from "@vuu-ui/vuu-utils";
-import { User, type AuthProvider } from "./VuuAuthProvider";
-export declare const VuuAuthTokenIssuePolicy: {
-    readonly BearerToken: "bearer-token";
-    readonly UsernamePassword: "username-password";
-};
-export type VuuAuthTokenIssuePolicy = ValueOf<typeof VuuAuthTokenIssuePolicy>;
-export interface VuuAuthenticatorConstructorOptions {
-    authProvider: AuthProvider;
-    authTokenIssuePolicy?: VuuAuthTokenIssuePolicy;
-    websocketUrl: string;
-}
-export declare class VuuAuthenticator {
-    private authProvider;
-    private authTokenIssuePolicy;
-    private websocketUrl;
-    constructor({ authProvider, authTokenIssuePolicy, websocketUrl, }: VuuAuthenticatorConstructorOptions);
-    private openWebsocketConnection;
-    login: () => Promise<[User, string[]] | never>;
-    logout: () => void;
-}

package/types/src/VuuDataSource.d.ts

@@ -1,74 +0,0 @@
-import type { CopyOption, DataSource, DataSourceBase, SessionType, DataSourceCallbackMessage, DataSourceConstructorProps, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, DeleteRowMode, OptimizeStrategy, SessionDataSourceOverrides, TableSchema, WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
-import type { MenuRpcResponse } from "@vuu-ui/vuu-data-types";
-import type { LinkDescriptorWithLabel, RpcResult, RpcResultError, RpcResultSuccess, SelectRequest, VuuGroupBy, VuuMenu, VuuRange, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcResponse, VuuRpcServiceRequest, VuuTable } from "@vuu-ui/vuu-protocol-types";
-import { BaseDataSource, Range } from "@vuu-ui/vuu-utils";
-type RangeRequest = (range: VuuRange) => void;
-export declare class VuuDataSource extends BaseDataSource implements DataSourceBase {
-    #private;
-    private bufferSize;
-    private server;
-    rangeRequest: RangeRequest;
-    readonly isRemote = true;
-    table: VuuTable;
-    constructor({ session, sessionTableMessageColumn, ...props }: DataSourceConstructorProps);
-    subscribe(subscribeProps: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
-    handleMessageFromServer: (message: DataSourceCallbackMessage) => void;
-    handleSessionMessageFromServer: (msg: DataSourceCallbackMessage) => void;
-    unsubscribe(): void;
-    suspend(escalateToDisable?: boolean, escalateDelay?: number | undefined): void;
-    /**
-     * Tell the server we wish to resume receiving messages. Server will send a
-     * snapshot of rows currently in cache. This can be used to update with
-     * latest data, e.g after an edit session during which we might have ignored
-     * some updates.
-     */
-    private sendResumeMessage;
-    isSessionDataSourceOf(dataSource: DataSource): boolean;
-    resume(callback?: DataSourceSubscribeCallback): void;
-    freeze(): void;
-    unfreeze(): void;
-    disable(): void;
-    enable(callback?: DataSourceSubscribeCallback): void;
-    select(selectRequest: Omit<SelectRequest, "vpId">): Promise<void>;
-    openTreeNode(keyOrIndex: string | number): void;
-    closeTreeNode(keyOrIndex: string | number): void;
-    get columns(): string[];
-    set columns(columns: string[]);
-    get tableSchema(): TableSchema | undefined;
-    set tableSchema(tableSchema: TableSchema | undefined);
-    get links(): LinkDescriptorWithLabel[] | undefined;
-    get maxRangeEnd(): number;
-    get menu(): VuuMenu | undefined;
-    get status(): DataSourceStatus;
-    get optimize(): OptimizeStrategy;
-    set optimize(optimize: OptimizeStrategy);
-    private revertDebounce;
-    get selectedRowsCount(): number;
-    private rawRangeRequest;
-    private debounceRangeRequest;
-    private throttleRangeRequest;
-    get config(): WithBaseFilter<WithFullConfig>;
-    set config(config: WithBaseFilter<WithFullConfig>);
-    set impendingConfig(config: WithBaseFilter<WithFullConfig>);
-    get groupBy(): VuuGroupBy;
-    set groupBy(groupBy: VuuGroupBy);
-    get range(): Range;
-    set range(range: Range);
-    get title(): string;
-    set title(title: string);
-    get visualLink(): LinkDescriptorWithLabel | undefined;
-    set visualLink(visualLink: LinkDescriptorWithLabel | undefined);
-    remoteProcedureCall<T extends VuuRpcResponse = VuuRpcResponse>(): Promise<T>;
-    createSessionDataSource(copyOption: CopyOption, sessionType?: SessionType, overrides?: SessionDataSourceOverrides): Promise<VuuDataSource | undefined>;
-    beginEditSession(): Promise<VuuDataSource>;
-    editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultError | RpcResultSuccess>;
-    endEditSession(saveChanges?: boolean, force?: boolean): Promise<void>;
-    rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultError | RpcResultSuccess>;
-    menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<MenuRpcResponse<any> | undefined>;
-    insertRow(): Promise<string>;
-    deleteRow(key: string, mode?: DeleteRowMode): Promise<true | string>;
-    deleteSelectedRows(mode?: DeleteRowMode): Promise<RpcResultSuccess | RpcResultError>;
-    addRow(rowData?: Record<string, VuuRowDataItemType>): Promise<RpcResult>;
-    undoRowChange(key: string): Promise<RpcResultSuccess | RpcResultError>;
-}
-export {};

package/types/src/WebSocketConnection.d.ts

@@ -1,54 +0,0 @@
-import { WebSocketProtocol } from "@vuu-ui/vuu-data-types";
-import { InvalidSessionReason, InvalidTokenReason, LoginErrorMessage, VuuClientMessage, VuuServerMessage } from "@vuu-ui/vuu-protocol-types";
-import { EventEmitter } from "@vuu-ui/vuu-utils";
-export type ConnectionPhase = "initial-connection" | "post-disconnect-reconnection";
-export type ConnectingStatus = "connecting" | "reconnecting";
-export type ConnectedStatus = "connected" | "reconnected";
-export type ConnectionStatus = ConnectingStatus | ConnectedStatus | "closed" | "websocket-open" | "disconnected" | "failed" | "inactive";
-export declare const isInvalidTokenReason: (text: string) => text is InvalidTokenReason;
-export declare const isInvalidSessionReason: (text: string) => text is InvalidSessionReason;
-export declare const isWebSocketConnectionStatus: (msg: unknown) => msg is ConnectionStatus;
-export declare const isConnected: (status: ConnectionStatus) => status is ConnectedStatus;
-export type LoginRejectedMessage = {
-    type: "LOGIN_REJECTED";
-    reason: LoginErrorMessage;
-};
-export declare const isLoginRejectedMessage: (message: object) => message is LoginRejectedMessage;
-export type VuuServerMessageCallback = (msg: VuuServerMessage | LoginRejectedMessage) => void;
-export type WebSocketConnectionConfig = {
-    url: string;
-    protocols: WebSocketProtocol;
-    callback: VuuServerMessageCallback;
-    connectionTimeout?: number;
-};
-export type WebSocketConnectionCloseReason = LoginErrorMessage | "failure" | "shutdown";
-export type WebSocketConnectionEvents = {
-    "connection-status": (status: ConnectionStatus) => void;
-};
-export declare class WebSocketConnection extends EventEmitter<WebSocketConnectionEvents> {
-    #private;
-    constructor({ callback, connectionTimeout, protocols, url, }: WebSocketConnectionConfig);
-    get connectionTimeout(): number;
-    get protocols(): WebSocketProtocol;
-    get isClosed(): boolean;
-    get isDisconnected(): boolean;
-    get connectionPhase(): ConnectionPhase;
-    get connectionStatus(): ConnectionStatus;
-    private set connectionStatus(value);
-    get confirmedOpen(): boolean;
-    /**
-     * We are 'confirmedOpen' when we see the first message transmitted
-     * from the server. This ensures that even if we have one or more
-     * proxies in our route to the endPoint, all connections have been
-     * opened successfully.
-     * First time in here (on our initial successful connection) we switch
-     * from 'connect' phase to 'reconnect' phase. We may have different
-     * retry configurations for these two phases.
-     */
-    private set confirmedOpen(value);
-    get url(): string;
-    openWebSocket(): Promise<unknown>;
-    private receive;
-    send: (msg: VuuClientMessage) => void;
-    close(reason?: WebSocketConnectionCloseReason): void;
-}

package/types/src/authenticate.d.ts

@@ -1,15 +0,0 @@
-import type { VuuUser } from "@vuu-ui/vuu-protocol-types";
-/**
- * The auth token returned from authn call encodes (Base64) a VuuUser
- * within the first part of the token.
- */
-export declare const parseVuuUserFromToken: (token: string) => VuuUser;
-export type AuthenticationResponse = {
-    token: string;
-    user: VuuUser;
-};
-export declare const getVuuAuthToken: (authUrl: string, token: string) => Promise<{
-    authorizations: string[];
-    token: string;
-}>;
-export declare const authenticate: (username: string, password: string, authUrl?: string) => Promise<AuthenticationResponse>;

package/types/src/constants.d.ts

@@ -1,41 +0,0 @@
-export declare const connectionId: {
-    readonly nextValue: number;
-};
-export declare const msgType: {
-    connect: string;
-    connectionStatus: string;
-    getFilterData: string;
-    rowData: string;
-    rowSet: string;
-    select: string;
-    selectAll: string;
-    selectNone: string;
-    selected: string;
-    snapshot: string;
-    update: string;
-    createLink: string;
-    disable: string;
-    enable: string;
-    suspend: string;
-    resume: string;
-    addSubscription: string;
-    closeTreeNode: string;
-    columnList: string;
-    data: string;
-    openTreeNode: string;
-    aggregate: string;
-    filter: string;
-    filterQuery: string;
-    filterData: string;
-    getSearchData: string;
-    groupBy: string;
-    modifySubscription: string;
-    searchData: string;
-    setGroupState: string;
-    size: string;
-    sort: string;
-    subscribed: string;
-    tableList: string;
-    unsubscribe: string;
-    viewRangeChanged: string;
-};

package/types/src/data-source.d.ts

@@ -1,6 +0,0 @@
-import type { DataSourceCallbackMessage, DataSourceConfig, DataSourceConfigMessage, DataSourceDataSizeMessage, WithRequestId } from "@vuu-ui/vuu-data-types";
-import type { SelectSuccessWithRowCount } from "@vuu-ui/vuu-protocol-types";
-export declare const isSizeOnly: (message: DataSourceCallbackMessage) => message is DataSourceDataSizeMessage;
-export declare const toDataSourceConfig: (message: DataSourceConfigMessage) => DataSourceConfig;
-export declare const shouldMessageBeRoutedToDataSource: (message: unknown) => message is Exclude<DataSourceCallbackMessage, WithRequestId<SelectSuccessWithRowCount>>;
-export declare const isDataSourceConfigMessage: (message: DataSourceCallbackMessage) => message is DataSourceConfigMessage;

package/types/src/index.d.ts

@@ -1,11 +0,0 @@
-export { authenticate, getVuuAuthToken, parseVuuUserFromToken, } from "./authenticate";
-export * from "./ConnectionManager";
-export { default as ConnectionManager } from "./ConnectionManager";
-export * from "./constants";
-export * from "./data-source";
-export { LostConnectionHandler, RetryOptions } from "./LostConnectionHandler";
-export * from "./message-utils";
-export { VuuAuthenticator, VuuAuthTokenIssuePolicy } from "./VuuAuthenticator";
-export { VuuAuthProvider, type AuthProvider } from "./VuuAuthProvider";
-export * from "./VuuDataSource";
-export { isConnected, type ConnectionStatus } from "./WebSocketConnection";