@true-engineering/true-react-common-ui-kit 4.0.0-alpha0 → 4.0.0-alpha10

package/src/theme/true-jss/TweakStylesManager.ts

@@ -0,0 +1,157 @@
+import type { StyleSheet, Classes, Rule } from 'jss';
+import {
+  isArrayNotEmpty,
+  isNotEmpty,
+  joinStrings,
+  mergeStyles,
+} from '@true-engineering/true-react-platform-helpers';
+import { isTweakStyle } from '../helpers';
+
+export type IPartialStyle = object;
+
+interface TweakRules<C extends string> {
+  classes: Classes<C>;
+  refs?: number;
+  rules: Map<C, Rule>;
+}
+
+interface TweakStylesManagerOptions<C extends string> {
+  sheet: StyleSheet<C>;
+  classes: Classes<C>;
+  tweak?: IPartialStyle[];
+}
+
+export class TweakStylesManager<C extends string> {
+  #map = new WeakMap<IPartialStyle, TweakStylesManager<C>>();
+  #sheet: StyleSheet<C>;
+  #classes: Classes<C>;
+  #tweak: IPartialStyle[];
+
+  #tweakRules: TweakRules<C> | undefined;
+  constructor({ sheet, classes, tweak = [] }: TweakStylesManagerOptions<C>) {
+    this.#sheet = sheet;
+    this.#classes = classes;
+    this.#tweak = tweak;
+  }
+
+  public getClasses([next, ...rest]: IPartialStyle[]): Classes<C> {
+    const nextManager = this.getNextManager(next);
+    if (isNotEmpty(nextManager)) {
+      return nextManager.getClasses(rest);
+    }
+    return this.getOrCreate()?.classes ?? this.#classes;
+  }
+
+  public manage([next, ...rest]: IPartialStyle[]): void {
+    const nextManager = this.getNextManager(next);
+    if (isNotEmpty(nextManager)) {
+      return nextManager.manage(rest);
+    }
+    if (!isNotEmpty(this.#tweakRules)) {
+      return;
+    }
+    if (this.#tweakRules.refs === 0) {
+      this.insertRules();
+    }
+    this.#tweakRules.refs = (this.#tweakRules.refs ?? 0) + 1;
+  }
+
+  public unmanage([next, ...rest]: IPartialStyle[]): void {
+    const nextManager = this.getNextManager(next);
+    if (isNotEmpty(nextManager)) {
+      return nextManager.unmanage(rest);
+    }
+    if (!isNotEmpty(this.#tweakRules) || this.#tweakRules.refs === 0) {
+      return;
+    }
+    this.#tweakRules.refs = (this.#tweakRules.refs ?? 1) - 1;
+    if (this.#tweakRules.refs === 0) {
+      this.deleteRules();
+    }
+  }
+
+  private getNextManager(next?: IPartialStyle) {
+    if (!isNotEmpty(next)) {
+      return;
+    }
+    if (!this.#map.has(next)) {
+      const manager = new TweakStylesManager({
+        sheet: this.#sheet,
+        classes: this.#classes,
+        tweak: this.#tweak.concat(next),
+      });
+      this.#map.set(next, manager);
+    }
+    return this.#map.get(next);
+  }
+
+  private getOrCreate() {
+    if (!isNotEmpty(this.#tweakRules) && isArrayNotEmpty(this.#tweak)) {
+      const [first, ...rest] = this.#tweak;
+      const styles = isArrayNotEmpty(rest) ? mergeStyles(first, ...rest) : first;
+
+      const rules = this.addRules(styles);
+
+      const classes = { ...this.#classes };
+      rules.forEach((rule, key) => {
+        classes[key] = joinStrings([classes[key], rule.id], ' ');
+      });
+
+      this.#tweakRules = { classes, rules };
+    }
+    return this.#tweakRules;
+  }
+
+  private addRules(styles: IPartialStyle) {
+    return new Map(
+      Object.entries(styles)
+        .map(([key, style]) => this.addRule(key as C, style))
+        .filter(isNotEmpty),
+    );
+  }
+
+  private addRule(key: C, style: object) {
+    if (isTweakStyle(key)) {
+      return;
+    }
+    const rule = this.#sheet.addRule(key, style, { index: this.getInsertIndex(key) });
+    return isNotEmpty(rule) ? ([key, rule] as const) : undefined;
+  }
+
+  private insertRules() {
+    this.#tweakRules?.rules.forEach((rule, key) => {
+      this.#sheet.rules.register(rule);
+      this.#sheet.rules.index.splice(this.getInsertIndex(key), 0, rule);
+      this.#sheet.insertRule(rule);
+    });
+  }
+
+  private deleteRules() {
+    this.#tweakRules?.rules.forEach((rule) => this.#sheet.deleteRule(rule));
+  }
+
+  private getInsertIndex(key: C) {
+    return (
+      this.#sheet.rules.index.findIndex((rule) => rule.key === key) + 1 ||
+      this.#sheet.rules.index.length
+    );
+  }
+}
+
+declare module 'jss' {
+  export interface RuleList {
+    index: Rule[];
+  }
+  // eslint-disable-next-line no-shadow
+  export interface StyleSheet<RuleName> {
+    rules: RuleList;
+    // eslint-disable-next-line @typescript-eslint/method-signature-style
+    deleteRule(rule: Rule): boolean;
+    // eslint-disable-next-line @typescript-eslint/method-signature-style
+    addRule(
+      name: RuleName,
+      style: JssStyle,
+      options?: Partial<Rule['options']>,
+    ): (Rule & { id: string }) | null;
+  }
+}

package/src/theme/true-jss/index.ts

@@ -0,0 +1,2 @@
+export * from './ThemedStylesManager';
+export * from './jss-context';

package/src/theme/true-jss/jss-context.tsx

@@ -0,0 +1,34 @@
+import { Context, FC, PropsWithChildren, useContext, useMemo } from 'react';
+import { JssContext as JssContextLib } from 'react-jss';
+import { GenerateId } from 'jss';
+
+export interface IJssContext {
+  generateId?: GenerateId;
+  tweakStylesArch?: 'react-jss' | 'true-jss';
+}
+
+/** Типизация JssContext оказалась некорректна */
+export const JssContext = JssContextLib as unknown as Context<IJssContext>;
+
+export const JssProvider: FC<PropsWithChildren<IJssContext>> = ({
+  children,
+  tweakStylesArch,
+  generateId,
+}) => {
+  const context = useContext(JssContext);
+
+  const value: IJssContext = useMemo(
+    () => ({
+      ...context,
+      tweakStylesArch: tweakStylesArch ?? context.tweakStylesArch,
+      generateId: generateId ?? context.generateId,
+    }),
+    [context, tweakStylesArch, generateId],
+  );
+
+  return (
+    <JssContext.Provider key={tweakStylesArch} value={value}>
+      {children}
+    </JssContext.Provider>
+  );
+};

package/src/theme/types.ts

@@ -8,7 +8,7 @@ import type {
   ICloseButtonStyles,
   ICommonIcon,
   IComplexIcon,
-  IControlGroupStyles,
+  IWithMessagesStyles,
   IControlWrapperStyles,
   ICssBaselineStyles,
   IDateInputStyles,
@@ -67,10 +67,12 @@ import type {
   IWithTooltipStyles,
 } from '../components';
 
-export type IStyles<C extends string, P> = Styles<C, P, Partial<Styles<C, P>>>;
+export type IStyles<C extends string, P = unknown> = Styles<C, P, Partial<Styles<C, P>>>;
 
+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?: Partial<Styles<C, P>> },
+  data?: P & { theme?: IMaybeArray<Partial<Styles<C, P>>> },
 ) => Classes<C>;
 
 export type ITweakStyles<
@@ -138,7 +140,7 @@ export interface IComponentStyles {
   Toaster: IToasterStyles;
   WithPopup: IWithPopupStyles;
   NewMoreMenu: INewMoreMenuStyles;
-  ControlGroup: IControlGroupStyles;
+  WithMessages: IWithMessagesStyles;
   ControlWrapper: IControlWrapperStyles;
   WithTooltip: IWithTooltipStyles;
 }

package/src/types.ts

@@ -8,6 +8,7 @@ import {
   ReactNode,
 } from 'react';
 import { Modifier, Placement } from 'react-overlays/usePopper';
+import type { IMaybeArray } from './theme';
 
 export interface ITestIdProps {
   testId?: string;
@@ -22,7 +23,7 @@ export interface IDataAttributesProps extends ITestIdProps {
 }
 
 export interface ITweakStylesProps<TweakStyles> {
-  tweakStyles?: TweakStyles;
+  tweakStyles?: IMaybeArray<TweakStyles>;
 }
 
 export type ICommonProps<TweakStyles> = IDataAttributesProps & ITweakStylesProps<TweakStyles>;

package/dist/components/ControlGroup/ControlGroup.d.ts

@@ -1,10 +0,0 @@
-import { ReactNode } from 'react';
-import { ICommonProps } from '../../types';
-import { IControlGroupStyles } from './ControlGroup.styles';
-export interface IControlGroupProps extends ICommonProps<IControlGroupStyles> {
-    children: ReactNode;
-    infoMessage?: ReactNode;
-    errorMessage?: ReactNode;
-    direction?: 'horizontal' | 'vertical';
-}
-export declare const ControlGroup: import("react").ForwardRefExoticComponent<IControlGroupProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/ControlGroup/ControlGroup.styles.d.ts

@@ -1,3 +0,0 @@
-import { ITweakStyles } from '../../theme';
-export declare const useStyles: import("../../theme").IUseStyles<"error" | "root" | "horizontal" | "vertical" | "children" | "info" | "message", unknown>;
-export type IControlGroupStyles = ITweakStyles<typeof useStyles>;

package/dist/components/ControlGroup/index.d.ts

@@ -1,2 +0,0 @@
-export * from './ControlGroup';
-export type { IControlGroupStyles } from './ControlGroup.styles';

package/src/components/ControlGroup/index.ts

@@ -1,2 +0,0 @@
-export * from './ControlGroup';
-export type { IControlGroupStyles } from './ControlGroup.styles';