@procore/saved-views 6.0.2 → 6.2.0

package/dist/modern/adapters/hub-data-loader.js

@@ -0,0 +1,270 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }require('../chunk-QGM4M3NI.js');
+
+// src/transport/hub-data-loader.tsx
+
+
+
+
+
+
+
+
+
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+
+
+var _websdkhubdataloader = require('@procore/web-sdk-hub-data-loader');
+var HubDataLoaderCache = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  getOrCreate(key) {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = { data: void 0, listeners: /* @__PURE__ */ new Set() };
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  subscribe(key, listener) {
+    const entry = this.getOrCreate(key);
+    entry.listeners.add(listener);
+    return () => {
+      entry.listeners.delete(listener);
+    };
+  }
+  get(key) {
+    return _optionalChain([this, 'access', _ => _.entries, 'access', _2 => _2.get, 'call', _3 => _3(key), 'optionalAccess', _4 => _4.data]);
+  }
+  set(key, data) {
+    const entry = this.getOrCreate(key);
+    entry.data = data;
+    entry.listeners.forEach((listener) => listener());
+  }
+  invalidate(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.data = void 0;
+    entry.listeners.forEach((listener) => listener());
+  }
+};
+var stringifyQueryKey = (queryKey) => JSON.stringify(queryKey);
+var HubDataLoaderCacheContext = _react.createContext.call(void 0, void 0);
+var useHubDataLoaderCache = () => {
+  const ctx = _react.useContext.call(void 0, HubDataLoaderCacheContext);
+  if (!ctx) {
+    throw new Error(
+      "HubDataLoaderCacheProvider is missing. This indicates the saved-views transport was not constructed via createHubDataLoaderTransport()."
+    );
+  }
+  return ctx.cache;
+};
+var METHOD_TO_OPERATION_TYPE = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  DELETE: "DELETE"
+};
+var splitUrl = (url) => {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) {
+    return { operationName: url, queryParams: {} };
+  }
+  const operationName = url.slice(0, queryIndex);
+  const search = new URLSearchParams(url.slice(queryIndex + 1));
+  const queryParams = {};
+  search.forEach((value, key) => {
+    queryParams[key] = value;
+  });
+  return { operationName, queryParams };
+};
+var parseBody = (body) => {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch (e) {
+      return void 0;
+    }
+  }
+  if (typeof body === "object") {
+    return body;
+  }
+  return void 0;
+};
+var createHubDataLoaderTransport = (options) => {
+  const { hubCardId, systemEvents } = options;
+  const CacheProvider = ({ children }) => {
+    const cacheRef = _react.useRef.call(void 0, );
+    if (!cacheRef.current) {
+      cacheRef.current = new HubDataLoaderCache();
+    }
+    const value = _react.useMemo.call(void 0, 
+      () => ({ cache: cacheRef.current }),
+      []
+    );
+    return /* @__PURE__ */ _react2.default.createElement(HubDataLoaderCacheContext.Provider, { value }, children);
+  };
+  const useHttp = () => {
+    const { sendRequest } = _websdkhubdataloader.useHubDataLoader.call(void 0, hubCardId, systemEvents);
+    return _react.useCallback.call(void 0, 
+      async (req) => {
+        const { operationName, queryParams } = splitUrl(req.url);
+        const params = {
+          operationName,
+          operationType: METHOD_TO_OPERATION_TYPE[req.method],
+          queryParams,
+          body: parseBody(req.body),
+          headers: req.headers,
+          // Read saved-views GETs fresh from the network. This transport keeps
+          // its own local subscription cache (HubDataLoaderCache) and gates
+          // refetches on a local-cache miss, so it doesn't benefit from the
+          // host's stale-while-revalidate cache. Without preferFresh the host
+          // serves the GET via `ensureQueryData`, which returns the cached
+          // (pre-mutation) list — so a freshly created/renamed/deleted view
+          // wouldn't appear until the host cache expired. preferFresh routes
+          // the read through `fetchQuery({ staleTime: 0 })`, guaranteeing the
+          // post-mutation refetch reflects the change immediately.
+          preferFresh: req.method === "GET"
+        };
+        const response = await sendRequest(params);
+        if (response.error) {
+          throw response.error;
+        }
+        return response.responseData;
+      },
+      [sendRequest]
+    );
+  };
+  const useQueryAdapter = (args) => {
+    const cache = useHubDataLoaderCache();
+    const key = _react.useMemo.call(void 0, 
+      () => stringifyQueryKey(args.queryKey),
+      [args.queryKey]
+    );
+    const queryFnRef = _react.useRef.call(void 0, args.queryFn);
+    queryFnRef.current = args.queryFn;
+    const subscribe = _react.useCallback.call(void 0, 
+      (listener) => cache.subscribe(key, listener),
+      [cache, key]
+    );
+    const getSnapshot = _react.useCallback.call(void 0, 
+      () => cache.get(key),
+      [cache, key]
+    );
+    const data = _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, getSnapshot);
+    const [isLoading, setIsLoading] = _react.useState.call(void 0, 
+      args.enabled !== false && data === void 0
+    );
+    const [error, setError] = _react.useState.call(void 0, void 0);
+    const fetchInFlight = _react.useRef.call(void 0, false);
+    _react.useEffect.call(void 0, () => {
+      if (args.enabled === false) {
+        setIsLoading(false);
+        return;
+      }
+      if (data !== void 0) {
+        setIsLoading(false);
+        return;
+      }
+      if (fetchInFlight.current) return;
+      let abandoned = false;
+      fetchInFlight.current = true;
+      setIsLoading(true);
+      setError(void 0);
+      queryFnRef.current().then((result) => {
+        if (!abandoned) {
+          cache.set(key, result);
+          setError(void 0);
+        }
+      }).catch((err) => {
+        if (!abandoned) setError(err);
+      }).finally(() => {
+        if (!abandoned) {
+          fetchInFlight.current = false;
+          setIsLoading(false);
+        }
+      });
+      return () => {
+        abandoned = true;
+        fetchInFlight.current = false;
+      };
+    }, [cache, key, args.enabled, data]);
+    return {
+      data,
+      isLoading,
+      isError: error !== void 0,
+      error
+    };
+  };
+  const useMutationAdapter = (args) => {
+    const [isPending, setIsPending] = _react.useState.call(void 0, false);
+    const [error, setError] = _react.useState.call(void 0, null);
+    const mutationFnRef = _react.useRef.call(void 0, args.mutationFn);
+    const onSuccessRef = _react.useRef.call(void 0, args.onSuccess);
+    const onErrorRef = _react.useRef.call(void 0, args.onError);
+    mutationFnRef.current = args.mutationFn;
+    onSuccessRef.current = args.onSuccess;
+    onErrorRef.current = args.onError;
+    const mutate = _react.useCallback.call(void 0, 
+      (variables, callOptions) => {
+        setIsPending(true);
+        setError(null);
+        mutationFnRef.current(variables).then((result) => {
+          _optionalChain([onSuccessRef, 'access', _5 => _5.current, 'optionalCall', _6 => _6(result, variables)]);
+          _optionalChain([callOptions, 'optionalAccess', _7 => _7.onSuccess, 'optionalCall', _8 => _8(result, variables)]);
+        }).catch((err) => {
+          setError(err);
+          _optionalChain([onErrorRef, 'access', _9 => _9.current, 'optionalCall', _10 => _10(err, variables)]);
+          _optionalChain([callOptions, 'optionalAccess', _11 => _11.onError, 'optionalCall', _12 => _12(err, variables)]);
+        }).finally(() => {
+          setIsPending(false);
+        });
+      },
+      []
+    );
+    const reset = _react.useCallback.call(void 0, () => {
+      setError(null);
+      setIsPending(false);
+    }, []);
+    return { mutate, isPending, error, reset };
+  };
+  const useCacheControl = () => {
+    const cache = useHubDataLoaderCache();
+    return {
+      invalidate: (queryKey) => {
+        cache.invalidate(stringifyQueryKey(queryKey));
+      },
+      setData: (queryKey, updater) => {
+        const key = stringifyQueryKey(queryKey);
+        const existing = cache.get(key);
+        const next = updater(existing);
+        cache.set(key, next);
+      },
+      getData: (queryKey) => cache.get(stringifyQueryKey(queryKey))
+    };
+  };
+  const useUrlAdapter = () => ({
+    // Hub Cards cannot read or write the host's URL. The host owns routing.
+    // The saved-views package falls back to localStorage-only persistence
+    // when these return null / no-op.
+    getViewToken: () => null,
+    setViewToken: () => {
+    }
+  });
+  return {
+    // Hub Cards cannot own the host URL, so the `?saved-view=<token>` share link
+    // cannot be read back on load. Hide the copy-link affordance in this context
+    // (see routing-in-hub-cards.md). The rest of saved views works unchanged.
+    supportsUrlSharing: false,
+    CacheProvider,
+    useHttp,
+    useQueryAdapter,
+    useMutationAdapter,
+    useCacheControl,
+    useUrlAdapter
+  };
+};
+
+
+exports.createHubDataLoaderTransport = createHubDataLoaderTransport;

package/dist/modern/adapters/hub-data-loader.mjs

@@ -0,0 +1,270 @@
+import "../chunk-6DZX6EAA.mjs";
+
+// src/transport/hub-data-loader.tsx
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore
+} from "react";
+import {
+  useHubDataLoader
+} from "@procore/web-sdk-hub-data-loader";
+var HubDataLoaderCache = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  getOrCreate(key) {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = { data: void 0, listeners: /* @__PURE__ */ new Set() };
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  subscribe(key, listener) {
+    const entry = this.getOrCreate(key);
+    entry.listeners.add(listener);
+    return () => {
+      entry.listeners.delete(listener);
+    };
+  }
+  get(key) {
+    return this.entries.get(key)?.data;
+  }
+  set(key, data) {
+    const entry = this.getOrCreate(key);
+    entry.data = data;
+    entry.listeners.forEach((listener) => listener());
+  }
+  invalidate(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.data = void 0;
+    entry.listeners.forEach((listener) => listener());
+  }
+};
+var stringifyQueryKey = (queryKey) => JSON.stringify(queryKey);
+var HubDataLoaderCacheContext = createContext(void 0);
+var useHubDataLoaderCache = () => {
+  const ctx = useContext(HubDataLoaderCacheContext);
+  if (!ctx) {
+    throw new Error(
+      "HubDataLoaderCacheProvider is missing. This indicates the saved-views transport was not constructed via createHubDataLoaderTransport()."
+    );
+  }
+  return ctx.cache;
+};
+var METHOD_TO_OPERATION_TYPE = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  DELETE: "DELETE"
+};
+var splitUrl = (url) => {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) {
+    return { operationName: url, queryParams: {} };
+  }
+  const operationName = url.slice(0, queryIndex);
+  const search = new URLSearchParams(url.slice(queryIndex + 1));
+  const queryParams = {};
+  search.forEach((value, key) => {
+    queryParams[key] = value;
+  });
+  return { operationName, queryParams };
+};
+var parseBody = (body) => {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return void 0;
+    }
+  }
+  if (typeof body === "object") {
+    return body;
+  }
+  return void 0;
+};
+var createHubDataLoaderTransport = (options) => {
+  const { hubCardId, systemEvents } = options;
+  const CacheProvider = ({ children }) => {
+    const cacheRef = useRef();
+    if (!cacheRef.current) {
+      cacheRef.current = new HubDataLoaderCache();
+    }
+    const value = useMemo(
+      () => ({ cache: cacheRef.current }),
+      []
+    );
+    return /* @__PURE__ */ React.createElement(HubDataLoaderCacheContext.Provider, { value }, children);
+  };
+  const useHttp = () => {
+    const { sendRequest } = useHubDataLoader(hubCardId, systemEvents);
+    return useCallback(
+      async (req) => {
+        const { operationName, queryParams } = splitUrl(req.url);
+        const params = {
+          operationName,
+          operationType: METHOD_TO_OPERATION_TYPE[req.method],
+          queryParams,
+          body: parseBody(req.body),
+          headers: req.headers,
+          // Read saved-views GETs fresh from the network. This transport keeps
+          // its own local subscription cache (HubDataLoaderCache) and gates
+          // refetches on a local-cache miss, so it doesn't benefit from the
+          // host's stale-while-revalidate cache. Without preferFresh the host
+          // serves the GET via `ensureQueryData`, which returns the cached
+          // (pre-mutation) list — so a freshly created/renamed/deleted view
+          // wouldn't appear until the host cache expired. preferFresh routes
+          // the read through `fetchQuery({ staleTime: 0 })`, guaranteeing the
+          // post-mutation refetch reflects the change immediately.
+          preferFresh: req.method === "GET"
+        };
+        const response = await sendRequest(params);
+        if (response.error) {
+          throw response.error;
+        }
+        return response.responseData;
+      },
+      [sendRequest]
+    );
+  };
+  const useQueryAdapter = (args) => {
+    const cache = useHubDataLoaderCache();
+    const key = useMemo(
+      () => stringifyQueryKey(args.queryKey),
+      [args.queryKey]
+    );
+    const queryFnRef = useRef(args.queryFn);
+    queryFnRef.current = args.queryFn;
+    const subscribe = useCallback(
+      (listener) => cache.subscribe(key, listener),
+      [cache, key]
+    );
+    const getSnapshot = useCallback(
+      () => cache.get(key),
+      [cache, key]
+    );
+    const data = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    const [isLoading, setIsLoading] = useState(
+      args.enabled !== false && data === void 0
+    );
+    const [error, setError] = useState(void 0);
+    const fetchInFlight = useRef(false);
+    useEffect(() => {
+      if (args.enabled === false) {
+        setIsLoading(false);
+        return;
+      }
+      if (data !== void 0) {
+        setIsLoading(false);
+        return;
+      }
+      if (fetchInFlight.current) return;
+      let abandoned = false;
+      fetchInFlight.current = true;
+      setIsLoading(true);
+      setError(void 0);
+      queryFnRef.current().then((result) => {
+        if (!abandoned) {
+          cache.set(key, result);
+          setError(void 0);
+        }
+      }).catch((err) => {
+        if (!abandoned) setError(err);
+      }).finally(() => {
+        if (!abandoned) {
+          fetchInFlight.current = false;
+          setIsLoading(false);
+        }
+      });
+      return () => {
+        abandoned = true;
+        fetchInFlight.current = false;
+      };
+    }, [cache, key, args.enabled, data]);
+    return {
+      data,
+      isLoading,
+      isError: error !== void 0,
+      error
+    };
+  };
+  const useMutationAdapter = (args) => {
+    const [isPending, setIsPending] = useState(false);
+    const [error, setError] = useState(null);
+    const mutationFnRef = useRef(args.mutationFn);
+    const onSuccessRef = useRef(args.onSuccess);
+    const onErrorRef = useRef(args.onError);
+    mutationFnRef.current = args.mutationFn;
+    onSuccessRef.current = args.onSuccess;
+    onErrorRef.current = args.onError;
+    const mutate = useCallback(
+      (variables, callOptions) => {
+        setIsPending(true);
+        setError(null);
+        mutationFnRef.current(variables).then((result) => {
+          onSuccessRef.current?.(result, variables);
+          callOptions?.onSuccess?.(result, variables);
+        }).catch((err) => {
+          setError(err);
+          onErrorRef.current?.(err, variables);
+          callOptions?.onError?.(err, variables);
+        }).finally(() => {
+          setIsPending(false);
+        });
+      },
+      []
+    );
+    const reset = useCallback(() => {
+      setError(null);
+      setIsPending(false);
+    }, []);
+    return { mutate, isPending, error, reset };
+  };
+  const useCacheControl = () => {
+    const cache = useHubDataLoaderCache();
+    return {
+      invalidate: (queryKey) => {
+        cache.invalidate(stringifyQueryKey(queryKey));
+      },
+      setData: (queryKey, updater) => {
+        const key = stringifyQueryKey(queryKey);
+        const existing = cache.get(key);
+        const next = updater(existing);
+        cache.set(key, next);
+      },
+      getData: (queryKey) => cache.get(stringifyQueryKey(queryKey))
+    };
+  };
+  const useUrlAdapter = () => ({
+    // Hub Cards cannot read or write the host's URL. The host owns routing.
+    // The saved-views package falls back to localStorage-only persistence
+    // when these return null / no-op.
+    getViewToken: () => null,
+    setViewToken: () => {
+    }
+  });
+  return {
+    // Hub Cards cannot own the host URL, so the `?saved-view=<token>` share link
+    // cannot be read back on load. Hide the copy-link affordance in this context
+    // (see routing-in-hub-cards.md). The rest of saved views works unchanged.
+    supportsUrlSharing: false,
+    CacheProvider,
+    useHttp,
+    useQueryAdapter,
+    useMutationAdapter,
+    useCacheControl,
+    useUrlAdapter
+  };
+};
+export {
+  createHubDataLoaderTransport
+};

package/dist/modern/chunk-6DZX6EAA.mjs

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/modern/chunk-QGM4M3NI.js

@@ -0,0 +1,37 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+
+
+
+
+exports.__require = __require; exports.__commonJS = __commonJS; exports.__toESM = __toESM;

package/dist/modern/index.d.mts

@@ -1,17 +1,20 @@
 import { Locale } from '@procore/globalization-toolkit';
 import * as React$1 from 'react';
-import React__default from 'react';
+import React__default, { PropsWithChildren } from 'react';
 import { DataTableConfig, TableApi, ColumnDefinition } from '@procore/data-table';
 import { ColumnState, FilterModel, GridApi } from 'ag-grid-community';
 import * as _procore_core_react_dist_Panel_Panel_types from '@procore/core-react/dist/Panel/Panel.types';
 import * as styled_components_dist_types from 'styled-components/dist/types';
 import * as _procore_core_react from '@procore/core-react';
+import { S as SavedViewsTransport } from './types-BWhJ-on3.mjs';
+export { a as SavedViewsCacheControl, b as SavedViewsHttpRequest, c as SavedViewsMutationArgs, d as SavedViewsMutationResult, e as SavedViewsQueryArgs, f as SavedViewsQueryResult, g as SavedViewsUrlAdapter } from './types-BWhJ-on3.mjs';
 
 declare function getTranslations(envLocale: Locale): Record<string, object>;
 
 declare const useSavedViewsPanel: (domain: string, tableName: string) => {
     isOpen: boolean;
     SavedViewsButton: () => React__default.JSX.Element;
+    SavedViewsProvider: ({ children, }: React__default.PropsWithChildren) => React__default.JSX.Element;
 };
 
 interface IQueryInputProps {
@@ -64,6 +67,15 @@ interface IBaseSavedViewsProps {
     projectId?: number;
     companyId: number;
     stickyViewsKey: string;
+    /**
+     * Optional transport that injects HTTP, query/mutation, cache, and URL
+     * adapters. Defaults to a transport backed by `@procore/core-http`,
+     * `@tanstack/react-query`, and `react-router-dom` (today's behavior).
+     *
+     * Hub Card consumers should pass the result of `createHubDataLoaderTransport`
+     * from `@procore/saved-views/adapters/hub-data-loader`.
+     */
+    transport?: SavedViewsTransport;
 }
 interface ISavedViewsProps extends Omit<IBaseSavedViewsProps, 'stickyViewsKey'> {
     defaultView: ISavedView;
@@ -116,6 +128,13 @@ interface IPanelContentProps {
     onClearTemporary?: () => void;
 }
 
+interface SavedViewsSelectionContextValue {
+    selectedView: ISavedView | null;
+    setSelectedView: (view: ISavedView | null) => void;
+}
+declare const SavedViewsSelectionProvider: ({ children, }: PropsWithChildren) => React__default.JSX.Element;
+declare const useSavedViewsSelection: () => SavedViewsSelectionContextValue | null;
+
 type SavedViewCollectionMenuItemProps = {
     item: ISavedView;
     key?: string;
@@ -158,7 +177,7 @@ declare const ExpandedPanel: styled_components_dist_types.IStyledComponentBase<"
 
 declare const PanelContent: (props: IPanelContentProps) => React__default.JSX.Element;
 
-declare const SavedViews: (props: ISavedViewsProps) => React__default.JSX.Element;
+declare const SavedViews: (props: ISavedViewsProps) => React__default.JSX.Element | null;
 
 type Props = {
     onDelete(): void;
@@ -189,4 +208,4 @@ interface IDataTableSavedViewsRef {
 }
 declare const DataTableSavedViews: React__default.ForwardRefExoticComponent<IDataTableSavedViewsExternalConsumerProps & React__default.RefAttributes<IDataTableSavedViewsRef>>;
 
-export { DataTableSavedViews, ExpandedPanel, FormModal, type IDataTableDefaultViewConfig, type IDataTableSavedViewsRef, type ISmartGridDefaultViewConfig, PanelContent, SavedViewCollectionMenuItem, SavedViews, SavedViewsDeleteConfirmationModalShared, SmartGridSavedViews, getTranslations, useSavedViewsPanel };
+export { DataTableSavedViews, ExpandedPanel, FormModal, type IDataTableDefaultViewConfig, type IDataTableSavedViewsRef, type ISmartGridDefaultViewConfig, PanelContent, SavedViewCollectionMenuItem, SavedViews, SavedViewsDeleteConfirmationModalShared, type SavedViewsSelectionContextValue, SavedViewsSelectionProvider, SavedViewsTransport, SmartGridSavedViews, getTranslations, useSavedViewsPanel, useSavedViewsSelection };