@dr.pogodin/react-utils 1.25.5 → 1.26.0

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

@@ -0,0 +1,68 @@
+import { type ReactNode } from 'react';
+type PropsT = {
+    children?: ReactNode;
+    description: string;
+    image?: string;
+    siteName?: string;
+    socialDescription?: string;
+    socialTitle?: string;
+    title: string;
+    url?: string;
+};
+/**
+ * The `<MetaTags>` component is an auxiliary wrapper around `react-helmet`,
+ * which helps to inject meta tags (page title, a brief content description,
+ * and social media thumbnails) into generated pages.
+ *
+ * When `<MetaTags>` are nested within the app's component tree, meta tags
+ * content injected by components encountered down the tree overrides tags
+ * injected by previously encountered `<MetaTags>` components.
+ *
+ * **Children:** `<MetaTags>` children, if any, are rendered at the component's
+ * location. The context passes down all meta tag properties of parent
+ * `<MetaTag>` instances. These properties can fetched within children
+ * hierarchy in the following way, thus facilitating tags modification by
+ * children:
+ * ```jsx
+ * import { useContext } from 'react';
+ * import { MetaTags } from '@dr.pogodin/react-utils';
+ * export default function SampleComponent() {
+ *   const { title, description, ...rest } = useContext(MetaTags.Context);
+ *   // Do something with these props here, e.g. prefix the page title with
+ *   // the component name:
+ *   return (
+ *     <MetaTags title={`Sample component - ${title}`} />
+ *   );
+ * }
+ * ```
+ * @param [props]
+ * @param [props.description] Page description to use in
+ * the `description` meta tag, and as a default description of Open Graph Tags.
+ * @param [props.image] The absolute URL of thumbnail image to use
+ * in Open Graph Tags (`twitter:image`, and `og:image`). By default these tags
+ * are not injected.
+ *
+ * **BEWARE:** It must be a complete, absolute URL, including the correct
+ * website domain and HTTP schema.
+ *
+ * @param [props.siteName]: The site name to use in `twitter:site`,
+ * and `og:sitename` tags. By default these tags are not injected.
+ *
+ * @param [props.socialDescription] The site description to use in
+ * `twitter:description` and `og:description` meta tags. By default the value of
+ * `description` prop is used.
+ * @param [props.socialTitle] The page title to use in
+ * `twitter:title`, `og:title`, and `og:image:alt` tags. By default the value of
+ * `title` prop is used. Also the `og:image:alt` tag is only injected if `image`
+ * prop is present.
+ *
+ * @param props.title: The page name to use in the `<title>` tag.
+ * It is also used as the default value of `socialTitle` prop.
+ *
+ * @param [props.url] The page URL to use in `og:url` tag.
+ * By default the tag is not injected.
+ */
+declare const MetaTags: React.FunctionComponent<PropsT> & {
+    Context: React.Context<PropsT>;
+};
+export default MetaTags;

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

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import { type Theme } from '@dr.pogodin/react-themes';
+import './styles.scss';
+type PropsT = {
+    children?: ReactNode;
+    onCancel?: () => void;
+    theme: Theme & {
+        container?: string;
+        overlay?: string;
+    };
+};
+/**
+ * The `<Modal>` component implements a simple themeable modal window, wrapped
+ * into the default theme. `<BaseModal>` exposes the base non-themed component.
+ * **Children:** Component children are rendered as the modal content.
+ * @param {object} props Component properties. Beside props documented below,
+ *  [Other theming properties](https://www.npmjs.com/package/@dr.pogodin/react-themes#themed-component-properties) are supported as well.
+ * @param {function} [props.onCancel] The callback to trigger when user
+ * clicks outside the modal, or presses Escape. It is expected to hide the
+ * modal.
+ * @param {ModalTheme} [props.theme] _Ad hoc_ theme.
+ */
+declare const BaseModal: React.FunctionComponent<PropsT>;
+declare const ThemedModal: import("@dr.pogodin/react-themes").ThemedComponent<PropsT>;
+export default ThemedModal;
+export { BaseModal };

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

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { type PropsT as GenericLinkPropsT } from './GenericLink';
+type PropsT = Omit<GenericLinkPropsT, 'routerLinkType'>;
+declare const NavLink: React.FunctionComponent<PropsT>;
+export default NavLink;

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

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import { type Theme } from '@dr.pogodin/react-themes';
+type PropsT = {
+    children?: ReactNode;
+    leftSidePanelContent?: ReactNode;
+    rightSidePanelContent?: ReactNode;
+    theme: Theme & {
+        container?: string;
+        mainPanel?: string;
+        sidePanel?: string;
+        leftSidePanel?: string;
+        rightSidePanel?: string;
+    };
+};
+declare const ThemedPageLayout: import("@dr.pogodin/react-themes").ThemedComponent<PropsT>;
+export default ThemedPageLayout;

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

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+import './style.scss';
+type PropsT = {
+    children?: ReactNode;
+    className?: string;
+    ratio?: `${number}:${number}`;
+};
+/**
+ * The `<ScalableRect>` component implements container keeping given aspect
+ * ratio, while its width is altered.
+ *
+ * **Children:** Component children are rendered as the component's content.
+ * @param {object} props
+ * @param {string} [props.className] CSS class for component container.
+ * @param {string} [props.ratio=1:1] Ratio of the rendered rectangle sides,
+ * in `W:H` form.
+ */
+declare const ScalableRect: React.FunctionComponent<PropsT>;
+export default ScalableRect;

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

@@ -0,0 +1,9 @@
+import { type Theme } from '@dr.pogodin/react-themes';
+type PropsT = {
+    theme: Theme & {
+        container?: string;
+        circle?: string;
+    };
+};
+declare const ThemedThrobber: import("@dr.pogodin/react-themes").ThemedComponent<PropsT>;
+export default ThemedThrobber;

package/build/types-code/shared/components/WithTooltip/Tooltip.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The actual tooltip component. It is rendered outside the regular document
+ * hierarchy, and with sub-components managed without React to achieve the best
+ * performance during animation.
+ */
+import { type ReactNode } from 'react';
+export declare enum PLACEMENTS {
+    ABOVE_CURSOR = "ABOVE_CURSOR",
+    ABOVE_ELEMENT = "ABOVE_ELEMENT",
+    BELOW_CURSOR = "BELOW_CURSOR",
+    BELOW_ELEMENT = "BELOW_ELEMENT"
+}
+export interface TooltipThemeT {
+    appearance?: string;
+    arrow?: string;
+    content?: string;
+    container?: string;
+}
+declare const Tooltip: React.ForwardRefExoticComponent<{
+    children?: ReactNode;
+    theme: any;
+} & React.RefAttributes<unknown>>;
+export default Tooltip;

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

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import { type Theme } from '@dr.pogodin/react-themes';
+import { PLACEMENTS, type TooltipThemeT } from './Tooltip';
+type PropsT = {
+    children?: ReactNode;
+    placement?: PLACEMENTS;
+    tip?: ReactNode;
+    theme: Theme & TooltipThemeT & {
+        wrapper?: string;
+    };
+};
+declare const ThemedWrapper: import("@dr.pogodin/react-themes").ThemedComponent<PropsT>;
+type ExportT = typeof ThemedWrapper & {
+    PLACEMENTS: typeof PLACEMENTS;
+};
+declare const e: ExportT;
+export default e;

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

@@ -0,0 +1,13 @@
+import { type Theme } from '@dr.pogodin/react-themes';
+type ComponentThemeT = Theme & {
+    container?: string;
+    video?: string;
+};
+type PropsT = {
+    autoplay?: boolean;
+    src: string;
+    theme: ComponentThemeT;
+    title?: string;
+};
+declare const ThemedYouTubeVideo: import("@dr.pogodin/react-themes").ThemedComponent<PropsT>;
+export default ThemedYouTubeVideo;

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

@@ -0,0 +1,16 @@
+/**
+ * Just an aggregation of all exported components into a single module.
+ */
+export { default as Button } from './Button';
+export { default as Checkbox } from './Checkbox';
+export { default as Dropdown } from './Dropdown';
+export { default as Input } from './Input';
+export { default as Link } from './Link';
+export { default as PageLayout } from './PageLayout';
+export { default as MetaTags } from './MetaTags';
+export { default as Modal, BaseModal } from './Modal';
+export { default as NavLink } from './NavLink';
+export { default as ScalableRect } from './ScalableRect';
+export { default as Throbber } from './Throbber';
+export { default as WithTooltip } from './WithTooltip';
+export { default as YouTubeVideo } from './YouTubeVideo';

package/build/types-code/shared/utils/config.d.ts

@@ -0,0 +1,2 @@
+declare const config: any;
+export default config;

package/build/types-code/shared/utils/globalState.d.ts

@@ -0,0 +1,20 @@
+import type { Request } from 'express';
+import { type SsrContext } from '@dr.pogodin/react-global-state';
+export type ChunkGroupsT = {
+    [chunkName: string]: string[];
+};
+export type InjT = {
+    CHUNK_GROUPS?: ChunkGroupsT;
+    CONFIG?: {
+        [key: string]: any;
+    };
+    ISTATE?: unknown;
+};
+export interface SsrContextT<StateT> extends SsrContext<StateT> {
+    chunkGroups: ChunkGroupsT;
+    chunks: string[];
+    req: Request;
+    status: number;
+}
+declare const getSsrContext: (throwWithoutSsrContext?: boolean | undefined) => SsrContextT<unknown> | undefined;
+export { getSsrContext, };

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

@@ -0,0 +1,52 @@
+import themedImpl, { type Theme, COMPOSE, PRIORITY, ThemeProvider } from '@dr.pogodin/react-themes';
+import config from './config';
+import * as isomorphy from './isomorphy';
+import time from './time';
+import * as webpack from './webpack';
+import type * as JuT from './jest';
+export { Barrier, Emitter, Semaphore } from '@dr.pogodin/js-utils';
+export { getSsrContext } from './globalState';
+export { default as splitComponent } from './splitComponent';
+type ThemedT = typeof themedImpl & {
+    COMPOSE: typeof COMPOSE;
+    PRIORITY: typeof PRIORITY;
+};
+declare const themed: ThemedT;
+declare const JU: typeof JuT | null;
+/**
+ * @category Utilities
+ * @global
+ * @func withRetries
+ * @desc
+ * ```js
+ * import { withRetries } from '@dr.pogodin/react-utils';
+ * ```
+ * Attempts to perform given asynchronous `action` up to `maxRetries` times,
+ * with the given `interval` between attempts. If any attempt is successful,
+ * the result is returned immediately, with no further attempts done;
+ * otherwise, if all attempts fail, the result Promise rejects after the last
+ * attempt.
+ * @param {function} action
+ * @param {number} [maxRetries=5] Optional. Maximum number of retries. Defaults
+ *  to 5 attempts.
+ * @param {number} [interval=1000] Optional. Interval between retries [ms].
+ *  Defaults to 1 second.
+ * @return {Promise} Resolves to the result of successful operation, or
+ *  rejects with the error from the latst failed attempt.
+ * @example
+ * import { withRetries } from '@dr.pogodin/react-utils';
+ *
+ * let firstCall = true;
+ *
+ * function sampleAction() {
+ *   if (!firstCall) return 'success';
+ *   firstCall = false;
+ *   throw Error('The first call to this method fails');
+ * }
+ *
+ * withRetries(sampleAction).then(console.log);
+ * // It will print 'success' after one second, once the second attempt
+ * // is performed.
+ */
+export declare function withRetries(action: () => Promise<unknown>, maxRetries?: number, interval?: number): Promise<unknown>;
+export { type Theme, config, isomorphy, JU, themed, ThemeProvider, time, webpack, };

package/build/types-code/shared/utils/isomorphy/buildInfo.d.ts

@@ -0,0 +1,23 @@
+export type BuildInfoT = {
+    key: string;
+    publicPath: string;
+    timestamp: string;
+    useServiceWorker: boolean;
+};
+declare global {
+    const BUILD_INFO: BuildInfoT | undefined;
+}
+/**
+ * In scenarious where "BUILD_INFO" is not injected by Webpack (server-side,
+ * tests, etc.) we expect the host codebase to explicitly set it before it is
+ * ever requested. As a precaution, this function throws if build info has been
+ * set already, unless `force` flag is explicitly set.
+ * @param info
+ * @param force
+ */
+export declare function setBuildInfo(info?: BuildInfoT, force?: boolean): void;
+/**
+ * Returns "Build Info" object; throws if it has not been initialized yet.
+ * @returns
+ */
+export declare function getBuildInfo(): BuildInfoT;

package/build/types-code/shared/utils/isomorphy/environment-check.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    var REACT_UTILS_FORCE_CLIENT_SIDE: boolean | undefined;
+}
+/**
+ * `true` within client-side environment (browser), `false` at server-side.
+ */
+export declare const IS_CLIENT_SIDE: boolean;
+/**
+ * `true` within the server-side environment (node), `false` at client-side.
+ */
+export declare const IS_SERVER_SIDE: boolean;

package/build/types-code/shared/utils/isomorphy/index.d.ts

@@ -0,0 +1,20 @@
+import { getBuildInfo } from './buildInfo';
+import { IS_CLIENT_SIDE, IS_SERVER_SIDE } from './environment-check';
+/**
+ * Returns `true` if development version of the code is running;
+ * `false` otherwise.
+ * @return {boolean}
+ */
+export declare function isDevBuild(): boolean;
+/**
+ * Returns `true` if production build of the code is running;
+ * `false` otherwise.
+ * @return {boolean}
+ */
+export declare function isProdBuild(): boolean;
+/**
+ * Returns build timestamp of the front-end JS bundle.
+ * @return {string} ISO date/time string.
+ */
+export declare function buildTimestamp(): string;
+export { IS_CLIENT_SIDE, IS_SERVER_SIDE, getBuildInfo };

package/build/types-code/shared/utils/jest/E2eSsrEnv.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Jest environment for end-to-end SSR and client-side testing. It relies on
+ * the standard react-utils mechanics to execute SSR of given scene, and also
+ * Webpack build of the code for client-side execution, it further exposes
+ * Jsdom environment for the client-side testing of the outcomes.
+ */
+import JsdomEnv from 'jest-environment-jsdom';
+import webpack from 'webpack';
+import type { EnvironmentContext, JestEnvironmentConfig } from '@jest/environment';
+export default class E2eSsrEnv extends JsdomEnv {
+    pragmas: Record<string, string | string[]>;
+    ssrRequest: object;
+    rootDir: string;
+    testFolder: string;
+    withSsr: boolean;
+    webpackStats?: webpack.StatsCompilation;
+    /**
+     * Loads Webpack config, and exposes it to the environment via global
+     * webpackConfig object.
+     */
+    loadWebpackConfig(): void;
+    /**
+     * Executes Webpack build.
+     * @return {Promise}
+     */
+    runWebpack(): Promise<void>;
+    runSsr(): Promise<void>;
+    constructor(config: JestEnvironmentConfig, context: EnvironmentContext);
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+}

package/build/types-code/shared/utils/jest/global.d.ts

@@ -0,0 +1,12 @@
+import { type IFs } from 'memfs';
+import webpack from 'webpack';
+declare global {
+    interface Window {
+        ssrMarkup: string | undefined;
+        ssrStatus: number | undefined;
+        webpackConfig: webpack.Configuration | undefined;
+        webpackOutputFs: IFs;
+        webpackStats?: webpack.StatsCompilation;
+    }
+}
+export default function getGlobal(): Window;

package/build/types-code/shared/utils/jest/index.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="trusted-types" />
+import { type ReactElement, type ReactNode } from 'react';
+import TU, { act } from 'react-dom/test-utils';
+import Renderer from 'react-test-renderer';
+/**
+ * An alias for [act(..)](https://reactjs.org/docs/test-utils.html#act)
+ * from `react-dom/test-utils`.
+ * @param {function} action
+ */
+export { act };
+export { default as getGlobal } from './global';
+declare global {
+    var IS_REACT_ACT_ENVIRONMENT: boolean | undefined;
+}
+/**
+ * Tricks **react-utils** into thinking the test is running within client-side
+ * (browser) environment.
+ */
+export declare function mockClientSide(): void;
+/**
+ * Reverts the effect of {@link module:JU.mockClientSide mockClientSide(..)}.
+ */
+export declare function unmockClientSide(): void;
+/**
+ * Generates a mock UUID, or better said it determenistically transforms given
+ * `seed` number into a UUID-formatted string.
+ * @param {number} seed
+ * @return {string}
+ */
+export declare function getMockUuid(seed?: number): string;
+/**
+ * Advances mock timers, and mock date by the specified time.
+ * @param {number} time Time step [ms].
+ * @returns {Promise} Wait for this to "jump after" any async code which should
+ * be executed because of the mock time movement.
+ */
+export declare function mockTimer(time: number): Promise<void>;
+export type MountedSceneT = HTMLElement & {
+    destroy: () => void;
+};
+/**
+ * Mounts `scene` to the DOM, and returns the root scene element.
+ * @param scene
+ * @return Created container DOM element with destroy() function
+ *  attached.
+ */
+export declare function mount(scene: ReactNode): MountedSceneT;
+/**
+ * Renders provided ReactJS component into JSON representation of the component
+ * tree, using [`react-test-renderer`](https://www.npmjs.com/package/react-test-renderer).
+ * @param {object} component ReactJS component to render.
+ * @return {object} JSON representation of the rendered tree.
+ * @example
+ * import { JU } from '@dr.pogodin/react-utils';
+ * console.log(JU.render(<div>Example</div>));
+ */
+export declare function render(component: ReactElement): Renderer.ReactTestRendererJSON | Renderer.ReactTestRendererJSON[] | null;
+/**
+ * Generates a shallow render of given ReactJS component, using
+ * [react-test-renderer/shallow](https://reactjs.org/docs/shallow-renderer.html)
+ * and returns the result.
+ * @param {object} component ReactJS component to render.
+ * @return {object} JSON representation of the shallow component's render tree.
+ */
+export declare function shallowRender(component: ReactElement): ReactElement<any, string | React.JSXElementConstructor<any>>;
+/**
+ * Makes a shallow snapshot test of the given ReactJS component, and also
+ * returns JSON representation of the rendered component tree. Under the hood
+ * it uses {@link module:JU.shallowRender shallowRender(..)} to generate
+ * the render, then executes `expect(RENDER_RESULT).toMatchSnapshot()`,
+ * and finally returns the `RENDER_RESULT` to the caller.
+ * @param {object} component ReactJS component to render.
+ * @return {object} JSON representation of shallow render.
+ */
+export declare function shallowSnapshot(component: ReactElement): ReactElement<any, string | React.JSXElementConstructor<any>>;
+/**
+ * Makes snapshot test of the given ReactJS component, and also returns JSON
+ * representation of the rendered component tree. Under the hood, it uses
+ * {@link module:JU.render render(..)} to render it, then executes
+ * `expect(RENDER_RESULT).toMatchSnapshot()`, and then returns `RENDER_RESULT`.
+ * @param {object} component ReactJS component to render.
+ * @return {object} JSON render of the component.
+ */
+export declare function snapshot(component: ReactElement): Renderer.ReactTestRendererJSON | Renderer.ReactTestRendererJSON[] | null;
+export declare const simulate: typeof TU.Simulate;

package/build/types-code/shared/utils/splitComponent.d.ts

@@ -0,0 +1,41 @@
+import { type ComponentType, type ReactNode } from 'react';
+import { type ChunkGroupsT } from './globalState';
+/**
+ * Client-side only! Ensures all CSS stylesheets required for the specified
+ * code chunk are loaded into the document; loads the missing ones; and does
+ * simple reference counting to facilitate future clean-up.
+ * @param chunkName Chunk name.
+ * @param refCount
+ * @return Resolves once all pending stylesheets, necessary for
+ *  the chunk, are either loaded, or failed to load.
+ */
+export declare function bookStyleSheets(chunkName: string, chunkGroups: ChunkGroupsT, refCount: boolean): Promise<void>;
+/**
+ * Client-side only! Frees from the document all CSS stylesheets that are
+ * required by the specified chunk, and have reference counter equal to one
+ * (for chunks with larger reference counter values, it just decrements
+ * the reference counter).
+ * @param {string} chunkName
+ */
+export declare function freeStyleSheets(chunkName: string, chunkGroups: ChunkGroupsT): void;
+type ComponentOrModule<PropsT> = ComponentType<PropsT> | {
+    default: ComponentType<PropsT>;
+};
+/**
+ * Given an async component retrieval function `getComponent()` it creates
+ * a special "code split" component, which uses <Suspense> to asynchronously
+ * load on demand the code required by `getComponent()`.
+ * @param options
+ * @param options.chunkName
+ * @param {function} options.getComponent
+ * @param {React.Element} [options.placeholder]
+ * @return {React.ElementType}
+ */
+export default function splitComponent<ComponentPropsT extends {
+    children?: ReactNode;
+}>({ chunkName, getComponent, placeholder, }: {
+    chunkName: string;
+    getComponent: () => Promise<ComponentOrModule<ComponentPropsT>>;
+    placeholder?: ReactNode;
+}): React.FunctionComponent<ComponentPropsT>;
+export {};

package/build/types-code/shared/utils/time.d.ts

@@ -0,0 +1,62 @@
+import dayjs from 'dayjs';
+import { timer } from '@dr.pogodin/js-utils';
+/**
+ * This react hook wraps Date.now() function in a SSR friendly way,
+ * ensuring that all calls to useCurrent() within the same render return
+ * exactly the same time (which is retrieved from Date.now() first, and
+ * then stored in the global state to be reused in all other calls), which
+ * is also passed and used in the first client side render, and then updated
+ * with a finite precision to avoid infinite re-rendering loops.
+ * @param [options] Optional settings.
+ * @param [options.globalStatePath="currentTime"] Global state path
+ *  to keep the current time value.
+ * @param [options.precision= 5 * time.SEC_MS] Current time precision.
+ *  The hook won't update the current time stored in the global state unless it
+ *  is different from Date.now() result by this number (in milliseconds).
+ *  Default to 5 seconds.
+ * @param [options.autorefresh=false] Set `true` to automatically
+ *  refresh time stored in the global state with the given `precision` (and
+ *  thus automatically re-rendering components dependent on this hook, or
+ *  the global state with the period equal to the `precision`.
+ * @return Unix timestamp in milliseconds.
+ */
+export declare function useCurrent({ autorefresh, globalStatePath, precision, }?: {
+    autorefresh?: boolean | undefined;
+    globalStatePath?: string | undefined;
+    precision?: number | undefined;
+}): number;
+/**
+ * Wraps the standard Date.getTimezoneOffset() method in a SSR-friendly way.
+ * This hook retrieves the offset value at the client side and uses a cookie
+ * to pass it to the server in subsequent requests from that user. At the server
+ * side the value from cookie is used in renders and passed back to the client
+ * via the global state. Prior to the value being known (in the very first
+ * request from the user, when the cookie is still missing), zero value is used
+ * as the default value.
+ *
+ * @param {object} [options] Optional settings.
+ * @param {string} [options.cookieName="timezoneOffset"] Optional. The name of
+ *  cookie to use to store the timezone offset. Defaults "timezoneOffset". Set
+ *  to a falsy value to forbid using cookies altogether (in that case the hook
+ *  will always return zero value at the server-side, and in the first render
+ *  at the client-side).
+ * @param {string} [options.timezoneOffset="timezoneOffset"] Optional.
+ *  The global state path to store the offset. Defaults "timezoneOffset".
+ * @return {number} Timezone offset.
+ */
+export declare function useTimezoneOffset({ cookieName, globalStatePath, }?: {
+    cookieName?: string | undefined;
+    globalStatePath?: string | undefined;
+}): number;
+declare const _default: typeof dayjs & {
+    DAY_MS: number;
+    HOUR_MS: number;
+    MIN_MS: number;
+    SEC_MS: number;
+    YEAR_MS: number;
+    now: () => number;
+    timer: typeof timer;
+    useCurrent: typeof useCurrent;
+    useTimezoneOffset: typeof useTimezoneOffset;
+};
+export default _default;

package/build/types-code/shared/utils/webpack.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/**
+ * Requires the specified module without including it into the bundle during
+ * Webpack build.
+ * @param modulePath
+ * @param [basePath]
+ * @return Required module.
+ */
+export declare function requireWeak(modulePath: string, basePath?: string): NodeJS.Module | null;
+/**
+ * Resolves specified module path with help of Babel's module resolver.
+ * Yes, the function itself just returns its argument to the caller, but Babel
+ * is configured to resolve the first argument of resolveWeak(..) function, thus
+ * the result will be the resolved path.
+ * @param {string} modulePath
+ * @return {string} Absolute or relative path to the module.
+ */
+export declare function resolveWeak(modulePath: string): string;

package/build/types-scss/__tests__/js/config/publicPath support/__assets__/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const container: string;

package/build/types-scss/__tests__/js/config/stylename-generation/__assets__/MockPackageA/TestComponent/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const testClassName: string;

package/build/types-scss/__tests__/js/config/stylename-generation/__assets__/MockPackageB/TestComponent/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const testClassName: string;

package/build/types-scss/__tests__/js/config/stylename-generation/__assets__/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const sampleClassName: string;

package/build/types-scss/__tests__/js/shared/components/NavLink/styles.scss.d.ts

@@ -0,0 +1 @@
+export declare const navLink: string;

package/build/types-scss/__tests__/js/shared/utils/splitComponent/__assets__/SampleScene/ComponentA/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const container: string;

package/build/types-scss/__tests__/js/shared/utils/splitComponent/__assets__/SampleScene/ComponentB/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const container: string;

package/build/types-scss/__tests__/js/shared/utils/splitComponent/__assets__/SampleScene/ComponentC/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const container: string;

package/build/types-scss/__tests__/js/shared/utils/splitComponent/__assets__/SampleScene/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const container: string;

package/build/types-scss/__tests__/ts/config/publicPath support/__assets__/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const container: string;

package/build/types-scss/__tests__/ts/config/stylename-generation/__assets__/MockPackageA/TestComponent/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const testClassName: string;

package/build/types-scss/__tests__/ts/config/stylename-generation/__assets__/MockPackageB/TestComponent/style.scss.d.ts

@@ -0,0 +1 @@
+export declare const testClassName: string;