@basic-ui/material 1.0.0-alpha.14 → 1.0.0-alpha.17

package/src/ThemeExplorer/ThemeBuilder.tsx

@@ -1,5 +1,5 @@
 import type { ComponentType } from 'react';
-import { useState, useMemo, useDeferredValue, useEffect } from 'react';
+import { useState, useMemo, useEffect } from 'react';
 import {
   CorePalette,
   argbFromHex,
@@ -8,21 +8,25 @@ import {
 import type { Color } from '@basic-ui/color-picker';
 import { toColor } from '@basic-ui/color-picker';
 import {
-  THEME_OVERRIDE_KEY,
+  THEME_OVERRIDE_STORAGE_KEY,
   injectThemeOverride,
   transformTheme,
+  loadGoogleFont,
 } from '@basic-ui/dynamic-theme';
+import { rem } from 'polished';
+import remToPx from 'polished/lib/helpers/remToPx';
 
 import { Box } from '../Box';
 import { TonalColors } from './components';
-import { TextFieldColorPicker } from './TextFieldColorPicker';
 import { ThemeColors } from './ThemeColors';
 import { makeColorScheme } from './makeColorScheme';
-import { theme } from '../theme';
 import { Text } from '../Text';
-import { Button } from '../Button';
 import { useLocalStorageCachedState } from './useLocalStorageCachedState';
 import { useDeferredColor } from './useDeferredColor';
+import { FontAutoComplete, parseMainFont } from './FontAutoComplete';
+import type { Theme } from '../theme/theme';
+import { BorderSlider } from './BorderSlider';
+import { ColorSchemePicker } from './ColorSchemePicker';
 
 export interface ThemeBuilderProps {
   CodeHighlightingComponent?: ComponentType<{
@@ -30,6 +34,7 @@ export interface ThemeBuilderProps {
     className: string;
     showButtons?: boolean;
   }>;
+  baseTheme: Theme;
 }
 
 function DefaultHighlighter(props: { children: string }) {
@@ -50,16 +55,52 @@ export const ThemeBuilder = (props: ThemeBuilderProps) => {
 };
 
 const ThemeBuilderImpl = (props: ThemeBuilderProps) => {
-  const { CodeHighlightingComponent = DefaultHighlighter } = props;
+  const { baseTheme: theme, CodeHighlightingComponent = DefaultHighlighter } =
+    props;
+  const [plainFont, setPlainFont] = useLocalStorageCachedState(
+    parseMainFont(theme.fonts.plain),
+    'fontFamily.plain'
+  );
+  const [brandFont, setBrandFont] = useLocalStorageCachedState(
+    parseMainFont(theme.fonts.brand),
+    'fontFamily.brand'
+  );
+
+  const [radiusExtraSmall, setRadiusExtraSmall] =
+    useLocalStorageCachedState<number>(
+      parseInt(remToPx(theme.radii['extra-small'])),
+      'radii.extra-small'
+    );
+
+  const [radiusSmall, setRadiusSmall] = useLocalStorageCachedState<number>(
+    parseInt(remToPx(theme.radii['small'])),
+    'radii.small'
+  );
+
+  const [radiusMedium, setRadiusMedium] = useLocalStorageCachedState<number>(
+    parseInt(remToPx(theme.radii['medium'])),
+    'radii.medium'
+  );
+
+  const [radiusLarge, setRadiusLarge] = useLocalStorageCachedState<number>(
+    parseInt(remToPx(theme.radii['large'])),
+    'radii.large'
+  );
+
+  const [radiusExtraLarge, setRadiusExtraLarge] =
+    useLocalStorageCachedState<number>(
+      parseInt(remToPx(theme.radii['extra-large'])),
+      'radii.extra-large'
+    );
+
   const [primaryColor, setPrimaryColor] = useLocalStorageCachedState<Color>(
     toColor('hex', theme.colors.primary),
     'primary'
   );
-  const deferredPrimaryColor = useDeferredValue(primaryColor);
 
   const { a1, a2, a3, error, n1, n2 } = useMemo(
-    () => CorePalette.of(argbFromHex(deferredPrimaryColor.hex)),
-    [deferredPrimaryColor.hex]
+    () => CorePalette.of(argbFromHex(primaryColor.hex)),
+    [primaryColor.hex]
   );
 
   const [secondaryColor, secondaryColorTonal, setSecondaryColor] =
@@ -84,104 +125,200 @@ const ThemeBuilderImpl = (props: ThemeBuilderProps) => {
     [a1, secondaryColorTonal, tertiaryColorTonal, error, neutralColorTonal, n2]
   );
 
+  const newTheme = useMemo(
+    () => ({
+      colors: scheme,
+      fonts: { plain: `"${plainFont}"`, brand: `"${brandFont}"` },
+      radii: {
+        'extra-small': rem(radiusExtraSmall),
+        'extra-small_top': `${rem(radiusExtraSmall)} ${rem(
+          radiusExtraSmall
+        )} 0 0`,
+        small: rem(radiusSmall),
+        medium: rem(radiusMedium),
+        large: rem(radiusLarge),
+        large_end: `0 ${rem(radiusLarge)} ${rem(radiusLarge)} 0`,
+        large_top: `${rem(radiusLarge)} ${rem(radiusLarge)} 0 0`,
+        'extra-large': rem(radiusExtraLarge),
+        'extra-large_top': `${rem(radiusExtraLarge)} ${rem(
+          radiusExtraLarge
+        )} 0 0`,
+      },
+    }),
+    [
+      scheme,
+      plainFont,
+      brandFont,
+      radiusExtraSmall,
+      radiusSmall,
+      radiusMedium,
+      radiusLarge,
+      radiusExtraLarge,
+    ]
+  );
+
   const colorModes = useMemo(
-    () => transformTheme({ colors: scheme }, []).colorModes,
-    [scheme]
+    () => transformTheme(newTheme, ['fonts', 'radii']).colorModes,
+    [newTheme]
   );
+
   useEffect(() => {
-    localStorage.setItem(THEME_OVERRIDE_KEY, JSON.stringify({ colorModes }));
+    localStorage.setItem(
+      THEME_OVERRIDE_STORAGE_KEY,
+      JSON.stringify({ colorModes })
+    );
     injectThemeOverride({ colorModes });
   }, [colorModes]);
 
   return (
     <>
+      {/* Shape */}
+      <Text variant="headline-small">Shape</Text>
       <Box display="flex" my={3} sx={{ gap: 3, flexWrap: 'wrap' }}>
-        <Box display="flex" minWidth="300px" flex="1">
-          <TextFieldColorPicker
-            label="Primary color"
-            value={primaryColor}
-            onChange={(c) => setPrimaryColor(c)}
-          />
-          <Button
-            variant="text"
-            disabled={
-              primaryColor.hex === toColor('hex', theme.colors.primary).hex
-            }
-            onClick={() =>
-              setPrimaryColor(toColor('hex', theme.colors.primary))
-            }
-          >
-            Reset
-          </Button>
-        </Box>
-        <Box display="flex" minWidth="300px" flex="1">
-          <TextFieldColorPicker
-            label="Secondary color"
-            value={
-              secondaryColor ||
-              toColor('hex', hexFromArgb(secondaryColorTonal.tone(40)))
-            }
-            onChange={(c) => setSecondaryColor(c)}
-          />
-          <Button
-            variant="text"
-            onClick={() => setSecondaryColor(null)}
-            disabled={secondaryColor === null}
-          >
-            Reset
-          </Button>
-        </Box>
-        <Box display="flex" minWidth="300px" flex="1">
-          <TextFieldColorPicker
-            label="Tertiary color"
-            value={
-              tertiaryColor ||
-              toColor('hex', hexFromArgb(tertiaryColorTonal.tone(40)))
+        <BorderSlider
+          label="Extra small"
+          defaultValue={radiusExtraSmall}
+          onChange={(v) => setRadiusExtraSmall(v)}
+          onReset={() => {
+            setRadiusExtraSmall(parseInt(remToPx(theme.radii['extra-small'])));
+          }}
+          resetDisabled={rem(radiusExtraSmall) === theme.radii['extra-small']}
+        />
+        <BorderSlider
+          label="Small"
+          defaultValue={radiusSmall}
+          onChange={(v) => setRadiusSmall(v)}
+          onReset={() => {
+            setRadiusSmall(parseInt(remToPx(theme.radii['small'])));
+          }}
+          resetDisabled={rem(radiusSmall) === theme.radii.small}
+        />
+        <BorderSlider
+          label="Medium"
+          defaultValue={radiusMedium}
+          onChange={(v) => setRadiusMedium(v)}
+          onReset={() => {
+            setRadiusMedium(parseInt(remToPx(theme.radii['medium'])));
+          }}
+          resetDisabled={rem(radiusMedium) === theme.radii['medium']}
+        />
+        <BorderSlider
+          label="Large"
+          defaultValue={radiusLarge}
+          onChange={(v) => setRadiusLarge(v)}
+          onReset={() => {
+            setRadiusLarge(parseInt(remToPx(theme.radii['large'])));
+          }}
+          resetDisabled={rem(radiusLarge) === theme.radii['large']}
+        />
+        <BorderSlider
+          label="Extra large"
+          defaultValue={radiusExtraLarge}
+          onChange={(v) => setRadiusExtraLarge(v)}
+          onReset={() => {
+            setRadiusExtraLarge(parseInt(remToPx(theme.radii['extra-large'])));
+          }}
+          resetDisabled={rem(radiusExtraLarge) === theme.radii['extra-large']}
+        />
+      </Box>
+      {/* Font pickers */}
+      <Text variant="headline-small">Typography</Text>
+      <Box display="flex" my={3} sx={{ gap: 3, flexWrap: 'wrap' }}>
+        <FontAutoComplete
+          label="Brand"
+          initialValue={brandFont}
+          onSelect={(f) => {
+            if (f) {
+              setBrandFont(f);
+              loadGoogleFont([
+                { family: f, weights: [300, 400, 500, 600, 700] },
+              ]);
             }
-            onChange={(c) => setTertiaryColor(c)}
-          />
-          <Button
-            variant="text"
-            onClick={() => setTertiaryColor(null)}
-            disabled={tertiaryColor === null}
-          >
-            Reset
-          </Button>
-        </Box>
-        <Box display="flex" minWidth="300px" flex="1">
-          <TextFieldColorPicker
-            label="Neutral color"
-            value={
-              neutralColor ||
-              toColor('hex', hexFromArgb(neutralColorTonal.tone(40)))
+          }}
+          onReset={() => {
+            setBrandFont(parseMainFont(theme.fonts.brand));
+          }}
+          resetDisabled={brandFont === parseMainFont(theme.fonts.brand)}
+        />
+        <FontAutoComplete
+          label="Plain"
+          initialValue={plainFont}
+          onSelect={(f) => {
+            if (f) {
+              setPlainFont(f);
+              loadGoogleFont([
+                { family: f, weights: [300, 400, 500, 600, 700] },
+              ]);
             }
-            onChange={(c) => setNeutralColor(c)}
-          />
-          <Button
-            variant="text"
-            onClick={() => setNeutralColor(null)}
-            disabled={neutralColor === null}
-          >
-            Reset
-          </Button>
-        </Box>
+          }}
+          onReset={() => {
+            setPlainFont(parseMainFont(theme.fonts.plain));
+          }}
+          resetDisabled={plainFont === parseMainFont(theme.fonts.plain)}
+        />
+      </Box>
+      {/* Color pickers */}
+      <Text variant="headline-small">Color schemes</Text>
+      <Box display="flex" my={3} sx={{ gap: 3, flexWrap: 'wrap' }}>
+        <ColorSchemePicker
+          label="Primary color"
+          initialValue={primaryColor}
+          onChange={(c) => setPrimaryColor(c)}
+          onReset={() => setPrimaryColor(toColor('hex', theme.colors.primary))}
+          resetDisabled={
+            primaryColor.hex === toColor('hex', theme.colors.primary).hex
+          }
+        />
+        <ColorSchemePicker
+          label="Secondary color"
+          initialValue={
+            secondaryColor ||
+            toColor('hex', hexFromArgb(secondaryColorTonal.tone(40)))
+          }
+          onChange={(c) => setSecondaryColor(c)}
+          onReset={() => setSecondaryColor(null)}
+          resetDisabled={secondaryColor === null}
+        />
+        <ColorSchemePicker
+          label="Tertiary color"
+          initialValue={
+            tertiaryColor ||
+            toColor('hex', hexFromArgb(tertiaryColorTonal.tone(40)))
+          }
+          onChange={(c) => setTertiaryColor(c)}
+          onReset={() => setTertiaryColor(null)}
+          resetDisabled={tertiaryColor === null}
+        />
+        <ColorSchemePicker
+          label="Neutral color"
+          initialValue={
+            neutralColor ||
+            toColor('hex', hexFromArgb(neutralColorTonal.tone(40)))
+          }
+          onChange={(c) => setNeutralColor(c)}
+          onReset={() => setNeutralColor(null)}
+          resetDisabled={neutralColor === null}
+        />
       </Box>
       <Box width="100%">
         <Box display="flex" flexDirection="column" sx={{ gap: 4 }}>
           <Box flex="1">
-            <Text variant="title-medium" as="h1" pb={'0.3em'}>
+            <Text variant="title-medium" as="h1" pb={'0.3em'} pt={3}>
               Light theme
             </Text>
             <ThemeColors scheme={scheme} />
           </Box>
           <Box flex="1">
-            <Text variant="title-medium" as="h1" pb={'0.3em'}>
+            <Text variant="title-medium" as="h1" pb={'0.3em'} pt={3}>
               Dark theme
             </Text>
             <ThemeColors scheme={scheme.modes.dark} />
           </Box>
         </Box>
         <Box my={4} display="flex" sx={{ gap: 3 }} flexDirection="column">
+          <Text variant="title-medium" as="h1" pb={'0.3em'} pt={3}>
+            Palettes
+          </Text>
           <TonalColors palette={a1} />
           <TonalColors palette={secondaryColorTonal} />
           <TonalColors palette={tertiaryColorTonal} />
@@ -189,10 +326,12 @@ const ThemeBuilderImpl = (props: ThemeBuilderProps) => {
           <TonalColors palette={neutralColorTonal} />
           <TonalColors palette={n2} />
         </Box>
-        <CodeHighlightingComponent className={`language-json`}>
-          {JSON.stringify({ colors: scheme }, null, 2)}
-        </CodeHighlightingComponent>
       </Box>
+      {/* Color pickers */}
+      <Text variant="headline-small">Theme</Text>
+      <CodeHighlightingComponent className={`language-json`}>
+        {JSON.stringify(newTheme, null, 2)}
+      </CodeHighlightingComponent>
     </>
   );
 };

package/src/ThemeExplorer/components.tsx

@@ -80,13 +80,13 @@ export const ColorRow = memo(
         display="flex"
         sx={{
           ':first-of-type': {
-            borderTopLeftRadius: 24,
-            borderTopRightRadius: 24,
+            borderTopLeftRadius: 'extra-large',
+            borderTopRightRadius: 'extra-large',
             overflow: 'hidden',
           },
           ':last-of-type': {
-            borderBottomLeftRadius: 24,
-            borderBottomRightRadius: 24,
+            borderBottomLeftRadius: 'extra-large',
+            borderBottomRightRadius: 'extra-large',
             overflow: 'hidden',
           },
           height,