@etsoo/toolpad 1.0.0

package/build/src/shared/locales/LocaleContext.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import DEFAULT_LOCALE_TEXT from "./en";
+export const LocaleContext = React.createContext(DEFAULT_LOCALE_TEXT);
+/**
+ * @ignore - internal component.
+ */
+export function LocaleProvider({ localeText, children }) {
+    const mergedLocaleText = React.useMemo(() => ({ ...DEFAULT_LOCALE_TEXT, ...localeText }), [localeText]);
+    return (_jsx(LocaleContext.Provider, { value: mergedLocaleText, children: children }));
+}
+/**
+ * @ignore - internal hook.
+ */
+export function useLocaleText() {
+    return React.useContext(LocaleContext);
+}

package/build/src/shared/locales/en.d.ts

@@ -0,0 +1,6 @@
+declare const TOOLPAD_CORE_DEFAULT_LOCALE_TEXT: {
+    signInLabel: string;
+    signOutLabel: string;
+    iconButtonAriaLabel: string;
+};
+export default TOOLPAD_CORE_DEFAULT_LOCALE_TEXT;

package/build/src/shared/locales/en.js

@@ -0,0 +1,8 @@
+const TOOLPAD_CORE_DEFAULT_LOCALE_TEXT = {
+    // Account
+    signInLabel: "Sign In",
+    signOutLabel: "Sign Out",
+    // Account Preview
+    iconButtonAriaLabel: "Current User"
+};
+export default TOOLPAD_CORE_DEFAULT_LOCALE_TEXT;

package/build/src/shared/navigation.d.ts

@@ -0,0 +1,16 @@
+import type { Navigation, NavigationItem, NavigationPageItem, NavigationSubheaderItem } from "../AppProvider";
+export declare const getItemKind: (item: NavigationItem) => "page" | "header" | "divider";
+export declare const isPageItem: (item: NavigationItem) => item is NavigationPageItem;
+export declare const getItemTitle: (item: NavigationPageItem | NavigationSubheaderItem) => string;
+export declare function getPageItemFullPath(basePath: string, navigationItem: NavigationPageItem): string;
+export declare function isPageItemSelected(navigationItem: NavigationPageItem, basePath: string, pathname: string): boolean;
+export declare function hasSelectedNavigationChildren(navigationItem: NavigationItem, basePath: string, pathname: string): boolean;
+/**
+ * Matches a path against the navigation to find the active page. i.e. the page that should be
+ * marked as selected in the navigation.
+ */
+export declare function matchPath(navigation: Navigation, path: string): NavigationPageItem | null;
+/**
+ * Gets the path for a specific navigation page item.
+ */
+export declare function getItemPath(navigation: Navigation, item: NavigationPageItem): string;

package/build/src/shared/navigation.js

@@ -0,0 +1,129 @@
+import { pathToRegexp } from "path-to-regexp";
+import invariant from "invariant";
+export const getItemKind = (item) => item.kind ?? "page";
+export const isPageItem = (item) => getItemKind(item) === "page";
+export const getItemTitle = (item) => {
+    return isPageItem(item) ? item.title ?? item.segment ?? "" : item.title;
+};
+export function getPageItemFullPath(basePath, navigationItem) {
+    return `${basePath}${basePath && !navigationItem.segment ? "" : "/"}${navigationItem.segment ?? ""}`;
+}
+export function isPageItemSelected(navigationItem, basePath, pathname) {
+    return navigationItem.pattern
+        ? pathToRegexp(`${basePath}/${navigationItem.pattern}`).test(pathname)
+        : getPageItemFullPath(basePath, navigationItem) === pathname;
+}
+export function hasSelectedNavigationChildren(navigationItem, basePath, pathname) {
+    if (isPageItem(navigationItem) && navigationItem.children) {
+        const navigationItemFullPath = getPageItemFullPath(basePath, navigationItem);
+        return navigationItem.children.some((nestedNavigationItem) => {
+            if (!isPageItem(nestedNavigationItem)) {
+                return false;
+            }
+            if (nestedNavigationItem.children) {
+                return hasSelectedNavigationChildren(nestedNavigationItem, navigationItemFullPath, pathname);
+            }
+            return isPageItemSelected(nestedNavigationItem, navigationItemFullPath, pathname);
+        });
+    }
+    return false;
+}
+/**
+ * Builds a map of navigation page items to their respective paths. This map is used to quickly
+ * lookup the path of a navigation item. It will be cached for the lifetime of the navigation.
+ */
+function buildItemToPathMap(navigation) {
+    const map = new Map();
+    const visit = (item, base) => {
+        if (isPageItem(item)) {
+            const path = `${base}${item.segment ? `/${item.segment}` : ""}` || "/";
+            map.set(item, path);
+            if (item.children) {
+                for (const child of item.children) {
+                    visit(child, path);
+                }
+            }
+        }
+    };
+    for (const item of navigation) {
+        visit(item, "");
+    }
+    return map;
+}
+const itemToPathMapCache = new WeakMap();
+/**
+ * Gets the cached map of navigation page items to their respective paths.
+ */
+function getItemToPathMap(navigation) {
+    let map = itemToPathMapCache.get(navigation);
+    if (!map) {
+        map = buildItemToPathMap(navigation);
+        itemToPathMapCache.set(navigation, map);
+    }
+    return map;
+}
+/**
+ * Build a lookup map of paths to navigation items. This map is used to match paths against
+ * to find the active page.
+ */
+function buildItemLookup(navigation) {
+    const map = new Map();
+    const visit = (item) => {
+        if (isPageItem(item)) {
+            const path = getItemPath(navigation, item);
+            if (map.has(path)) {
+                console.warn(`Duplicate path in navigation: ${path}`);
+            }
+            map.set(path, item);
+            if (item.pattern) {
+                const basePath = item.segment
+                    ? path.slice(0, -item.segment.length)
+                    : path;
+                map.set(pathToRegexp(basePath + item.pattern), item);
+            }
+            if (item.children) {
+                for (const child of item.children) {
+                    visit(child);
+                }
+            }
+        }
+    };
+    for (const item of navigation) {
+        visit(item);
+    }
+    return map;
+}
+const itemLookupMapCache = new WeakMap();
+function getItemLookup(navigation) {
+    let map = itemLookupMapCache.get(navigation);
+    if (!map) {
+        map = buildItemLookup(navigation);
+        itemLookupMapCache.set(navigation, map);
+    }
+    return map;
+}
+/**
+ * Matches a path against the navigation to find the active page. i.e. the page that should be
+ * marked as selected in the navigation.
+ */
+export function matchPath(navigation, path) {
+    const lookup = getItemLookup(navigation);
+    for (const [key, item] of lookup.entries()) {
+        if (typeof key === "string" && key === path) {
+            return item;
+        }
+        if (key instanceof RegExp && key.test(path)) {
+            return item;
+        }
+    }
+    return null;
+}
+/**
+ * Gets the path for a specific navigation page item.
+ */
+export function getItemPath(navigation, item) {
+    const map = getItemToPathMap(navigation);
+    const path = map.get(item);
+    invariant(path, `Item not found in navigation: ${item.title}`);
+    return path;
+}

package/build/src/useActivePage/index.d.ts

@@ -0,0 +1 @@
+export * from "./useActivePage";

package/build/src/useActivePage/index.js

@@ -0,0 +1 @@
+export * from "./useActivePage";

package/build/src/useActivePage/useActivePage.d.ts

@@ -0,0 +1,11 @@
+import type { Breadcrumb } from "../PageContainer";
+export interface ActivePage {
+    title: string;
+    path: string;
+    /**
+     * @deprecated Use `breadcrumbs` instead.
+     */
+    breadCrumbs: Breadcrumb[];
+    breadcrumbs: Breadcrumb[];
+}
+export declare function useActivePage(): ActivePage | null;

package/build/src/useActivePage/useActivePage.js

@@ -0,0 +1,48 @@
+"use client";
+import * as React from "react";
+import { NavigationContext, RouterContext } from "../shared/context";
+import { getItemPath, getItemTitle, matchPath } from "../shared/navigation";
+export function useActivePage() {
+    const navigationContext = React.useContext(NavigationContext);
+    const routerContext = React.useContext(RouterContext);
+    const pathname = routerContext?.pathname ?? "/";
+    const activeItem = matchPath(navigationContext, pathname);
+    const rootItem = matchPath(navigationContext, "/");
+    return React.useMemo(() => {
+        if (!activeItem) {
+            return null;
+        }
+        const breadcrumbs = [];
+        if (rootItem) {
+            breadcrumbs.push({
+                title: getItemTitle(rootItem),
+                path: "/"
+            });
+        }
+        const segments = pathname.split("/").filter(Boolean);
+        let prefix = "";
+        for (const segment of segments) {
+            const path = `${prefix}/${segment}`;
+            prefix = path;
+            const item = matchPath(navigationContext, path);
+            if (!item) {
+                continue;
+            }
+            const itemPath = getItemPath(navigationContext, item);
+            const lastCrumb = breadcrumbs[breadcrumbs.length - 1];
+            if (lastCrumb?.path !== itemPath) {
+                breadcrumbs.push({
+                    title: getItemTitle(item),
+                    path: itemPath
+                });
+            }
+        }
+        return {
+            title: getItemTitle(activeItem),
+            path: getItemPath(navigationContext, activeItem),
+            breadcrumbs,
+            // TODO: Remove in the next major version
+            breadCrumbs: breadcrumbs
+        };
+    }, [activeItem, rootItem, pathname, navigationContext]);
+}

package/build/src/useLocalStorageState/index.d.ts

@@ -0,0 +1 @@
+export * from "./useLocalStorageState";

package/build/src/useLocalStorageState/index.js

@@ -0,0 +1 @@
+export * from "./useLocalStorageState";

package/build/src/useLocalStorageState/useLocalStorageState.d.ts

@@ -0,0 +1,2 @@
+import { UseStorageState } from "../persistence";
+export declare const useLocalStorageState: UseStorageState;

package/build/src/useLocalStorageState/useLocalStorageState.js

@@ -0,0 +1,14 @@
+"use client";
+import { useStorageState, useStorageStateServer } from "../persistence";
+/**
+ * Sync state to local storage so that it persists through a page refresh. Usage is
+ * similar to useState except we pass in a storage key so that we can default
+ * to that value on page load instead of the specified initial value.
+ *
+ * Since the storage API isn't available in server-rendering environments, we
+ * return null during SSR and hydration.
+ */
+const useLocalStorageStateBrowser = (...args) => useStorageState(window.localStorage, ...args);
+export const useLocalStorageState = typeof window === "undefined"
+    ? useStorageStateServer
+    : useLocalStorageStateBrowser;

package/build/src/useSessionStorageState/index.d.ts

@@ -0,0 +1 @@
+export * from "./useSessionStorageState";

package/build/src/useSessionStorageState/index.js

@@ -0,0 +1 @@
+export * from "./useSessionStorageState";

package/build/src/useSessionStorageState/useSessionStorageState.d.ts

@@ -0,0 +1,2 @@
+import { UseStorageState } from "../persistence";
+export declare const useSessionStorageState: UseStorageState;

package/build/src/useSessionStorageState/useSessionStorageState.js

@@ -0,0 +1,14 @@
+"use client";
+import { useStorageState, useStorageStateServer } from "../persistence";
+/**
+ * Sync state to session storage so that it persists through a page refresh. Usage is
+ * similar to useState except we pass in a storage key so that we can default
+ * to that value on page load instead of the specified initial value.
+ *
+ * Since the storage API isn't available in server-rendering environments, we
+ * return null during SSR and hydration.
+ */
+const useSessionStorageStateBrowser = (...args) => useStorageState(window.sessionStorage, ...args);
+export const useSessionStorageState = typeof window === "undefined"
+    ? useStorageStateServer
+    : useSessionStorageStateBrowser;

package/build/src/utils/collections.d.ts

@@ -0,0 +1,44 @@
+export declare function asArray<T>(maybeArray: T | T[]): T[];
+type PropertiesOf<P> = Extract<keyof P, string>;
+type Require<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type Ensure<U, K extends PropertyKey> = K extends keyof U ? Require<U, K> : U & Record<K, unknown>;
+/**
+ * Type aware version of Object.protoype.hasOwnProperty.
+ * See https://fettblog.eu/typescript-hasownproperty/
+ */
+export declare function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is Ensure<X, Y>;
+/**
+ * Maps `obj` to a new object. The `mapper` function receives an entry array of key and value and
+ * is allowed to manipulate both. It can also return `null` to omit a property from the result.
+ */
+export declare function mapProperties<P, L extends PropertyKey, U>(obj: P, mapper: <K extends PropertiesOf<P>>(old: [K, P[K]]) => [L, U] | null): Record<L, U>;
+/**
+ * Maps an objects' property keys. The result is a new object with the mapped keys, but the same values.
+ */
+export declare function mapKeys<U>(obj: Record<string, U>, mapper: (old: string) => string): Record<string, U>;
+/**
+ * Maps an objects' property values. The result is a new object with the same keys, but mapped values.
+ */
+export declare function mapValues<P, V>(obj: P, mapper: (old: P[PropertiesOf<P>], key: PropertiesOf<P>) => V): Record<PropertiesOf<P>, V>;
+/**
+ * Filters an objects' property values. Similar to `array.filter` but for objects. The result is a new
+ * object with all the properties removed for which `filter` returned `false`.
+ */
+export declare function filterValues<K extends PropertyKey, P, Q extends P>(obj: Record<K, P>, filter: (old: P) => old is Q): Record<K, Q>;
+export declare function filterValues<P>(obj: P, filter: (old: P[keyof P]) => boolean): Partial<P>;
+export declare function filterValues<U>(obj: Record<string, U>, filter: (old: U) => boolean): Record<string, U>;
+/**
+ * Filters an objects' property keys. Similar to `array.filter` but for objects. The result is a new
+ * object with all the properties removed for which `filter` returned `false`.
+ */
+export declare function filterKeys<P>(obj: P, filter: (old: keyof P) => boolean): Partial<P>;
+export declare function filterKeys<U>(obj: Record<string, U>, filter: (old: string) => boolean): Record<string, U>;
+/**
+ * Compares the properties of two objects. Returns `true` if all properties are strictly equal, `false`
+ * otherwise.
+ * Pass a subset of properties to only compare those.
+ */
+export declare function equalProperties<P extends object>(obj1: P, obj2: P, subset?: (keyof P)[]): boolean;
+export {};

package/build/src/utils/collections.js

@@ -0,0 +1,43 @@
+export function asArray(maybeArray) {
+    return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+/**
+ * Type aware version of Object.protoype.hasOwnProperty.
+ * See https://fettblog.eu/typescript-hasownproperty/
+ */
+export function hasOwnProperty(obj, prop) {
+    return obj.hasOwnProperty(prop);
+}
+export function mapProperties(obj, mapper) {
+    return Object.fromEntries(Object.entries(obj).flatMap((entry) => {
+        const mapped = mapper(entry);
+        return mapped ? [mapped] : [];
+    }));
+}
+/**
+ * Maps an objects' property keys. The result is a new object with the mapped keys, but the same values.
+ */
+export function mapKeys(obj, mapper) {
+    return mapProperties(obj, ([key, value]) => [mapper(key), value]);
+}
+/**
+ * Maps an objects' property values. The result is a new object with the same keys, but mapped values.
+ */
+export function mapValues(obj, mapper) {
+    return mapProperties(obj, ([key, value]) => [key, mapper(value, key)]);
+}
+export function filterValues(obj, filter) {
+    return mapProperties(obj, ([key, value]) => filter(value) ? [key, value] : null);
+}
+export function filterKeys(obj, filter) {
+    return mapProperties(obj, ([key, value]) => filter(key) ? [key, value] : null);
+}
+/**
+ * Compares the properties of two objects. Returns `true` if all properties are strictly equal, `false`
+ * otherwise.
+ * Pass a subset of properties to only compare those.
+ */
+export function equalProperties(obj1, obj2, subset) {
+    const keysToCheck = new Set(subset ?? [...Object.keys(obj1), ...Object.keys(obj2)]);
+    return Array.from(keysToCheck).every((key) => Object.is(obj1[key], obj2[key]));
+}

package/build/src/utils/describeConformance.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export interface ConformanceOptions {
+    refInstanceof?: unknown;
+    inheritComponent?: React.ElementType;
+    skip?: Array<"themeDefaultProps">;
+}
+export default function describeConformance(minimalElement: React.ReactElement<unknown>, getOptions: () => ConformanceOptions): void;

package/build/src/utils/describeConformance.js

@@ -0,0 +1,3 @@
+export default function describeConformance(minimalElement, getOptions) {
+    getOptions();
+}

package/build/src/utils/events.d.ts

@@ -0,0 +1,27 @@
+export type EventName = string | symbol;
+export type EventHandlers = Record<EventName, unknown>;
+export type EventHandler<T extends EventHandlers, K extends keyof T = keyof T> = (event: T[K]) => void;
+export type AllEventsHandler<T extends EventHandlers, K extends keyof T = keyof T> = (type: K, event: T[K]) => void;
+/**
+ * Lightweight event emitter
+ */
+export declare class Emitter<T extends EventHandlers = {}> {
+    private handlers;
+    /**
+     * Add a listener for an event
+     */
+    on(name: "*", handler: AllEventsHandler<T>): void;
+    on<K extends keyof T>(name: K, handler: EventHandler<T, K>): void;
+    /**
+     * Remove a listener from an event
+     */
+    off<K extends keyof T>(name: K, handler: EventHandler<T, K>): void;
+    /**
+     * Subscribe to an event and return an unsubscribe function.
+     */
+    subscribe<K extends keyof T>(name: K, handler: EventHandler<T, K>): () => void;
+    /**
+     * Emit an event.
+     */
+    emit<K extends keyof T>(name: K, event: T[K]): void;
+}

package/build/src/utils/events.js

@@ -0,0 +1,54 @@
+/**
+ * Lightweight event emitter
+ */
+export class Emitter {
+    constructor() {
+        this.handlers = new Map();
+    }
+    on(name, handler) {
+        let eventHandlers = this.handlers.get(name);
+        if (!eventHandlers) {
+            eventHandlers = new Set();
+            this.handlers.set(name, eventHandlers);
+        }
+        eventHandlers.add(handler);
+    }
+    /**
+     * Remove a listener from an event
+     */
+    off(name, handler) {
+        const eventHandlers = this.handlers.get(name);
+        if (eventHandlers) {
+            eventHandlers.delete(handler);
+            if (eventHandlers.size <= 0) {
+                this.handlers.delete(name);
+            }
+        }
+    }
+    /**
+     * Subscribe to an event and return an unsubscribe function.
+     */
+    subscribe(name, handler) {
+        this.on(name, handler);
+        return () => {
+            this.off(name, handler);
+        };
+    }
+    /**
+     * Emit an event.
+     */
+    emit(name, event) {
+        const eventHandlers = this.handlers.get(name);
+        if (eventHandlers) {
+            for (const eventHandler of eventHandlers) {
+                eventHandler(event);
+            }
+        }
+        const allHandlers = this.handlers.get("*");
+        if (allHandlers) {
+            for (const eventHandler of allHandlers) {
+                eventHandler(name, event);
+            }
+        }
+    }
+}

package/build/src/utils/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useBoolean } from "./useBoolean";
+export { default as usePageTitle } from "./usePageTitle";

package/build/src/utils/hooks/index.js

@@ -0,0 +1,2 @@
+export { default as useBoolean } from "./useBoolean";
+export { default as usePageTitle } from "./usePageTitle";

package/build/src/utils/hooks/useBoolean.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+/**
+ * A utility with shortcuts to manipulate boolean values.
+ */
+export default function useBoolean(initialValue: boolean): {
+    value: boolean;
+    setValue: React.Dispatch<React.SetStateAction<boolean>>;
+    toggle: () => void;
+    setTrue: () => void;
+    setFalse: () => void;
+};

package/build/src/utils/hooks/useBoolean.js

@@ -0,0 +1,11 @@
+import * as React from "react";
+/**
+ * A utility with shortcuts to manipulate boolean values.
+ */
+export default function useBoolean(initialValue) {
+    const [value, setValue] = React.useState(initialValue);
+    const toggle = React.useCallback(() => setValue((existing) => !existing), []);
+    const setTrue = React.useCallback(() => setValue(true), []);
+    const setFalse = React.useCallback(() => setValue(false), []);
+    return { value, setValue, toggle, setTrue, setFalse };
+}

package/build/src/utils/hooks/useDebounced.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This hook allows you to debounce any fast changing value. The debounced value will only
+ * reflect the latest value when the useDebounce hook has not been called for the specified
+ * time period.
+ *
+ * Inspired by https://usehooks.com/useDebounce/
+ */
+export default function useDebounced<T>(value: T, delay: number): T;

package/build/src/utils/hooks/useDebounced.js

@@ -0,0 +1,28 @@
+import * as React from "react";
+/**
+ * This hook allows you to debounce any fast changing value. The debounced value will only
+ * reflect the latest value when the useDebounce hook has not been called for the specified
+ * time period.
+ *
+ * Inspired by https://usehooks.com/useDebounce/
+ */
+export default function useDebounced(value, delay) {
+    const [debouncedValue, setDebouncedValue] = React.useState(() => value);
+    const timeoutIdRef = React.useRef(null);
+    React.useEffect(() => () => {
+        if (timeoutIdRef.current) {
+            clearTimeout(timeoutIdRef.current);
+            timeoutIdRef.current = null;
+        }
+    }, []);
+    React.useEffect(() => {
+        timeoutIdRef.current = setTimeout(() => setDebouncedValue(() => value), delay);
+        return () => {
+            if (timeoutIdRef.current) {
+                clearTimeout(timeoutIdRef.current);
+                timeoutIdRef.current = null;
+            }
+        };
+    }, [value, delay]);
+    return debouncedValue;
+}

package/build/src/utils/hooks/useDebouncedHandler.d.ts

@@ -0,0 +1,12 @@
+interface Handler<P extends unknown[]> {
+    (...params: P): void;
+}
+/**
+ * Creates a debounced version of the handler that is passed. The invocation of [fn] is
+ * delayed for [delay] milliseconds from the last invocation of the debounced function.
+ *
+ * This implementation adds on the lodash implementation in that it handles updates to the
+ * delay value.
+ */
+export default function useDebouncedHandler<P extends unknown[]>(fn: Handler<P>, delay: number): Handler<P>;
+export {};

package/build/src/utils/hooks/useDebouncedHandler.js

@@ -0,0 +1,41 @@
+import * as React from "react";
+function defer(fn, params, delay) {
+    const timeout = setTimeout(() => {
+        fn.current(...params);
+    }, delay);
+    return { startTime: Date.now(), timeout, params };
+}
+/**
+ * Creates a debounced version of the handler that is passed. The invocation of [fn] is
+ * delayed for [delay] milliseconds from the last invocation of the debounced function.
+ *
+ * This implementation adds on the lodash implementation in that it handles updates to the
+ * delay value.
+ */
+export default function useDebouncedHandler(fn, delay) {
+    const fnRef = React.useRef(fn);
+    React.useEffect(() => {
+        fnRef.current = fn;
+    }, [fn]);
+    const delayedInvocation = React.useRef(null);
+    const clearCurrent = React.useCallback(() => {
+        if (delayedInvocation.current) {
+            clearTimeout(delayedInvocation.current.timeout);
+            delayedInvocation.current = null;
+        }
+    }, []);
+    React.useEffect(() => {
+        if (!delayedInvocation.current) {
+            return;
+        }
+        const { startTime, params } = delayedInvocation.current;
+        const elapsed = Date.now() - startTime;
+        const newDelay = Math.max(delay - elapsed, 0);
+        clearCurrent();
+        delayedInvocation.current = defer(fnRef, params, newDelay);
+    }, [delay, clearCurrent]);
+    return React.useCallback((...params) => {
+        clearCurrent();
+        delayedInvocation.current = defer(fnRef, params, delay);
+    }, [delay, clearCurrent]);
+}

package/build/src/utils/hooks/useLatest.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the latest non-null, non-undefined value that has been passed to it.
+ */
+declare function useLatest<T>(value: T): T;
+declare function useLatest<T>(value: T | null | undefined): T | null | undefined;
+export default useLatest;

package/build/src/utils/hooks/useLatest.js

@@ -0,0 +1,9 @@
+import * as React from "react";
+function useLatest(value) {
+    const [latest, setLatest] = React.useState(value);
+    if (latest !== value && value !== null && value !== undefined) {
+        setLatest(value);
+    }
+    return value ?? latest;
+}
+export default useLatest;

package/build/src/utils/hooks/usePageTitle.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets the current document title.
+ */
+export default function usePageTitle(title: string): void;

package/build/src/utils/hooks/usePageTitle.js

@@ -0,0 +1,13 @@
+import * as React from "react";
+/**
+ * Sets the current document title.
+ */
+export default function usePageTitle(title) {
+    React.useEffect(() => {
+        const original = document.title;
+        document.title = title;
+        return () => {
+            document.title = original;
+        };
+    }, [title]);
+}