classname-variants 1.2.0 → 1.3.0

package/README.md

@@ -4,13 +4,13 @@ Stitches-like [variant API](https://stitches.dev/docs/variants) for plain class
 
 The library is framework agnostic and can be used with any kind of CSS flavor.
 
-It is especially useful though if used with [Tailwind](https://tailwindcss.com/) or [CSS Modules](https://github.com/css-modules/css-modules) in cobmination with React, as it provides some [dedicated helpers](#React) and even allows for a _styled-components_ like API, but with [class names instead of styles](#bonus-styled-components-but-with-class-names-)!
+It is especially useful though if used with [Tailwind](https://tailwindcss.com/) or [CSS Modules](https://github.com/css-modules/css-modules) in combination with React, as it provides some [dedicated helpers](#React) and even allows for a _styled-components_ like API, but with [class names instead of styles](#bonus-styled-components-but-with-class-names-)!
 
 [![Edit classname-variants/react](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/classname-variants-react-3bzjl?fontsize=14&hidenavigation=1&theme=dark)
 
 # Basics
 
-Let's aussume we want to build a button component with Tailwind CSS that comes in different sizes and colors.
+Let's assume we want to build a button component with Tailwind CSS that comes in different sizes and colors.
 
 It consists of some _base classes_ that are always present as well as some optional classes that need to be added depending on the desired _variants_.
 
@@ -135,10 +135,10 @@ const buttonProps = variantProps({
 });
 ```
 
-This way a compontents' props (or part of them) can be directly spread into the target element. All variant-related props are used to construct the `className` property while all other props are passed through verbatim:
+This way a component's props (or part of them) can be directly spread into the target element. All variant-related props are used to construct the `className` property while all other props are passed through verbatim:
 
 ```tsx
-type Props = SX.IntrinsicElements["button"] &
+type Props = JSX.IntrinsicElements["button"] &
   VariantPropsOf<typeof buttonProps>;
 
 function Button(props: Props) {
@@ -154,9 +154,9 @@ function App() {
 }
 ```
 
-# Bonus: styled-components, but with class names 💅
+# Bonus: styled-components, but for static CSS 💅
 
-Things can be taken even a step further, resulting in a _styled-components_ like way of defining reusable components:
+Things can be taken even a step further, resulting in a _styled-components_ like way of defining reusable components. Under the hood, this does basically the same as the example above, but also handles _refs_ correctly:
 
 ```tsx
 import { styled } from "classname-variants/react";
@@ -171,7 +171,7 @@ const Button = styled("button", {
 });
 ```
 
-The same can be done with CSS modules:
+Again, this is not limited to tailwind, so you could do the same with CSS modules:
 
 ```tsx
 import { styled } from "classname-variants/react";
@@ -187,7 +187,33 @@ const Button = styled("button", {
 });
 ```
 
-You can also style other custom React components as long as the accept a `className` prop.
+**NOTE:** You can also style other custom React components as long as they accept a `className` prop.
+
+## Polymorphic components with "as"
+
+If you want to keep all the variants you have defined for a component but want to render a different HTML tag or a different custom component, you can use the "as" prop to do so:
+
+```tsx
+import { styled } from "classname-variants/react";
+import styles from "./styles.module.css";
+
+const Button = styled("button", {
+  variants: {
+    //...
+  },
+});
+
+function App() {
+  return (
+    <div>
+      <Button>I'm a button</Button>
+      <Button as="a" href="/">
+        I'm a link!
+      </Button>
+    </div>
+  );
+}
+```
 
 # Tailwind IntelliSense
 

package/example.tsx

@@ -12,7 +12,9 @@ function CustomComponent({
   return <div {...props}>{title}</div>;
 }
 
-const Card = styled(CustomComponent, "bg-white p-4 border-2 rounded-lg");
+const Card = styled("div", "bg-white p-4 border-2 rounded-lg");
+
+const TitleCard = styled(CustomComponent, "bg-white p-4 border-2 rounded-lg");
 
 const Button = styled("button", {
   base: "px-5 py-2 text-white disabled:bg-gray-400 disabled:text-gray-300",
@@ -51,7 +53,14 @@ function App() {
       <Button color="accent" disabled>
         Disabled
       </Button>
-      <Card title="Hello" />
+      <TitleCard title="Hello" />
+      <Card>
+        <h1>Hello</h1>
+        <p>world</p>
+      </Card>
+      <Card as="a" href="https://example.com">
+        Link
+      </Card>
     </div>
   );
 }

package/lib/example.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/example.js

@@ -0,0 +1,45 @@
+import React from "react";
+import ReactDOM from "react-dom";
+import { styled } from "./src/react";
+function CustomComponent({ title, ...props }) {
+    return React.createElement("div", { ...props }, title);
+}
+const Card = styled("div", "bg-white p-4 border-2 rounded-lg");
+const TitleCard = styled(CustomComponent, "bg-white p-4 border-2 rounded-lg");
+const Button = styled("button", {
+    base: "px-5 py-2 text-white disabled:bg-gray-400 disabled:text-gray-300",
+    variants: {
+        color: {
+            neutral: "bg-slate-500 hover:bg-slate-400",
+            accent: "bg-teal-500 hover:bg-teal-400",
+        },
+        outlined: {
+            true: "border-2",
+        },
+        rounded: {
+            true: "rounded-full",
+            false: "rounded-sm",
+        },
+    },
+    compoundVariants: [
+        {
+            variants: { color: "accent", outlined: true },
+            className: "border-teal-600",
+        },
+    ],
+    defaultVariants: {
+        color: "neutral",
+    },
+});
+function App() {
+    return (React.createElement("div", { className: "flex justify-center items-center pt-8 gap-4 flex-wrap" },
+        React.createElement(Button, { onClick: console.log }, "Accent"),
+        React.createElement(Button, { rounded: true }, "Neutral + Rounded"),
+        React.createElement(Button, { color: "accent", outlined: true }, "Accent + Outlined"),
+        React.createElement(Button, { color: "accent", disabled: true }, "Disabled"),
+        React.createElement(TitleCard, { title: "Hello" }),
+        React.createElement(Card, null,
+            React.createElement("h1", null, "Hello"),
+            React.createElement("p", null, "world"))));
+}
+ReactDOM.render(React.createElement(App, null), document.getElementById("root"));

package/lib/react.d.ts

@@ -1,4 +1,4 @@
-import { ComponentProps, ElementType, ForwardRefExoticComponent, PropsWithoutRef } from "react";
+import { ComponentProps, ElementType, ReactElement } from "react";
 import { Variants, VariantsConfig, VariantOptions, Simplify } from "./index.js";
 /**
  * Utility type to infer the first argument of a variantProps function.
@@ -13,6 +13,18 @@ declare type VariantProps<C extends VariantsConfig<V>, V extends Variants = C["v
 export declare function variantProps<C extends VariantsConfig<V>, V extends Variants = C["variants"]>(config: Simplify<C>): <P extends VariantProps<C, C["variants"]>>(props: P) => {
     className: string;
 } & Omit<P, keyof C["variants"]>;
-declare type StyledComponent<T extends ElementType, C extends VariantsConfig<V>, V extends Variants = C["variants"]> = ForwardRefExoticComponent<PropsWithoutRef<ComponentProps<T> & VariantOptions<C>> & React.RefAttributes<T>>;
-export declare function styled<T extends ElementType, C extends VariantsConfig<V>, V extends Variants = C["variants"]>(type: T, config: string | Simplify<C>): StyledComponent<T, C>;
+declare type VariantsOf<T> = T extends VariantsConfig<infer V> ? V : {};
+declare type AsProps<T extends ElementType = ElementType> = {
+    as?: T;
+};
+declare type PolymorphicComponentProps<T extends ElementType> = AsProps<T> & Omit<ComponentProps<T>, "as">;
+export declare function styled<T extends ElementType, C extends VariantsConfig<V>, V extends Variants = VariantsOf<C>>(type: T, config: string | Simplify<C>): <As extends ElementType<any> = T>(props: AsProps<As> & Omit<ComponentProps<As>, "as"> & { [K in keyof C["variants"] as K extends keyof { [K_1 in keyof C["variants"] as C["variants"][K_1] extends {
+    true: any;
+} | {
+    false: any;
+} ? K_1 : never]: C["variants"][K_1]; } | keyof { [K_2 in keyof C["variants"] as K_2 extends keyof C["defaultVariants"] ? K_2 : never]: C["variants"][K_2]; } ? never : K]: { [K_3 in keyof C["variants"]]: keyof C["variants"][K_3] extends "true" | "false" ? boolean : keyof C["variants"][K_3]; }[K]; } & { [K_4 in keyof C["variants"] as K_4 extends keyof { [K_1 in keyof C["variants"] as C["variants"][K_1] extends {
+    true: any;
+} | {
+    false: any;
+} ? K_1 : never]: C["variants"][K_1]; } | keyof { [K_2 in keyof C["variants"] as K_2 extends keyof C["defaultVariants"] ? K_2 : never]: C["variants"][K_2]; } ? K_4 : never]?: { [K_3 in keyof C["variants"]]: keyof C["variants"][K_3] extends "true" | "false" ? boolean : keyof C["variants"][K_3]; }[K_4] | undefined; }) => ReactElement | null;
 export {};

package/lib/react.js

@@ -21,5 +21,8 @@ export function styled(type, config) {
     const styledProps = typeof config === "string"
         ? variantProps({ base: config, variants: {} })
         : variantProps(config);
-    return forwardRef((props, ref) => createElement(type, { ...styledProps(props), ref }));
+    const Component = forwardRef(({ as, ...props }, ref) => {
+        return createElement(as !== null && as !== void 0 ? as : type, { ...styledProps(props), ref });
+    });
+    return Component;
 }

package/lib/src/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Definition of the available variants and their options.
+ * @example
+ * {
+ *   color: {
+ *     white: "bg-white"
+ *     green: "bg-green-500",
+ *   },
+ *   size: {
+ *     small: "text-xs",
+ *     large: "text-lg"
+ *   }
+ * }
+ */
+export declare type Variants = Record<string, Record<string, string>>;
+/**
+ * Configuration including defaults and compound variants.
+ */
+export interface VariantsConfig<V extends Variants> {
+    base?: string;
+    variants: V;
+    compoundVariants?: CompoundVariant<V>[];
+    defaultVariants?: Partial<OptionsOf<V>>;
+}
+/**
+ * Rules for class names that are applied for certain variant combinations.
+ */
+export interface CompoundVariant<V extends Variants> {
+    variants: Partial<OptionsOf<V>>;
+    className: string;
+}
+/**
+ * Only the boolean variants, i.e. ones that have "true" or "false" as options.
+ */
+declare type BooleanVariants<V extends Variants> = {
+    [K in keyof V as V[K] extends {
+        true: any;
+    } | {
+        false: any;
+    } ? K : never]: V[K];
+};
+/**
+ * Only the variants for which a default options is set.
+ */
+declare type DefaultVariants<C extends VariantsConfig<V>, V extends Variants = C["variants"]> = {
+    [K in keyof V as K extends keyof C["defaultVariants"] ? K : never]: C["variants"][K];
+};
+/**
+ * Names of all optional variants, i.e. booleans or ones with default options.
+ */
+declare type OptionalVariantNames<C extends VariantsConfig<V>, V extends Variants = C["variants"]> = keyof BooleanVariants<V> | keyof DefaultVariants<C>;
+/**
+ * Possible options for all the optional variants.
+ *
+ * @example
+ * {
+ *   color?: "white" | "green",
+ *   rounded?: boolean | undefined
+ * }
+ */
+declare type OptionalOptions<C extends VariantsConfig<V>, V extends Variants = C["variants"]> = {
+    [K in keyof V as K extends OptionalVariantNames<C> ? K : never]?: OptionsOf<V>[K];
+};
+/**
+ * Possible options for all required variants.
+ *
+ * @example {
+ *   size: "small" | "large"
+ * }
+ */
+declare type RequiredOptions<C extends VariantsConfig<V>, V extends Variants = C["variants"]> = {
+    [K in keyof V as K extends OptionalVariantNames<C> ? never : K]: OptionsOf<V>[K];
+};
+/**
+ * Utility type to extract the possible options.
+ * Converts "true" | "false" options into booleans.
+ *
+ * @example
+ * OptionsOf<{
+ *   size: { small: "text-xs"; large: "text-lg" };
+ *   rounded: { true: "rounded-full" }
+ * }>
+ * ==>
+ * {
+ *   size: "text-xs" | "text-lg";
+ *   rounded: boolean;
+ * }
+ */
+declare type OptionsOf<V extends Variants> = {
+    [K in keyof V]: keyof V[K] extends "true" | "false" ? boolean : keyof V[K];
+};
+/**
+ * Extracts the possible options.
+ */
+export declare type VariantOptions<C extends VariantsConfig<V>, V extends Variants = C["variants"]> = RequiredOptions<C> & OptionalOptions<C>;
+/**
+ * Without this conversion step, defaultVariants and compoundVariants will
+ * allow extra keys, i.e. non-existent variants.
+ * See https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
+ */
+export declare type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+export declare function variants<C extends VariantsConfig<V>, V extends Variants = C["variants"]>(config: Simplify<C>): (props: VariantOptions<C>) => string;
+export {};

package/lib/src/index.js

@@ -0,0 +1,27 @@
+export function variants(config) {
+    const { base, variants, compoundVariants, defaultVariants } = config;
+    const isBooleanVariant = (name) => {
+        const v = variants === null || variants === void 0 ? void 0 : variants[name];
+        return v && ("false" in v || "true" in v);
+    };
+    return (props) => {
+        var _a;
+        const res = [base];
+        const getSelected = (name) => {
+            var _a, _b;
+            return (_b = (_a = props[name]) !== null && _a !== void 0 ? _a : defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[name]) !== null && _b !== void 0 ? _b : (isBooleanVariant(name) ? false : undefined);
+        };
+        for (let name in variants) {
+            const selected = getSelected(name);
+            if (selected !== undefined)
+                res.push((_a = variants[name]) === null || _a === void 0 ? void 0 : _a[selected]);
+        }
+        for (let { variants, className } of compoundVariants !== null && compoundVariants !== void 0 ? compoundVariants : []) {
+            const isSelected = (name) => getSelected(name) === variants[name];
+            if (Object.keys(variants).every(isSelected)) {
+                res.push(className);
+            }
+        }
+        return res.filter(Boolean).join(" ");
+    };
+}

package/lib/src/react.d.ts

@@ -0,0 +1,19 @@
+import { ComponentProps, ElementType, ForwardRefExoticComponent, PropsWithoutRef } from "react";
+import { Variants, VariantsConfig, VariantOptions, Simplify } from "./index.js";
+/**
+ * Utility type to infer the first argument of a variantProps function.
+ */
+export declare type VariantPropsOf<T> = T extends (props: infer P) => any ? P : never;
+/**
+ * Type for the variantProps() argument – consists of the VariantOptions and an optional className for chaining.
+ */
+declare type VariantProps<C extends VariantsConfig<V>, V extends Variants = C["variants"]> = VariantOptions<C> & {
+    className?: string;
+};
+export declare function variantProps<C extends VariantsConfig<V>, V extends Variants = C["variants"]>(config: Simplify<C>): <P extends VariantProps<C, C["variants"]>>(props: P) => {
+    className: string;
+} & Omit<P, keyof C["variants"]>;
+declare type StyledComponent<T extends ElementType, C extends VariantsConfig<V>, V extends Variants = C["variants"]> = ForwardRefExoticComponent<PropsWithoutRef<ComponentProps<T> & VariantOptions<C>> & React.RefAttributes<T>>;
+declare type Vars<T> = T extends VariantsConfig<infer V> ? V : {};
+export declare function styled<T extends ElementType, C extends VariantsConfig<V>, V extends Variants = Vars<C>>(type: T, config: string | Simplify<C>): StyledComponent<T, C>;
+export {};

package/lib/src/react.js

@@ -0,0 +1,25 @@
+import { createElement, forwardRef, } from "react";
+import { variants, } from "./index.js";
+export function variantProps(config) {
+    const variantClassName = variants(config);
+    return (props) => {
+        const result = {};
+        // Pass-through all unrelated props
+        for (let prop in props) {
+            if (config.variants && !(prop in config.variants)) {
+                result[prop] = props[prop];
+            }
+        }
+        // Add the optionally passed className prop for chaining
+        result.className = [props.className, variantClassName(props)]
+            .filter(Boolean)
+            .join(" ");
+        return result;
+    };
+}
+export function styled(type, config) {
+    const styledProps = typeof config === "string"
+        ? variantProps({ base: config, variants: {} })
+        : variantProps(config);
+    return forwardRef((props, ref) => createElement(type, { ...styledProps(props), ref }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "classname-variants",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Variant API for plain class names",
   "author": "Felix Gnass <fgnass@gmail.com>",
   "license": "MIT",
@@ -44,6 +44,6 @@
     "@types/react": "^17.0.39",
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
-    "typescript": "^4.5.5"
+    "typescript": "^4.6.4"
   }
 }

package/src/react.ts

@@ -3,8 +3,8 @@ import {
   createElement,
   ElementType,
   forwardRef,
-  ForwardRefExoticComponent,
-  PropsWithoutRef,
+  ReactElement,
+  Ref,
 } from "react";
 
 import {
@@ -52,25 +52,31 @@ export function variantProps<
   };
 }
 
-type StyledComponent<
-  T extends ElementType,
-  C extends VariantsConfig<V>,
-  V extends Variants = C["variants"]
-> = ForwardRefExoticComponent<
-  PropsWithoutRef<ComponentProps<T> & VariantOptions<C>> &
-    React.RefAttributes<T>
->;
+type VariantsOf<T> = T extends VariantsConfig<infer V> ? V : {};
+
+type AsProps<T extends ElementType = ElementType> = {
+  as?: T;
+};
+
+type PolymorphicComponentProps<T extends ElementType> = AsProps<T> &
+  Omit<ComponentProps<T>, "as">;
 
 export function styled<
   T extends ElementType,
   C extends VariantsConfig<V>,
-  V extends Variants = C["variants"]
->(type: T, config: string | Simplify<C>): StyledComponent<T, C> {
+  V extends Variants = VariantsOf<C>
+>(type: T, config: string | Simplify<C>) {
   const styledProps =
     typeof config === "string"
       ? variantProps({ base: config, variants: {} })
       : variantProps(config);
-  return forwardRef<T, ComponentProps<T> & VariantOptions<C>>((props, ref) =>
-    createElement(type, { ...styledProps(props), ref })
+
+  const Component: <As extends ElementType = T>(
+    props: PolymorphicComponentProps<As> & VariantOptions<C>
+  ) => ReactElement | null = forwardRef(
+    ({ as, ...props }: AsProps, ref: Ref<Element>) => {
+      return createElement(as ?? type, { ...styledProps(props), ref });
+    }
   );
+  return Component;
 }