@ostack.tech/ui 0.1.0

package/dist/types/providers/DocumentTitleProvider/DocumentTitleProviderContext.d.ts

@@ -0,0 +1,44 @@
+import * as React from "react";
+/** Value of the document title provider context. */
+export interface DocumentTitleProviderContextValue {
+    baseDocumentTitle: string | null;
+    baseSeparator: string;
+    breadcrumbsSeparator: string;
+}
+/** Document title provider context. */
+export declare const DocumentTitleProviderContext: React.Context<DocumentTitleProviderContextValue | null>;
+/** State of the document title component. */
+export interface DocumentTitleState {
+    breadcrumbs: string[];
+    childrenDocumentTitles: number;
+    actions: DocumentTitleActions;
+}
+/** Document title actions. */
+export interface DocumentTitleActions {
+    addChildDocumentTitle: () => void;
+    removeChildDocumentTitle: () => void;
+}
+/** Document title store. */
+export type DocumentTitleStore = ReturnType<typeof useCreateDocumentTitleStore>;
+/** Document title context. */
+export declare const DocumentTitleContext: React.Context<(Omit<import("zustand").StoreApi<DocumentTitleState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: DocumentTitleState, previousSelectedState: DocumentTitleState) => void): () => void;
+        <U>(selector: (state: DocumentTitleState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}) | null>;
+/** Hook used to create the context of a document title component. */
+export declare function useCreateDocumentTitleStore(breadcrumbs?: string[]): Omit<import("zustand").StoreApi<DocumentTitleState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: DocumentTitleState, previousSelectedState: DocumentTitleState) => void): () => void;
+        <U>(selector: (state: DocumentTitleState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+};
+/** Hook that returns access to the document title's store. */
+export declare function useDocumentTitleStore<T>(selector: (state: Partial<DocumentTitleState>) => T): T;

package/dist/types/providers/DocumentTitleProvider/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./DocumentTitle.tsx";
+export * from "./DocumentTitleProvider.tsx";

package/dist/types/providers/ErrorReportingProvider/ErrorReport.d.ts

@@ -0,0 +1,35 @@
+import type * as React from "react";
+/** Error report. */
+export interface ErrorReport {
+    /** Hash of the error information, providing a unique identifier for the error. */
+    digest: string;
+    /** Error message. */
+    message: string;
+    /** Error stack, when available. */
+    stack: string | null;
+    /**
+     * Component error stack (React component tree of where the error occurred),
+     * when available.
+     */
+    componentStack: string | null;
+    /** Timestamp of when the error occurred. */
+    timestamp: Date;
+    /**
+     * Browser's user agent.
+     *
+     * **NOTE**: This could also be obtained from the `User-Agent` header of the
+     * HTTP request. However, it is included here since it is possible for the
+     * reporting to go through a proxy, which is free to alter the HTTP header.
+     */
+    userAgent: string;
+    /** URL where the error occurred. */
+    url: string;
+}
+/**
+ * Builds the error report.
+ *
+ * @param error Error that occurred.
+ * @param info Optional React error information.
+ * @returns Error report.
+ */
+export declare function buildErrorReport(error: unknown, info?: React.ErrorInfo): ErrorReport;

package/dist/types/providers/ErrorReportingProvider/ErrorReportingContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+/** Value of the error reporting context. */
+export interface ErrorReportingContextValue {
+    onError: (error: Error, info?: React.ErrorInfo) => void;
+}
+/** Error reporting context. */
+export declare const ErrorReportingContext: React.Context<ErrorReportingContextValue | null>;

package/dist/types/providers/ErrorReportingProvider/ErrorReportingProvider.d.ts

@@ -0,0 +1,70 @@
+import * as React from "react";
+import { type ErrorReport } from "./ErrorReport.ts";
+/** Properties of the error reporting provider. */
+export interface ErrorReportingProviderProps {
+    /**
+     * Whether error reporting is enabled. By default, error reporting is only
+     * enabled in production.
+     */
+    enabled?: boolean;
+    /**
+     * Function used to report an error. This function completely overrides the
+     * default error reporting and, as such, properties related to error reporting
+     * such as the `errorReportingUrl` are ignored.
+     *
+     * The default `reportError` function uses `fetch` with the remaining
+     * properties such as `errorReportingUrl` to perform the reporting.
+     *
+     * @param report Error report that should be reported.
+     */
+    reportError?: (report: ErrorReport) => void | Promise<void>;
+    /**
+     * URL to report the error to when using the default `reportError` function.
+     *
+     * This property is ignored when a custom `reportError` is provided.
+     */
+    errorReportingUrl?: string | URL;
+    /**
+     * Method to use when reporting the error.
+     *
+     * This property is ignored when a custom `reportError` is provided.
+     *
+     * @default POST
+     */
+    errorReportingMethod?: string;
+    /**
+     * Function used to encode the error report.
+     *
+     * By default, the report is encoded into JSON via `JSON.stringify`.
+     *
+     * This property is ignored when a custom `reportError` is provided.
+     *
+     * @param report Report to encode.
+     */
+    encodeErrorReport?: (report: ErrorReport) => BodyInit;
+    /**
+     * MIME type of the error report encoding.
+     *
+     * This property is ignored when a custom `reportError` is provided.
+     *
+     * @default application/json
+     */
+    encodedErrorReportMimeType?: string;
+    /**
+     * Options to provide to the `fetch` call when reporting an error, such as
+     * headers or others. By default, the request is a `POST` with JSON
+     * content-type.
+     *
+     * This property is ignored when a custom `reportError` is provided.
+     */
+    errorReportingOptions?: Omit<RequestInit, "method" | "body">;
+    children?: React.ReactNode;
+}
+/**
+ * Provider used to report errors caught in error boundaries throughout the
+ * application.
+ *
+ * Note that this provider does **not** automatically set an error boundary, so
+ * at least one should be manually set.
+ */
+export declare function ErrorReportingProvider({ enabled, reportError, errorReportingUrl, errorReportingMethod, encodeErrorReport, encodedErrorReportMimeType, errorReportingOptions, children, }: ErrorReportingProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/providers/ErrorReportingProvider/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ErrorReport.ts";
+export * from "./ErrorReportingContext.ts";
+export * from "./ErrorReportingProvider.tsx";
+export * from "./useErrorReporter.ts";

package/dist/types/providers/ErrorReportingProvider/useErrorReporter.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+/** Hook used to report an error. */
+export declare function useErrorReporter(): (error: Error, info?: React.ErrorInfo) => void;

package/dist/types/providers/LocalizationProvider/LocalizationContext.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import { type LocalizationObject } from "../../locale/LocalizationObject.ts";
+/** Value of the localisation context. */
+export type LocalizationContextValue = LocalizationObject;
+/** Localisation context. */
+export declare const LocalizationContext: React.Context<LocalizationObject>;

package/dist/types/providers/LocalizationProvider/LocalizationProvider.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { type LocalizationObject } from "../../locale/LocalizationObject.ts";
+/** Properties of the localisation provider. */
+export interface LocalizationProviderProps {
+    /** Locale to use for the components. */
+    locale?: LocalizationObject;
+    children: React.ReactNode;
+}
+/** Localisation provider. */
+export declare function LocalizationProvider({ locale, children, }: LocalizationProviderProps): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/dist/types/providers/LocalizationProvider/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./LocalizationContext.ts";
+export * from "./LocalizationProvider.tsx";
+export * from "./useLocale.ts";

package/dist/types/providers/LocalizationProvider/useLocale.d.ts

@@ -0,0 +1,3 @@
+import { type LocalizationObject } from "../../locale/LocalizationObject.ts";
+/** Hook used to get the current locale. */
+export declare function useLocale(): LocalizationObject;

package/dist/types/providers/PrefixProvider/PrefixContext.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+/** Default library prefix. */
+export declare const DEFAULT_PREFIX = "oui-";
+/** Prefix context. */
+export declare const PrefixContext: React.Context<string>;

package/dist/types/providers/PrefixProvider/PrefixProvider.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+/** Properties of the prefix provider. */
+export interface PrefixProviderProps {
+    /** Prefix to use. */
+    prefix?: string;
+    children: React.ReactNode;
+}
+/** Prefix provider. */
+export declare function PrefixProvider({ prefix, children }: PrefixProviderProps): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/dist/types/providers/PrefixProvider/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./PrefixContext.ts";
+export * from "./PrefixProvider.tsx";
+export * from "./usePrefix.ts";

package/dist/types/providers/PrefixProvider/usePrefix.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Function which prefixes the provided `toPrefix` string. If no argument is
+ * provided, the prefix is returned as-is.
+ */
+export type PrefixFn = (toPrefix: string) => string;
+/**
+ * Hook which returns a function which can be used to prefix a string with the
+ * current prefix.
+ */
+export declare function usePrefix(): PrefixFn;

package/dist/types/providers/ToastManagerProvider/ToastManagerContext.d.ts

@@ -0,0 +1,35 @@
+import * as React from "react";
+import { type Toast, type ToastDescription, type ToastTitle } from "../../components/Toast";
+import { type DistributedOmit } from "../../utils/typeUtils.ts";
+/** Toast options. */
+export type ToastOptions = DistributedOmit<React.ComponentPropsWithRef<typeof Toast>, "defaultOpen" | "open" | "title"> & {
+    /** Toast's title. */
+    title?: React.ReactNode;
+    /** HTML `title` prop. */
+    htmlTitle?: string;
+    /** Properties to pass to the title component. */
+    titleProps?: React.ComponentPropsWithRef<typeof ToastTitle>;
+    /** Properties to pass to the description component. */
+    descriptionProps?: React.ComponentPropsWithRef<typeof ToastDescription>;
+};
+/** Toast identifier. */
+export type ToastId = number;
+/** Value of the toast manager context. */
+export interface ToastManagerContextValue {
+    /**
+     * Adds a new toast.
+     *
+     * @param description Toast's description.
+     * @param toastOptions Toast's options.
+     * @returns Toast's unique identifier.
+     */
+    addToast: (description: React.ReactNode, toastOptions?: ToastOptions) => ToastId;
+    /**
+     * Removes an existing toast with the given identifier.
+     *
+     * @param toastId Toast identifier.
+     */
+    removeToast: (toastId: ToastId) => void;
+}
+/** Toast manager context. */
+export declare const ToastManagerContext: React.Context<ToastManagerContextValue | undefined>;

package/dist/types/providers/ToastManagerProvider/ToastManagerProvider.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+/** Properties of the toast manager provider. */
+export interface ToastManagerProviderProps {
+    children: React.ReactNode;
+}
+/**
+ * Toast manager provider.
+ *
+ * Note that this provider should be within a `ToastProvider`.
+ */
+export declare function ToastManagerProvider({ children }: ToastManagerProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/providers/ToastManagerProvider/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ToastManagerContext.ts";
+export * from "./ToastManagerProvider.tsx";
+export * from "./useToastManager.ts";

package/dist/types/providers/ToastManagerProvider/useToastManager.d.ts

@@ -0,0 +1,23 @@
+import { type ToastManagerContextValue } from "./ToastManagerContext.ts";
+/**
+ * Hook used to programmatically manage toasts within an application.
+ *
+ * @example
+ *
+ * ```typescript
+ * const { addToast } = useToastManager();
+ *
+ * async function handleNewItemClick() {
+ *   try {
+ *     await api.createNewItem();
+ *     addToast("New item created successfully!", { severity: "success" });
+ *   } catch (err) {
+ *     addToast(err.message, {
+ *       title: "Error creating new item. :-(",
+ *       severity: "danger",
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare function useToastManager(): ToastManagerContextValue;

package/dist/types/utils/accent.d.ts

@@ -0,0 +1,2 @@
+/** Existing accent colours. */
+export type AccentColor = "neutral" | "primary" | "success" | "danger" | "warning";

package/dist/types/utils/boolDataAttr.d.ts

@@ -0,0 +1,4 @@
+/** Value for a data attribute given a condition. */
+export declare function boolDataAttr(condition: boolean | null | undefined): string | undefined;
+/** Sets the provided data attribute on the provided element given a condition. */
+export declare function setBoolDataAttr(element: HTMLElement | null, attr: string, condition: boolean | null | undefined): void;

package/dist/types/utils/breakpoints.d.ts

@@ -0,0 +1,32 @@
+import { type UseMediaQueryOptions } from "./useMediaQuery.ts";
+/** Available breakpoints. */
+export declare const BREAKPOINTS: {
+    readonly xs: 0;
+    readonly sm: 576;
+    readonly md: 768;
+    readonly lg: 992;
+    readonly xl: 1200;
+    readonly xxl: 1400;
+};
+/** Type of available breakpoints. */
+export type Breakpoint = keyof typeof BREAKPOINTS;
+/**
+ * Hook that returns `true` when the screen size is greater or equal than the
+ * width of the provided breakpoint.
+ *
+ * @param breakpoint Breakpoint from which to match.
+ * @param options Media query options.
+ * @returns Whether the screen size is greater or equal than the width of the
+ *   provided breakpoint.
+ */
+export declare function useMediaBreakpointUp(breakpoint: Breakpoint, options?: UseMediaQueryOptions): boolean;
+/**
+ * Hook that returns `true` when the screen size is less than the width of the
+ * provided breakpoint.
+ *
+ * @param breakpoint Breakpoint to up to which to match.
+ * @param options Media query options.
+ * @returns Whether the screen size is less than the width of the provided
+ *   breakpoint.
+ */
+export declare function useMediaBreakpointDown(breakpoint: Breakpoint, options?: UseMediaQueryOptions): boolean;

package/dist/types/utils/changeCase.d.ts

@@ -0,0 +1,2 @@
+/** Converts camel case to kebab case. */
+export declare function camelToKebabCase(str: string): string;

package/dist/types/utils/combineEventHandlers.d.ts

@@ -0,0 +1,24 @@
+type EventHandler<T extends unknown[] = unknown[]> = (...args: T) => void;
+/** Options to pass to the `combineEventHandlers` function. */
+export interface CombineEventHandlersOptions {
+    /**
+     * Whether to check whether an event's default behaviour has been cancelled
+     * before running the second handler.
+     *
+     * @default false
+     */
+    checkDefaultPrevented?: boolean;
+}
+/**
+ * Combines two event handlers into a single event handler.
+ *
+ * @param handler1 First event handler.
+ * @param handler2 Second event handler.
+ * @param options Options.
+ * @returns Combined handler.
+ */
+export declare function combineEventHandlers<T extends unknown[] = unknown[]>(handler1: EventHandler<T>, handler2: EventHandler<T> | undefined, options?: CombineEventHandlersOptions): EventHandler<T>;
+export declare function combineEventHandlers<T extends unknown[] = unknown[]>(handler1: EventHandler<T> | undefined, handler2: EventHandler<T>, options?: CombineEventHandlersOptions): EventHandler<T>;
+export declare function combineEventHandlers(handler1: undefined, handler2: undefined, options?: CombineEventHandlersOptions): undefined;
+export declare function combineEventHandlers<T extends unknown[] = unknown[]>(handler1: EventHandler<T> | undefined, handler2: EventHandler<T> | undefined, options?: CombineEventHandlersOptions): EventHandler<T> | undefined;
+export {};

package/dist/types/utils/control.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { type AccentColor } from "./accent.ts";
+/** Possible status of a control. */
+export type ControlStatus = "valid" | "invalid" | "warned";
+/**
+ * Style variants of a control.
+ *
+ * The `cell` variant should be used to display controls within table cells.
+ */
+export type ControlVariant = "default" | "cell";
+/** Value of the control context. */
+export interface ControlContextValue {
+    variant?: ControlVariant;
+    status?: ControlStatus;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+/** Control context. */
+export declare const ControlContext: React.Context<ControlContextValue | null>;
+/** Hook providing access to the control context. */
+export declare function useControlContext(): ControlContextValue | null;
+/** Transforms a control status into a colour accent. */
+export declare function controlStatusToAccent(status?: ControlStatus, defaultAccent?: AccentColor): AccentColor | undefined;

package/dist/types/utils/cx.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Utility function used to join class names together.
+ *
+ * @example
+ *
+ * ```typescript
+ * cx("foo", "bar", [false, "baz"]); // "foo bar baz"
+ * cx({ foo: true, bar: false }, "baz"); // "foo baz"
+ * ```
+ *
+ * @param args Class arguments to join.
+ * @returns Joined class names.
+ */
+export declare function cx(...args: unknown[]): string | undefined;

package/dist/types/utils/filtering.d.ts

@@ -0,0 +1,14 @@
+/** Result of matching a formatted value against a filter. */
+export interface MatchAgainstFilter {
+    /** Content before the matched content. */
+    before: string;
+    /** Matched content. */
+    matched: string;
+    /** Content after the matched content. */
+    after: string;
+}
+/**
+ * Matches a string value against a filter and returns the match or `null` when
+ * the value doesn't match.
+ */
+export declare function matchAgainstFilter(value: string, filter: string, locale: string): MatchAgainstFilter | null;

package/dist/types/utils/keyboardShortcut.d.ts

@@ -0,0 +1,111 @@
+/** Type of the shortcut action. */
+export type KeyboardShortcutAction = (event: KeyboardEvent) => void;
+/** Options of the `registerKeyboardShortcut` function. */
+export interface RegisterKeyboardShortcutOptions {
+    /**
+     * Target element on which to listen for the keybinds.
+     *
+     * @default window
+     */
+    target?: Window | HTMLElement;
+    /**
+     * Event type to listen for.
+     *
+     * @default keydown
+     */
+    eventType?: "keydown" | "keyup";
+    /**
+     * Keybinding sequences will wait this long (in milliseconds) between key
+     * presses before cancelling.
+     *
+     * @default 1000
+     */
+    sequenceTimeout?: number;
+    /**
+     * Whether the triggered shortcut should be ignored.
+     *
+     * By default, no shortcuts are ignored. However, we provide an auxiliary
+     * function {@link ignoreFormControlsKeyboardShortcut} which ignores keyboard
+     * shortcuts occurring in form controls (`<input>`, `<textarea>`,
+     * `<select>`).
+     *
+     * @param event Keyboard event which triggered the shortcut. `event.target`
+     *   should contain the element in which the event was triggered.
+     * @returns Whether the keyboard shortcut should be ignored.
+     */
+    ignore?: (event: KeyboardEvent) => boolean;
+    /**
+     * Whether key presses should use a capture listener.
+     *
+     * @default false
+     */
+    capture?: boolean;
+    /**
+     * Whether the event's default behaviour should be prevented.
+     *
+     * @default false
+     */
+    preventDefault?: boolean;
+}
+/**
+ * Function which registers an action to run when one of the provided keybinds
+ * is triggered.
+ *
+ * Built on top of the [`tinykeys`](https://jamiebuilds.github.io/tinykeys)
+ * library. For more information on keybinding syntax, read the [`tinykeys`
+ * documentation](https://github.com/jamiebuilds/tinykeys).
+ *
+ * @param keybinds Keybinds which should trigger the action.
+ * @param action Action to run. Receives the keyboard event as an argument.
+ * @param options Configuration options (see
+ *   {@link RegisterKeyboardShortcutOptions}).
+ * @returns Function used to unregister the shortcut.
+ * @see {@link useKeyboardShortcut} for a hook version of this function.
+ */
+export declare function registerKeyboardShortcut(keybinds: string | string[], action: KeyboardShortcutAction, { target, eventType, sequenceTimeout, ignore, capture, preventDefault, }?: RegisterKeyboardShortcutOptions): () => void;
+/** Options of the `useKeyboardShortcut` hook. */
+export interface UseKeyboardShortcutOptions extends Omit<RegisterKeyboardShortcutOptions, "target"> {
+    /**
+     * Target element on which to listen for the keybinds. While set to `null`
+     * keybinds will be ignored.
+     *
+     * @default window
+     */
+    target?: Window | HTMLElement | null;
+}
+/**
+ * Hook which runs an action when one of the provided keybinds is triggered.
+ *
+ * Built on top of the [`tinykeys`](https://jamiebuilds.github.io/tinykeys)
+ * library. For more information on keybinding syntax, read the [`tinykeys`
+ * documentation](https://github.com/jamiebuilds/tinykeys).
+ *
+ * Example usage:
+ *
+ * ```tsx
+ * import { Button, useKeyboardShortcut } from "@ostack.tech/ui";
+ *
+ * function SaveAction() {
+ *   const saveFile = () => {
+ *     // ...
+ *   };
+ *   useKeyboardShortcut("$mod+S", saveFile);
+ *
+ *   return <Button onClick={saveFile}>Save</Button>;
+ * }
+ * ```
+ *
+ * @param keybinds Keybinds which should trigger the action.
+ * @param action Action to run. Receives the keyboard event as an argument.
+ * @param options Configuration options (see
+ *   {@link RegisterKeyboardShortcutOptions}).
+ * @see {@link registerKeyboardShortcut} for a non-hook version of this
+ * function.
+ */
+export declare function useKeyboardShortcut(keybinds: string | string[] | null | undefined, action: KeyboardShortcutAction, { target, eventType, sequenceTimeout, ignore, capture, preventDefault, }?: UseKeyboardShortcutOptions): void;
+/**
+ * `ignore` function to use in `registerKeyboardShortcut`/`useKeyboardShortcut`
+ * which ignores triggered shortcuts which occur in `<input>`, `<textarea>`, or
+ * `<select>` elements.
+ */
+export declare function ignoreFormControlsKeyboardShortcut(event: KeyboardEvent): boolean;

package/dist/types/utils/mergeAriaIds.d.ts

@@ -0,0 +1,2 @@
+/** Merges `aria` identifiers for usage in, for example, `aria-describedby`. */
+export declare function mergeAriaIds(...args: unknown[]): string | undefined;

package/dist/types/utils/nativeControls.d.ts

@@ -0,0 +1,2 @@
+/** Native form controls. */
+export declare const NATIVE_CONTROLS: Set<string>;

package/dist/types/utils/numericStringUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Converts a numberic value to a string, removing exponential notation. Nullish
+ * or `NaN` values become the empty string.
+ */
+export declare function numericToString(v: string | number | null | undefined): string;
+/** Whether a numeric string represents a negative number. */
+export declare function isNumericStringNegative(v: string): boolean;
+/** Whether a numeric string represents the `null` value. */
+export declare function numericStringRepresentsNull(v: string): boolean;
+/** Removes leading and trailing zeros from a numeric string. */
+export declare function normalizeNumericString(v: string): string;
+/**
+ * Compares two numeric strings and returns a positive number if the first one
+ * is greater than the second one, a negative number if the opposite is true, or
+ * zero when they're equal.
+ */
+export declare function compareNumericStrings(v1: string, v2: string): number;
+/**
+ * Transforms an integer numeric string into a float numeric string, given the
+ * scale.
+ */
+export declare function numericStringIntToFloat(v: string, scale: number): string;
+/**
+ * Transforms a float numeric string into an integer numeric string, given the
+ * scale.
+ */
+export declare function numericStringFloatToInt(v: string, scale: number): string;

package/dist/types/utils/parseDateStrict.d.ts

@@ -0,0 +1,7 @@
+import { type FormatOptions, type ParseOptions } from "date-fns";
+/**
+ * Strictly parses a string date into a date.
+ *
+ * Workaround for: https://github.com/date-fns/date-fns/issues/942
+ */
+export declare function parseDateStrict(dateString: string, dateFormat: string, options?: ParseOptions & FormatOptions): Date | null;

package/dist/types/utils/promiseUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether a given value is [promise-like]{@link PromiseLike}.
+ *
+ * @param value Value to check if it is promise-like.
+ * @returns Whether the provided value is like a promise.
+ */
+export declare function isPromiseLike(value: unknown): value is PromiseLike<unknown>;

package/dist/types/utils/setNativeValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sets the native value of an HTML element in a way that isn't detected by
+ * React; meaning that we can then dispatch an event that React will handle.
+ *
+ * See: https://github.com/facebook/react/issues/10135
+ */
+export declare function setNativeValue(element: HTMLElement, value: string): void;

package/dist/types/utils/sorting.d.ts

@@ -0,0 +1,9 @@
+/** Sort direction (ascending or descending). */
+export type SortDirection = "asc" | "desc";
+/** Stable sort implementation. */
+export declare function stableSort<T>(array: T[], comparator?: (v1: T, v2: T, i1: number, i2: number) => number, sortDirection?: SortDirection): T[];
+/**
+ * Comparison function allowing comparison of values of multiple types,
+ * including all primitive types, as well as dates.
+ */
+export declare function compare<T>(v1: T, v2: T): number;

package/dist/types/utils/stringHash.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Non-cryptographically secure string hashing function.
+ *
+ * @param str String to hash.
+ * @returns Hash of the string.
+ */
+export declare function stringHash(str: string): number;

package/dist/types/utils/typeUtils.d.ts

@@ -0,0 +1,2 @@
+/** {@link Omit} that distributes the omission over unions. */
+export type DistributedOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;