@true-engineering/true-react-common-ui-kit 4.0.0-alpha54 → 4.0.0-alpha61

package/src/components/WithMessages/WithMessages.tsx

@@ -15,45 +15,46 @@ export interface IWithMessagesProps extends ICommonProps<IWithMessagesStyles> {
   controlsDirection?: 'horizontal' | 'vertical';
 }
 
-export const WithMessages = forwardRef<HTMLDivElement, IWithMessagesProps>(
-  ({ children, infoMessage, errorMessage, controlsDirection, tweakStyles, testId, data }, ref) => {
-    const classes = useStyles({ theme: tweakStyles });
+export const WithMessages = forwardRef<HTMLDivElement, IWithMessagesProps>(function WithMessages(
+  { children, infoMessage, errorMessage, controlsDirection, tweakStyles, testId, data },
+  ref,
+) {
+  const classes = useStyles({ theme: tweakStyles });
 
-    const shouldShowError = isReactNodeNotEmpty(errorMessage);
-    const shouldShowInfo = isReactNodeNotEmpty(infoMessage) && !shouldShowError;
+  const shouldShowError = isReactNodeNotEmpty(errorMessage);
+  const shouldShowInfo = isReactNodeNotEmpty(infoMessage) && !shouldShowError;
 
-    return (
-      <div
-        ref={ref}
-        className={classes.withMessages}
-        data-invalid={shouldShowError ? true : undefined}
-        {...addDataAttributes(data, testId)}
-      >
-        {isReactNodeNotEmpty(children) && (
-          <div
-            className={clsx(classes.children, {
-              [classes.horizontal]: controlsDirection === 'horizontal',
-              [classes.vertical]: controlsDirection === 'vertical',
-            })}
-          >
-            {children}
-          </div>
-        )}
-        {(shouldShowError || shouldShowInfo) && (
-          <div className={classes.message}>
-            {shouldShowError && (
-              <div className={classes.error} {...addDataTestId(testId, 'error')}>
-                {errorMessage}
-              </div>
-            )}
-            {shouldShowInfo && (
-              <div className={classes.info} {...addDataTestId(testId, 'info')}>
-                {infoMessage}
-              </div>
-            )}
-          </div>
-        )}
-      </div>
-    );
-  },
-);
+  return (
+    <div
+      ref={ref}
+      className={classes.withMessages}
+      data-invalid={shouldShowError ? true : undefined}
+      {...addDataAttributes(data, testId)}
+    >
+      {isReactNodeNotEmpty(children) && (
+        <div
+          className={clsx(classes.children, {
+            [classes.horizontal]: controlsDirection === 'horizontal',
+            [classes.vertical]: controlsDirection === 'vertical',
+          })}
+        >
+          {children}
+        </div>
+      )}
+      {(shouldShowError || shouldShowInfo) && (
+        <div className={classes.message}>
+          {shouldShowError && (
+            <div className={classes.error} {...addDataTestId(testId, 'error')}>
+              {errorMessage}
+            </div>
+          )}
+          {shouldShowInfo && (
+            <div className={classes.info} {...addDataTestId(testId, 'info')}>
+              {infoMessage}
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+});

package/src/components/WithTooltip/WithTooltip.tsx

@@ -22,6 +22,8 @@ export interface IWithTooltipProps
   tooltipView?: ITooltipProps['view'];
   /** @default 'info' */
   tooltipType?: ITooltipProps['type'];
+  /** @default 'undefined' */
+  tooltipSize?: ITooltipProps['size'];
 }
 
 export const WithTooltip: FC<IWithTooltipProps> = ({
@@ -31,6 +33,7 @@ export const WithTooltip: FC<IWithTooltipProps> = ({
   tooltipText,
   tooltipView = 'tooltip',
   tooltipType = 'info',
+  tooltipSize,
   isDisabled = false,
   popupData,
   tweakStyles,
@@ -64,6 +67,7 @@ export const WithTooltip: FC<IWithTooltipProps> = ({
         view={tooltipView}
         type={tooltipType}
         text={tooltipText}
+        size={tooltipSize}
         tweakStyles={tweakTooltipStyles}
         testId={getTestId(restProps.testId, 'tooltip')}
       />

package/src/helpers/misc.ts

@@ -1,3 +1,4 @@
+import { ComponentType, memo } from 'react';
 import {
   isNotEmpty,
   isString,
@@ -160,3 +161,8 @@ export const addDataAttributes = (data: IDataAttributes = {}): IDataAttributes =
 
 export const excludeStorybookParams = (params: string[]): RegExp =>
   new RegExp(`^(on.*|${['tweakStyles', 'data', ...params].join('|')})$`);
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const genericMemo = memo as <T extends ComponentType<any>>(
+  ...args: Parameters<typeof memo<T>>
+) => T;

package/src/hooks/index.ts

@@ -1,6 +1,7 @@
 export * from './use-did-mount-effect';
 export * from './use-dropdown';
 export * from './use-intersection-ref';
+export * from './use-resize-ref';
 export * from './use-is-mounted';
 export * from './use-latest-ref';
 export * from './use-merge';

package/src/hooks/use-intersection-ref.ts

@@ -1,4 +1,4 @@
-import { RefCallback, useMemo } from 'react';
+import { RefCallback, useEffect, useMemo } from 'react';
 import { isNotEmpty } from '@true-engineering/true-react-platform-helpers';
 import { useLatestRef } from './use-latest-ref';
 
@@ -7,12 +7,16 @@ export interface IInsertionRefOptions {
   isDisabled?: boolean;
   onIntersection?: VoidFunction;
   onIntersectionEnd?: VoidFunction;
+  observerOptions?: IntersectionObserverInit;
 }
 
-export const useIntersectionRef = (options?: IInsertionRefOptions): RefCallback<Element> => {
+export const useIntersectionRef = ({
+  observerOptions,
+  ...options
+}: IInsertionRefOptions): RefCallback<Element> => {
   const optionsRef = useLatestRef(options);
 
-  return useMemo(() => {
+  const { ref, disconnect } = useMemo(() => {
     const observer = new IntersectionObserver(([{ isIntersecting }]) => {
       const { current } = optionsRef;
       if (current?.isDisabled) {
@@ -23,8 +27,22 @@ export const useIntersectionRef = (options?: IInsertionRefOptions): RefCallback<
       } else {
         current?.onIntersectionEnd?.();
       }
-    });
+    }, observerOptions);
 
-    return (node) => (isNotEmpty(node) ? observer.observe(node) : observer.disconnect());
-  }, [optionsRef]);
+    const observerRef: RefCallback<Element> = (node) => {
+      observer.disconnect();
+      if (isNotEmpty(node)) {
+        observer.observe(node);
+      }
+    };
+
+    return {
+      ref: observerRef,
+      disconnect: () => observer.disconnect(),
+    };
+  }, [optionsRef, observerOptions]);
+
+  useEffect(() => disconnect, [disconnect]);
+
+  return ref;
 };

package/src/hooks/use-latest-ref.ts

@@ -1,7 +1,11 @@
-import { MutableRefObject, useRef } from 'react';
+import { MutableRefObject, useLayoutEffect, useRef } from 'react';
 
 export const useLatestRef = <T>(value: T): MutableRefObject<T> => {
   const ref = useRef(value);
-  ref.current = value;
+
+  useLayoutEffect(() => {
+    ref.current = value;
+  });
+
   return ref;
 };

package/src/hooks/use-resize-ref.ts

@@ -0,0 +1,35 @@
+import { RefCallback, useMemo, useEffect } from 'react';
+import { isNotEmpty } from '@true-engineering/true-react-platform-helpers';
+import { useLatestRef } from './use-latest-ref';
+
+export interface IResizeRefOptions {
+  /** @default false */
+  isDisabled?: boolean;
+  onChange: (entry: ResizeObserverEntry) => void;
+}
+
+export const useResizeRef = (options: IResizeRefOptions): RefCallback<Element> => {
+  const optionsRef = useLatestRef(options);
+
+  const { ref, disconnect } = useMemo(() => {
+    const observer = new ResizeObserver(([entry]) => {
+      const { current } = optionsRef;
+      if (!current.isDisabled) {
+        current?.onChange(entry);
+      }
+    });
+
+    const observerRef: RefCallback<Element> = (node) => {
+      observer.disconnect();
+      if (isNotEmpty(node)) {
+        observer.observe(node);
+      }
+    };
+
+    return { ref: observerRef, disconnect: () => observer.disconnect() };
+  }, [optionsRef]);
+
+  useEffect(() => disconnect, [disconnect]);
+
+  return ref;
+};

package/src/hooks/use-tweak-styles.ts

@@ -1,18 +1,6 @@
-import { useContext, useMemo } from 'react';
-import {
-  isArrayNotEmpty,
-  isNotEmpty,
-  mergeStyles,
-} from '@true-engineering/true-react-platform-helpers';
-import {
-  areStylesThemed,
-  themedStyles,
-  IComponentName,
-  IMaybeArray,
-  useTheme,
-  JssContext,
-  IMixedStyles,
-} from '../theme';
+import { useMemo } from 'react';
+import { IMaybeArray } from '@true-engineering/true-react-platform-helpers';
+import { IComponentName, IMixedStyles, useThemeComponentStyles } from '../theme';
 import { mixStyles } from './use-mixed-styles';
 
 // TODO: Можно усилить типы
@@ -37,43 +25,18 @@ export const useTweakStyles = <StyleSheet, ClassName extends keyof StyleSheet &
    */
   className: ClassName;
   /**
-   * Название компонента который вызывает useTweakStyles. (В данном примере 'Select')
+   * Название компонента который вызывает useTweakStyles
    */
   currentComponentName?: IComponentName;
 }): Array<NonNullable<StyleSheet[ClassName]>> => {
-  const theme = useTheme();
-  const isMergeDisabled = isNotEmpty(useContext(JssContext).tweakStylesArch);
-
-  return useMemo(() => {
-    const themeStyles = isNotEmpty(currentComponentName)
-      ? (theme.components?.[currentComponentName] as StyleSheet)
-      : undefined;
-
-    const resultStyles = mixStyles(
-      innerStyles,
-      mixStyles(themeStyles, tweakStyles).map((style) => style[className]),
-    );
-
-    if (isMergeDisabled || resultStyles.length < 2) {
-      return resultStyles;
-    }
-
-    const [maybeInnerStyles, maybeThemeStyles, ...rest] = resultStyles;
-
-    if (
-      maybeThemeStyles !== themeStyles?.[className] || // Если нет themeStyles или innerStyles
-      isArrayNotEmpty(rest) // Или есть tweakStyles
-    ) {
-      // Мёржим как есть
-      return [mergeStyles(maybeInnerStyles, maybeThemeStyles, ...rest)];
-    }
-
-    // Иначе мёржим themeStyles в innerStyles
-    if (!areStylesThemed(maybeInnerStyles)) {
-      themedStyles(maybeInnerStyles, maybeThemeStyles);
-    }
-
-    // И возвращаем только innerStyles
-    return [maybeInnerStyles];
-  }, [innerStyles, className, currentComponentName, tweakStyles, theme, isMergeDisabled]);
+  const themeStyles = useThemeComponentStyles<StyleSheet>(currentComponentName);
+
+  return useMemo(
+    () =>
+      mixStyles(
+        innerStyles,
+        mixStyles(themeStyles, tweakStyles).map((style) => style[className]),
+      ),
+    [innerStyles, className, themeStyles, tweakStyles],
+  );
 };

package/src/theme/Provider.tsx

@@ -1,26 +1,9 @@
-import { createContext, FC, ReactNode, useContext, useMemo } from 'react';
+import { createContext, useContext } from 'react';
 import { common } from './common';
 import type { IUiKitTheme } from './types';
 
-export interface IThemedProviderProps {
-  theme: IUiKitTheme;
-  children: ReactNode;
-}
+export const ThemeContext = createContext<IUiKitTheme>(common);
 
-let globalTheme: IUiKitTheme;
+export const ThemeProvider = ThemeContext.Provider;
 
-export const getTheme = (): IUiKitTheme => globalTheme;
-
-interface ThemeContextValue {
-  theme: IUiKitTheme;
-}
-
-export const ThemeContext = createContext<ThemeContextValue>({ theme: common });
-
-export const ThemeProvider: FC<IThemedProviderProps> = ({ theme, children }) => {
-  globalTheme = theme;
-  const value: ThemeContextValue = useMemo(() => ({ theme }), [theme]);
-  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
-};
-
-export const useTheme = (): IUiKitTheme => useContext(ThemeContext).theme;
+export const useTheme = (): IUiKitTheme => useContext(ThemeContext);

package/src/theme/common.ts

@@ -1,4 +1,3 @@
-import { Styles } from 'react-jss';
 import { IUiKitHelpers, IUiKitTheme } from './types';
 
 export const colors = {
@@ -49,41 +48,40 @@ export const dimensions = {
 } as const;
 
 export const helpers = {
-  withAngle: (angleSize = 6, position: 'left' | 'right' = 'left', distance = 100): Styles =>
-    ({
-      display: 'inline-block',
-      position: 'relative',
-      marginTop: angleSize * 2 - 1,
-      boxShadow: '0 8px 20px 0 rgba(0, 0, 0, 0.04)',
-      border: ['solid', 1, colors.BORDER_MAIN],
-      borderRadius: dimensions.BORDER_RADIUS_EXTRA_SMALL,
-
-      '&:before': {
-        content: '""',
-        position: 'absolute',
-        top: -angleSize,
-        left: position === 'left' && distance,
-        right: position === 'right' && distance,
-        width: 0,
-        height: 0,
-        borderLeft: [angleSize, 'solid', 'transparent'],
-        borderRight: [angleSize, 'solid', 'transparent'],
-        borderBottom: [angleSize, 'solid', colors.BORDER_MAIN],
-      },
+  withAngle: (angleSize = 6, position: 'left' | 'right' = 'left', distance = 100) => ({
+    display: 'inline-block',
+    position: 'relative',
+    marginTop: angleSize * 2 - 1,
+    boxShadow: '0 8px 20px 0 rgba(0, 0, 0, 0.04)',
+    border: ['solid', 1, colors.BORDER_MAIN],
+    borderRadius: dimensions.BORDER_RADIUS_EXTRA_SMALL,
+
+    '&:before': {
+      content: '""',
+      position: 'absolute',
+      top: -angleSize,
+      left: position === 'left' && distance,
+      right: position === 'right' && distance,
+      width: 0,
+      height: 0,
+      borderLeft: [angleSize, 'solid', 'transparent'],
+      borderRight: [angleSize, 'solid', 'transparent'],
+      borderBottom: [angleSize, 'solid', colors.BORDER_MAIN],
+    },
 
-      '&:after': {
-        content: '""',
-        position: 'absolute',
-        top: -angleSize + 1,
-        left: position === 'left' && distance + 1,
-        right: position === 'right' && distance + 1,
-        width: 0,
-        height: 0,
-        borderLeft: [angleSize - 1, 'solid', 'transparent'],
-        borderRight: [angleSize - 1, 'solid', 'transparent'],
-        borderBottom: [angleSize - 1, 'solid', colors.CLASSIC_WHITE],
-      },
-    } as unknown as Styles),
+    '&:after': {
+      content: '""',
+      position: 'absolute',
+      top: -angleSize + 1,
+      left: position === 'left' && distance + 1,
+      right: position === 'right' && distance + 1,
+      width: 0,
+      height: 0,
+      borderLeft: [angleSize - 1, 'solid', 'transparent'],
+      borderRight: [angleSize - 1, 'solid', 'transparent'],
+      borderBottom: [angleSize - 1, 'solid', colors.CLASSIC_WHITE],
+    },
+  }),
 
   withScrollBar: {
     boxSizing: 'border-box',
@@ -135,7 +133,6 @@ const SLIDE_UP_POSITION_END = 0;
 
 export const animations = {
   defaultTransition: '0.25s ease-in-out',
-  // Если понадобится, сюда можно пробросить параметры через useTheme props
   slideUp: {
     'slide-up-enter': {
       opacity: 0,

package/src/theme/helpers.ts

@@ -1,30 +1,28 @@
-import { merge } from 'lodash-es';
+import { useMemo } from 'react';
+import { createUseStyles } from 'react-jss';
 import {
   isArrayNotEmpty,
   isNotEmpty,
+  isString,
   mergeStyles,
 } from '@true-engineering/true-react-platform-helpers';
-import { IMaybeArray } from './types';
+import { mixStyles } from '../hooks/use-mixed-styles';
+import { useTheme } from './Provider';
+import { IComponentName, IStyles, IUseStyles } from './types';
 
-const EMPTY_STYLES = {};
+export const useThemeComponentStyles = <T>(
+  componentName?: IComponentName,
+): Partial<T> | undefined => {
+  const { components } = useTheme();
+  return isNotEmpty(componentName) ? (components?.[componentName] as never) : undefined;
+};
 
-export const isTweakStyle = (key: string): boolean => key.startsWith('tweak');
+const isTweakStyle = (key: string): boolean => key.startsWith('tweak');
 
-export const isStylesNotEmpty = <T>(tweakStyles?: T): tweakStyles is NonNullable<T> =>
+const areStylesNotEmpty = <T>(tweakStyles?: T): tweakStyles is NonNullable<T> =>
   isNotEmpty(tweakStyles) && !Object.keys(tweakStyles).every(isTweakStyle);
 
-export const cleanStyles = <T>(tweakStyles?: T): T =>
-  isStylesNotEmpty(tweakStyles) ? tweakStyles : (EMPTY_STYLES as T);
-
-export const mergeTweakStyles = <T>(tweakStyles?: IMaybeArray<T>): T | undefined => {
-  if (!Array.isArray(tweakStyles)) {
-    return tweakStyles;
-  }
-  const [first, ...rest] = tweakStyles;
-  return isArrayNotEmpty(rest) ? mergeStyles(first, ...rest) : first;
-};
-
-export const checkStyles = (componentName: string, styles: Record<string, unknown>): void => {
+const checkStyles = (styles: IStyles<string>, componentName = 'LocalComponent'): void => {
   const invalidClasses = Object.keys(styles).filter(isTweakStyle);
 
   if (isArrayNotEmpty(invalidClasses)) {
@@ -34,23 +32,8 @@ export const checkStyles = (componentName: string, styles: Record<string, unknow
   }
 };
 
-export const areStylesThemed = (styles: Record<string, unknown>): boolean =>
-  // eslint-disable-next-line no-underscore-dangle
-  styles.__themed === true;
-
-/**
- * Подмешивает стили из темы. Мутирует, добавляя специально поле,
- * по которому можно определить была ли уже произведена мутация ранее,
- * тем самым сохраняя ссылку на объект и позволяя этим кэшировать JSS стили
- */
-export const themedStyles = <T>(styles: T, themeComponentStyles: T): T => {
-  merge(styles, themeComponentStyles); // mutation !!!!
-  Object.defineProperty(styles, '__themed', { value: true });
-  return styles;
-};
-
-type TweakStylesCache = (styles: object[], prev?: object[]) => object | undefined;
-export const getTweakStylesCache = (): TweakStylesCache => {
+type TweakStylesCache = (styles: object[], idx?: number) => object | undefined;
+const getTweakStylesCache = (): TweakStylesCache => {
   let mergedStyles: object | undefined;
   const cache = new WeakMap<object, TweakStylesCache>();
 
@@ -59,20 +42,45 @@ export const getTweakStylesCache = (): TweakStylesCache => {
       cache.set(next, getTweakStylesCache());
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return cache.get(next)!;
+    return cache.get(next)!; // eslint-disable-line @typescript-eslint/no-non-null-assertion
   };
 
-  return (styles, prev = []) => {
-    const [next, ...rest] = styles;
+  return (styles, idx = 0) => {
+    const next = styles.at(idx);
     if (isNotEmpty(next)) {
-      return getNext(next)(rest, prev.concat(next));
+      return getNext(next)(styles, idx + 1);
     }
 
-    if (isNotEmpty(mergedStyles)) {
-      return mergedStyles;
+    if (!isNotEmpty(mergedStyles)) {
+      const [first, ...rest] = styles;
+      mergedStyles = isArrayNotEmpty(rest) ? mergeStyles(first, ...rest) : first;
     }
 
-    return (mergedStyles = mergeTweakStyles(prev));
+    return mergedStyles;
+  };
+};
+
+const tweakStylesCache = getTweakStylesCache();
+const useStyles = createUseStyles<string>((tweakStyles) => tweakStyles as never);
+
+export const createThemedStyles: <C extends string>(
+  ...args: [IStyles<C>] | [IComponentName, IStyles<C>]
+) => IUseStyles<C> = (first, second?) => {
+  const componentName = isString(first) ? first : undefined;
+  const styles = second! ?? first; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+
+  if (process.env.NODE_ENV !== 'production') {
+    checkStyles(styles, componentName);
+  }
+
+  return ({ theme, tweakStyles = theme }) => {
+    const themeStyles = useThemeComponentStyles<typeof styles>(componentName);
+
+    const data = useMemo(() => {
+      const resultStyles = mixStyles(styles, themeStyles, tweakStyles).filter(areStylesNotEmpty);
+      return { theme: tweakStylesCache(resultStyles) };
+    }, [themeStyles, tweakStyles]);
+
+    return useStyles(data);
   };
 };

package/src/theme/index.ts

@@ -1,6 +1,4 @@
 export * from './Provider';
-export * from './true-jss';
 export * from './common';
 export * from './types';
 export * from './helpers';
-export * from './create-themed-styles';

package/src/theme/types.ts

@@ -1,5 +1,5 @@
-import { Styles } from 'react-jss';
-import { Classes, JssValue } from 'jss';
+import type { Classes, JssStyle, JssValue, Styles } from 'jss';
+import type { IMaybeArray } from '@true-engineering/true-react-platform-helpers';
 import type {
   IAccountInfoStyles,
   IAddButtonStyles,
@@ -67,19 +67,22 @@ import type {
   IWithTooltipStyles,
 } from '../components';
 
-export type IStyles<C extends string, P = unknown> = Styles<C, P, Partial<Styles<C, P>>>;
+export type IStyles<C extends string> = Styles<C>;
+
+export type IStyle = JssStyle;
 
-export type IMaybeArray<T> = T[] | T;
 export type IMixedStyles<T> = IMaybeArray<T | boolean | undefined>;
-export type IUseStyles<C extends string, P = unknown> = (
-  data?: P & { theme?: IMaybeArray<Partial<Styles<C, P>>> },
-) => Classes<C>;
+
+export type IUseStyles<C extends string> = (data: {
+  theme?: IMaybeArray<Partial<IStyles<C>>>;
+  tweakStyles?: IMaybeArray<Partial<IStyles<C>>>;
+}) => Classes<C>;
 
 export type ITweakStyles<
   StyleCreator,
   ChildTweakStyles = unknown,
-> = StyleCreator extends IUseStyles<infer C, infer P>
-  ? Partial<Styles<C, P>> & Partial<ChildTweakStyles>
+> = StyleCreator extends IUseStyles<infer C>
+  ? Partial<IStyles<C>> & Partial<ChildTweakStyles>
   : never;
 
 export interface IComponentStyles {
@@ -149,7 +152,7 @@ export interface IComponentStyles {
 export type IComponentName = keyof IComponentStyles;
 
 export type IUiKitAnimations = Record<string, any>;
-export type IUiKitHelpers = Record<string, Styles | (() => Styles)>;
+export type IUiKitHelpers = Record<string, IStyle | (() => IStyle)>;
 
 export interface IUiKitTheme {
   components?: Partial<IComponentStyles>;

package/src/types.ts

@@ -8,8 +8,8 @@ import type {
   ReactNode,
 } from 'react';
 import type { Modifier, Placement } from 'react-overlays/usePopper';
-import type { JssStyle } from 'jss';
-import type { IMaybeArray } from './theme';
+import type { IMaybeArray } from '@true-engineering/true-react-platform-helpers';
+import { IStyle } from './theme';
 
 export interface ITestIdProps {
   testId?: string;
@@ -66,7 +66,7 @@ export type IRenderNode<T> = ReactNode | ((props: T) => ReactNode);
 
 export type IExtendableProps<T extends string | readonly string[]> = Record<
   T extends ReadonlyArray<infer P> ? P : T,
-  JssStyle
+  IStyle
 >;
 
 export type IDefaultExtendableProps = IExtendableProps<'custom'>;

package/dist/theme/create-themed-styles.d.ts

@@ -1,2 +0,0 @@
-import { IComponentName, IStyles, IUseStyles } from './types';
-export declare function createThemedStyles<C extends string>(...args: [IStyles<C>] | [IComponentName, IStyles<C>]): IUseStyles<C>;

package/dist/theme/true-jss/ThemedStylesManager.d.ts

@@ -1,18 +0,0 @@
-import { Classes } from 'jss';
-import { IStyles } from '../types';
-import { IPartialStyle } from './TweakStylesManager';
-import { IJssContext } from './jss-context';
-interface IThemedStylesManagerOptions<C extends string> {
-    styles: IStyles<C>;
-    name: string;
-}
-export declare class ThemedStylesManager<C extends string> {
-    #private;
-    constructor({ styles, name }: IThemedStylesManagerOptions<C>);
-    getClasses(theme: object | undefined, tweak: IPartialStyle[], jssContext: IJssContext): Classes<C>;
-    manageTweak(theme: object | undefined, tweak: IPartialStyle[]): VoidFunction | undefined;
-    manage(theme?: object): VoidFunction | undefined;
-    private unmanage;
-    private getOrCreate;
-}
-export {};