@dr.pogodin/react-utils 1.25.5 → 1.26.0

package/build/types-code/client/getInj.d.ts

@@ -0,0 +1,3 @@
+import 'node-forge/lib/aes';
+import type { InjT } from '../shared/utils/globalState';
+export default function getInj(): InjT;

package/build/types-code/client/index.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentType } from 'react';
+type OptionsT = {
+    dontHydrate?: boolean;
+};
+/**
+ * Prepares and launches the app at client side.
+ * @param Application Root application component
+ * @param [options={}] Optional. Additional settings.
+ */
+export default function Launch(Application: ComponentType, options?: OptionsT): void;
+export {};

package/build/types-code/client/init.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Initialization of client-side environment.
+ */
+import { type BuildInfoT } from '../shared/utils/isomorphy/buildInfo';
+declare global {
+    interface Window {
+        __DEV_BUILD_INFO__: BuildInfoT | undefined;
+    }
+}

package/build/types-code/index.d.ts

@@ -0,0 +1,10 @@
+import 'styles/global.scss';
+import type ServerT from './server';
+declare const server: typeof ServerT | null;
+declare const client: any;
+export { default as api } from 'axios';
+export * as PT from 'prop-types';
+export { default as Rgs, type API as RgsApi, getGlobalState, GlobalStateProvider, useAsyncCollection, useAsyncData, useGlobalState, } from '@dr.pogodin/react-global-state';
+export { BaseModal, Button, Checkbox, Dropdown, Input, Link, PageLayout, MetaTags, Modal, NavLink, ScalableRect, Throbber, WithTooltip, YouTubeVideo, } from './shared/components';
+export { type Theme, config, Barrier, Emitter, isomorphy, getSsrContext, JU, Semaphore, splitComponent, themed, ThemeProvider, time, webpack, withRetries, } from './shared/utils';
+export { client, server };

package/build/types-code/server/Cache.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Implements the static cache.
+ */
+export default class Cache<DatumT> {
+    private: {
+        items: {
+            [key: string]: {
+                data: DatumT;
+                size: number;
+                timestamp: number;
+            };
+        };
+        maxSize: number;
+        size: number;
+    };
+    constructor(maxSize: number);
+    /**
+     * Cache lookup.
+     * @param key Item key to look for.
+     * @param [maxage=Number.MAX_VALUE] Optional. The maximum age of
+     *  cached item to serve. Default to infinite.
+     * @returns Cached item, or null if the item is absent in cache,
+     *  or stale.
+     */
+    get({ key, maxage, }: {
+        key: string;
+        maxage?: number;
+    }): DatumT | null;
+    /**
+     * Adds item to cache.
+     * @ignore
+     * @param data Item to add.
+     * @param key Key to store the item at.
+     * @param size Byte size of the item.
+     */
+    add(data: DatumT, key: string, size: number): void;
+}

package/build/types-code/server/index.d.ts

@@ -0,0 +1,145 @@
+/// <reference types="express" />
+/// <reference types="node" />
+import 'source-map-support/register';
+import http from 'http';
+import 'raf/polyfill';
+import { type Configuration } from 'webpack';
+import { type OptionsT as ServerOptionsT } from './server';
+export { getDefaultCspSettings, } from './server';
+export { errors } from './utils';
+type OptionsT = ServerOptionsT & {
+    https?: {
+        cert: string;
+        key: string;
+    };
+    port?: false | number | string;
+};
+/**
+ * Creates and launches web-server for ReactJS application. Allows zero
+ * or detailed configuration, supports server-side rendering,
+ * and development tools, including Hot Module Reloading (HMR).
+ *
+ * NOTE: Many of options defined below are passed down to the server and
+ * renderer factories, and their declared default values are set in those
+ * factories, rather than here.
+ *
+ * @param {object} webpackConfig Webpack configuration used to build
+ * the frontend bundle. In production mode the server will read out of it
+ * `context`, `publicPath`, and a few other parameters, necessary to locate
+ * and serve the app bundle. In development mode the server will use entire
+ * provided config to build the app bundle in memory, and further watch and
+ * update it via HMR.
+ * @param {object} [options] Additional parameters.
+ * @param {Component} [options.Application] The root ReactJS component of
+ * the app to use for the server-side rendering. When not provided
+ * the server-side rendering is disabled.
+ * @param {function} [options.beforeExpressJsError] Asynchronous callback
+ * (`(server) => Promise<boolean>`) to be executed just before the default error
+ * handler is added to ExpressJS server. If the callback is provided and its
+ * result resolves to a truthy value, `react-utils` won't attach the default
+ * error handler.
+ * @param {function} [options.beforeExpressJsSetup] Asynchronous callback
+ * (`(server) => Promise) to be executed right after ExpressJS server creation,
+ * before any configuration is performed.
+ * @param {BeforeRenderHook} [options.beforeRender] The hook to run just before
+ * the server-side rendering. For each incoming request, it will be executed
+ * just before the HTML markup is generated at the server. It allows to load
+ * and provide the data necessary for server-side rendering, and also to inject
+ * additional configuration and scripts into the generated HTML code.
+ * @param {boolean} [options.noCsp] Set `true` to disable
+ * Content-Security-Policy (CSP) headers altogether.
+ * @param {function} [options.cspSettingsHook] A hook allowing
+ * to customize [CSP](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)
+ * settings for [helmet](https://github.com/helmetjs/helmet)'s
+ * `contentSecurityPolicy` middleware on per-request basis.
+ *
+ * If provided it should be a with signature: \
+ * `(defaultSettings: object, req: object)` &rArr; `object` \
+ * which gets the default settings (also used without the hook),
+ * and the incoming request object. The hook response will be passed
+ * as options to the helmet `contentSecurityPolicy` middleware.
+ *
+ * Currently, the default settings is the following object in production
+ * environment:
+ * ```js
+ * {
+ *   directives: {
+ *     defaultSrc: ["'self'"],
+ *     baseUri: ["'self'"],
+ *     blockAllMixedContent: [],
+ *     fontSrc: ["'self'", 'https:', 'data:'],
+ *     frameAncestors: ["'self'"],
+ *     frameSrc: ["'self'", 'https://*.youtube.com'],
+ *     imgSrc: ["'self'", 'data:'],
+ *     objectSrc: ["'none'"],
+ *     scriptSrc: ["'self'", "'unsafe-eval'", `'nonce-UNIQUE_NONCE_VALUE'`],
+ *     scriptSrcAttr: ["'none'"],
+ *     styleSrc: ["'self'", 'https:', "'unsafe-inline'"],
+ *     upgradeInsecureRequests: [] // Removed in dev mode.
+ *   }
+ * }
+ * ```
+ * It matches the default value used by Helmet with a few updates:
+ * - YouTube host is whitelisted in the `frameSrc` directive to ensure
+ *   the {@link YouTubeVideo} component works.
+ * - An unique per-request nonce is added to `scriptSrc` directive to
+ *   whitelist auxiliary scripts injected by react-utils. The actual nonce
+ *   value can be fetched by host code via `.nonce` field of `req` argument
+ *   of `.beforeRender` hook.
+ * - `upgradeInsecureRequests` directive is removed in development mode,
+ *   to simplify local testing with http requests.
+ * @param {string} [options.defaultLoggerLogLevel='info'] Log level for
+ * the default logger, which is created if no `logger` option provided.
+ * @param {boolean} [options.devMode] Pass in `true` to start the server in
+ * development mode.
+ * @param {string} [options.favicon] Path to the favicon to use by the server.
+ * By default no favicon is used.
+ * @param {object} [options.https] If provided, HTTPS server will be started,
+ * instead of HTTP otherwise. The object should provide SSL certificate and key
+ * via two string fields: `cert`, and `key`.
+ * @param {string} [options.https.cert] SSL Certificate.
+ * @param {string} [options.https.key] SSL key.
+ * @param {boolean} [options.httpsRedirect=true] Pass in `true` to enable
+ * automatic redirection of all incoming HTTP requests to HTTPS.
+ *
+ * To smoothly use it at `localhost` you need to run the server in HTTPS mode,
+ * and also properly create and install a self-signed SSL sertificate on your
+ * system. This article is helpful:
+ * [How to get HTTPS working on your local development environment in 5 minutes](https://medium.freecodecamp.org/how-to-get-https-working-on-your-local-development-environment-in-5-minutes-7af615770eec)
+ * @param {Logger} [options.logger] The logger to use at server side.
+ * By default [`winston`](https://www.npmjs.com/package/winston) logger
+ * with console transport is used. The logger you provide, or the default
+ * `winston` logger otherwise, will be attached to the created ExpressJS server
+ * object.
+ * @param {function} [options.onExpressJsSetup] An async callback
+ * (`(server) => Promise`) to be triggered when most of the server
+ * configuration is completed, just before the server-side renderer,
+ * and the default error handler are attached. You can use it to mount
+ * custom API routes. The server-side logger can be accessed as `server.logger`.
+ * @param {number|string} [options.port=3000] The port to start the server on.
+ * @param {number} [options.staticCacheSize=1.e7] The maximum
+ * static cache size in bytes. Defaults to ~10 MB.
+ * @param {function} [options.staticCacheController] When given, it activates,
+ * and controls the static caching of generated HTML markup. When this function
+ * is provided, on each incoming request it is triggered with the request
+ * passed in as the argument. To attempt to serve the response from the cache
+ * it should return the object with the following fields:
+ * - `key: string` &ndash; the cache key for the response;
+ * - `maxage?: number` &ndash; the maximum age of cached result in ms.
+ *   If undefined - infinite age is assumed.
+ * @param {number} [options.maxSsrRounds=10] Maximum number of SSR rounds.
+ * @param {number} [options.ssrTimeout=1000] SSR timeout in milliseconds,
+ * defaults to 1 second.
+ * @return {Promise<{ expressServer: object, httpServer: object }>} Resolves to
+ * an object with created Express and HTTP servers.
+ */
+declare function launchServer(webpackConfig: Configuration, options: OptionsT): Promise<{
+    expressServer: import("express").Express & {
+        logger: import("./renderer").LoggerI;
+    };
+    httpServer: http.Server;
+}>;
+declare namespace launchServer {
+    var SCRIPT_LOCATIONS: typeof import("./renderer").SCRIPT_LOCATIONS;
+}
+export default launchServer;

package/build/types-code/server/renderer.d.ts

@@ -0,0 +1,106 @@
+/**
+ * ExpressJS middleware for server-side rendering of a ReactJS app.
+ */
+import { type Request, type RequestHandler } from 'express';
+import { type ComponentType } from 'react';
+import winston from 'winston';
+import { type BuildInfoT } from '../shared/utils/isomorphy/buildInfo';
+import { type Configuration } from 'webpack';
+interface LogMethodI {
+    (level: string, message: string, ...meta: any[]): void;
+}
+interface LeveledLogMethodI {
+    (message: string, ...meta: any[]): void;
+}
+export interface LoggerI {
+    debug: LeveledLogMethodI;
+    error: LeveledLogMethodI;
+    info: LeveledLogMethodI;
+    log: LogMethodI;
+    warn: LeveledLogMethodI;
+}
+export declare enum SCRIPT_LOCATIONS {
+    BODY_OPEN = "BODY_OPEN",
+    DEFAULT = "DEFAULT",
+    HEAD_OPEN = "HEAD_OPEN"
+}
+type ScriptT = {
+    code: string;
+    location: SCRIPT_LOCATIONS;
+};
+/**
+ * Given an incoming HTTP requests, it deduces whether Brotli-encoded responses
+ * are acceptable to the caller.
+ * @param {object} req
+ * @return {boolean}
+ * @ignore
+ */
+export declare function isBrotliAcceptable(req: Request): boolean;
+/**
+ * Creates a new default (Winston) logger.
+ * @param {object} [options={}]
+ * @param {string} [options.defaultLogLevel='info']
+ * @return {object}
+ */
+export declare function newDefaultLogger({ defaultLogLevel, }?: {
+    defaultLogLevel?: string | undefined;
+}): winston.Logger;
+type ConfigT = {
+    [key: string]: ConfigT | string;
+};
+type BeforeRenderResT = {
+    configToInject?: ConfigT;
+    extraScripts?: Array<ScriptT | string>;
+    initialState?: any;
+};
+type BeforeRenderT = (req: Request, config: ConfigT) => BeforeRenderResT | Promise<BeforeRenderResT>;
+type CacheRefT = {
+    key: string;
+    maxage?: number;
+};
+export type OptionsT = {
+    Application?: ComponentType;
+    beforeRender?: BeforeRenderT;
+    buildInfo?: BuildInfoT;
+    defaultLoggerLogLevel?: string;
+    favicon?: string;
+    logger?: LoggerI;
+    maxSsrRounds?: number;
+    noCsp?: boolean;
+    staticCacheSize?: number;
+    ssrTimeout?: number;
+    staticCacheController?: (req: Request) => CacheRefT;
+};
+/**
+ * Creates the middleware.
+ * @param webpackConfig
+ * @param options Additional options:
+ * @param [options.Application] The root ReactJS component of
+ * the app to use for the server-side rendering. When not provided
+ * the server-side rendering is disabled.
+ * @param [options.buildInfo] "Build info" object to use. If provided,
+ *  it will be used, instead of trying to load from the filesystem the one
+ *  generated by the Webpack build. It is intended for test environments,
+ *  where passing this stuff via file system is no bueno.
+ * @param [options.favicon] `true` will include favicon
+ *  link into the rendered HTML templates.
+ * @param [options.noCsp] `true` means that no
+ * Content-Security-Policy (CSP) is used by server, thus the renderer
+ * may cut a few corners.
+ * @param [options.maxSsrRounds=10] Maximum number of SSR rounds.
+ * @param [options.ssrTimeout=1000] SSR timeout in milliseconds,
+ * defaults to 1 second.
+ * @param [options.staticCacheSize=1.e7] The maximum
+ * static cache size in bytes. Defaults to ~10 MB.
+ * @param [options.staticCacheController] When given, it activates,
+ * and controls the static caching of generated HTML markup. When this function
+ * is provided, on each incoming request it is triggered with the request
+ * passed in as the argument. To attempt to serve the response from the cache
+ * it should return the object with the following fields:
+ * - `key: string` &ndash; the cache key for the response;
+ * - `maxage?: number` &ndash; the maximum age of cached result in ms.
+ *   If undefined - infinite age is assumed.
+ * @return Created middleware.
+ */
+export default function factory(webpackConfig: Configuration, options: OptionsT): RequestHandler;
+export {};

package/build/types-code/server/server.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Creation of standard ExpressJS server for ReactJS apps.
+ */
+import { type Express, type Request } from 'express';
+import { type HelmetOptions } from 'helmet';
+import { type Configuration } from 'webpack';
+import { type LoggerI, type OptionsT as RendererOptionsT } from './renderer';
+export type CspOptionsT = Exclude<HelmetOptions['contentSecurityPolicy'], boolean | undefined>;
+/**
+ * @category Utilities
+ * @func server/getDefaultCspSettings
+ * @global
+ * @desc
+ * ```js
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { getDefaultCspSettings } from '@dr.pogodin/react-utils';
+ * ```
+ * @return {{
+ *   directives: object
+ * }} A deep copy of default CSP settings object used by `react-utils`,
+ * with the exception of `nonce-xxx` clause in `script-src` directive,
+ * which is added dynamically for each request.
+ */
+export declare function getDefaultCspSettings(): {
+    directives: {
+        [x: string]: string[];
+    };
+};
+type ServerT = Express & {
+    logger: LoggerI;
+};
+export type OptionsT = RendererOptionsT & {
+    beforeExpressJsError?: (server: ServerT) => Promise<boolean>;
+    beforeExpressJsSetup?: (server: ServerT) => Promise<void>;
+    cspSettingsHook?: (defaultOptions: CspOptionsT, req: Request) => CspOptionsT;
+    devMode?: boolean;
+    httpsRedirect?: boolean;
+    onExpressJsSetup?: (server: ServerT) => Promise<void> | void;
+};
+export default function factory(webpackConfig: Configuration, options: OptionsT): Promise<ServerT>;
+export {};

package/build/types-code/server/utils/errors.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @category Utilities
+ * @module server/errors
+ * @desc
+ * ```js
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { errors } = server;
+ * ```
+ * Server-side helpers for error handling.
+ */
+import { StatusCodes as CODES, ReasonPhrases as ERRORS, getReasonPhrase as getErrorForCode } from 'http-status-codes';
+import joi from 'joi';
+/**
+ * @static
+ * @const CODES
+ * @desc An alias for
+ * [StatusCodes object from **http-status-codes** library](https://www.npmjs.com/package/http-status-codes).
+ * It is a map between HTTP status code names and corresponding numeric codes.
+ * @example
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { CODES } = server.errors;
+ * console.log(CODES.BAD_REQUEST); // Prints: 400
+ */
+export { CODES };
+/**
+ * @static
+ * @const ERRORS
+ * @desc An alias for
+ * [ReasonPhrases object from **http-status-codes** library](https://www.npmjs.com/package/http-status-codes).
+ * It is a map between HTTP status code names and their pretty-printed forms.
+ * @example
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { ERRORS } = server.errors;
+ * console.log(ERRORS.BAD_REQUEST); // Prints: Bad Request
+ */
+export { ERRORS };
+/**
+ * @static
+ * @func getErrorForCode
+ * @desc An alias for
+ * [getReasonPhrase() function from **http-status-codes** library](https://www.npmjs.com/package/http-status-codes).
+ * Given an HTTP code it returns the corresponding error text.
+ * @param {number} code HTTP code.
+ * @return {string} HTTP error text.
+ * @example
+ * import { server } from '@dr.pogodin/react-utils';
+ * console.log(server.errors.getErrorForCode(400)); // Prints: Bad Request
+ */
+export { getErrorForCode };
+/**
+ * @static
+ * @const joi
+ * @desc An alias for [Joi library](https://joi.dev/api/?v=17.4.0),
+ * which provides tooling for HTTP request validation. You can use it in any
+ * way you would use that library import.
+ * @example
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { joi } = server.errors;
+ * const requestBodySchema = joi.object({
+ *   sampleKey: joi.string().max(16).required(),
+ * });
+ */
+export { joi };
+declare class ErrorWithStatus extends Error {
+    status: number;
+}
+/**
+ * ```js
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { newError } = server.errors;
+ * ```
+ * Creates a new `Error` object with given message, and HTTP status code
+ * attached as `status` field.
+ * @param {string} message Error message.
+ * @param {number} [statusCode=500] HTTP status code. Defaults to 500 (Internal
+ * Server Error).
+ * @return {Error}
+ */
+export declare function newError(message: string, statusCode?: CODES): ErrorWithStatus;
+/**
+ * ```js
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { fail } = server.errors;
+ * ```
+ * Throws an error with given message and HTTP status code.
+ * @param message Error message.
+ * @param [statusCode=500] HTTP error code. Defaults to 500 (Internal
+ * Server Error).
+ */
+export declare function fail(message: string, statusCode?: CODES): void;
+/**
+ * ```js
+ * import { server } from '@dr.pogodin/react-utils';
+ * const { assert } = server.errors;
+ * ```
+ * Validates a value using given Joi schema, and throws an error with given
+ * message and HTTP status code in case of the validation failure.
+ * @param value
+ * @param schema
+ * @param [message] Error message.
+ * @param [statusCode=500] HTTP status code. Defaults to 400 (Bad
+ * Request).
+ */
+export declare function assert(value: any, schema: joi.AnySchema, message?: string, statusCode?: CODES): void;

package/build/types-code/server/utils/index.d.ts

@@ -0,0 +1 @@
+export * as errors from './errors';

package/build/types-code/shared/components/Button/index.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import { type Theme } from '@dr.pogodin/react-themes';
+type PropsT = {
+    active?: boolean;
+    children?: ReactNode;
+    disabled?: boolean;
+    enforceA?: boolean;
+    onClick?: React.MouseEventHandler & React.KeyboardEventHandler;
+    onMouseDown?: React.MouseEventHandler;
+    openNewTab?: boolean;
+    replace?: boolean;
+    theme: Theme & {
+        active?: string;
+        button?: string;
+        disabled?: string;
+    };
+    to?: object | string;
+};
+/**
+ * Button component theme: a map of CSS
+ * class names to append to button elements:
+ * @prop {string} [active] to the root element of active button.
+ * @prop {string} [button] to the root element of any button.
+ * @prop {string} [disabled] to the root element of disabled button.
+ */
+declare const ThemedButton: import("@dr.pogodin/react-themes").ThemedComponent<PropsT>;
+export default ThemedButton;

package/build/types-code/shared/components/Checkbox/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import { type Theme } from '@dr.pogodin/react-themes';
+type PropT = {
+    checked?: boolean;
+    label?: string;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    theme: Theme & {
+        checkbox?: string;
+        container?: string;
+        label?: string;
+    };
+};
+/**
+ * Checkbox component theme: a map of
+ * CSS classes to append to its elements:
+ * @prop [checkbox] to the underlying checkbox `<input>` element.
+ * @prop [container] to the root checkbox element.
+ * @prop [label] to the checkbox label element.
+ */
+declare const ThemedCheckbox: import("@dr.pogodin/react-themes").ThemedComponent<PropT>;
+export default ThemedCheckbox;

package/build/types-code/shared/components/Dropdown/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { type Theme } from '@dr.pogodin/react-themes';
+type DropdownOptionT = {
+    name?: string | null;
+    value: string;
+};
+type PropsT = {
+    filter?: (item: DropdownOptionT | string) => boolean;
+    label?: string;
+    onChange?: React.ChangeEventHandler<HTMLSelectElement>;
+    options?: Array<DropdownOptionT | string>;
+    theme: Theme & {
+        arrow?: string;
+        container?: string;
+        hiddenOption?: string;
+        label?: string;
+        option?: string;
+        select?: string;
+    };
+    value?: string;
+};
+declare const ThemedDropdown: import("@dr.pogodin/react-themes").ThemedComponent<PropsT>;
+export default ThemedDropdown;

package/build/types-code/shared/components/GenericLink/index.d.ts

@@ -0,0 +1,61 @@
+import { type ReactNode } from 'react';
+import { type Link } from 'react-router-dom';
+import './style.scss';
+type ToT = Parameters<typeof Link>[0]['to'];
+interface LinkI {
+}
+export type PropsT = {
+    children?: ReactNode;
+    className?: string;
+    disabled?: boolean;
+    enforceA?: boolean;
+    keepScrollPosition?: boolean;
+    onClick?: React.MouseEventHandler<HTMLAnchorElement>;
+    onMouseDown?: React.MouseEventHandler<HTMLAnchorElement>;
+    openNewTab?: boolean;
+    replace?: boolean;
+    routerLinkType: LinkI;
+    to?: ToT;
+};
+/**
+ * The `<Link>` component, and almost identical `<NavLink>` component, are
+ * auxiliary wrappers around
+ * [React Router](https://github.com/ReactTraining/react-router)'s
+ * `<Link>` and `<NavLink>` components; they help to handle external and
+ * internal links in uniform manner.
+ *
+ * @param [props] Component properties.
+ * @param [props.className] CSS classes to apply to the link.
+ * @param [props.disabled] Disables the link.
+ * @param [props.enforceA] `true` enforces rendering of the link as
+ * a simple `<a>` element.
+ * @param [props.keepScrollPosition] If `true`, and the link is
+ * rendered as a React Router's component, it won't reset the viewport scrolling
+ * position to the origin when clicked.
+ * @param [props.onClick] Event handler to trigger upon click.
+ * @param [props.onMouseDown] Event handler to trigger on MouseDown
+ * event.
+ * @param [props.openNewTab] If `true` the link opens in a new tab.
+ * @param [props.replace] When `true`, the link will replace current
+ * entry in the history stack instead of adding a new one.
+ * @param [props.to] Link URL.
+ * @param [props.activeClassName] **`<NavLink>`** only: CSS class(es)
+ * to apply to rendered link when it is active.
+ * @param [props.activeStyle] **`<NavLink>`** only: CSS styles
+ * to apply to the rendered link when it is active.
+ * @param [props.exact] **`<NavLink>`** only: if `true`, the active
+ * class/style will only be applied if the location is matched exactly.
+ * @param [props.isActive] **`<NavLink>`** only: Add extra
+ * logic for determining whether the link is active. This should be used if you
+ * want to do more than verify that the link’s pathname matches the current URL
+ * pathname.
+ * @param [props.location] **`<NavLink>`** only: `isActive` compares
+ * current history location (usually the current browser URL). To compare to
+ * a different location, a custom `location` can be passed.
+ * @param [props.strict] **`<NavLink>`** only: . When `true`, trailing
+ * slash on a location’s pathname will be taken into consideration when
+ * determining if the location matches the current URL. See the `<Route strict>`
+ * documentation for more information.
+ */
+declare const GenericLink: React.FunctionComponent<PropsT>;
+export default GenericLink;

package/build/types-code/shared/components/Input/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { type Theme } from '@dr.pogodin/react-themes';
+declare const ThemedInput: import("@dr.pogodin/react-themes").ThemedComponent<React.InputHTMLAttributes<HTMLInputElement> & {
+    label?: string | undefined;
+    theme: Theme & {
+        container?: string;
+        input?: string;
+        label?: string;
+    };
+} & React.RefAttributes<HTMLInputElement>>;
+export default ThemedInput;

package/build/types-code/shared/components/Link.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The Link wraps around React Router's Link component, to automatically replace
+ * it by the regular <a> element when:
+ * - The target reference points to another domain;
+ * - User opts to open the reference in a new tab;
+ * - User explicitely opts to use <a>.
+ */
+/// <reference types="react" />
+import { type PropsT as GenericLinkPropsT } from './GenericLink';
+type PropsT = Omit<GenericLinkPropsT, 'routerLinkType'>;
+declare const Link: React.FunctionComponent<PropsT>;
+export default Link;