classname-variants 1.0.2 → 1.1.0

package/README.md

@@ -138,7 +138,8 @@ 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:
 
 ```tsx
-type Props = SX.IntrinsicElements["button"] & VariantProps<typeof buttonProps>;
+type Props = SX.IntrinsicElements["button"] &
+  VariantPropsOf<typeof buttonProps>;
 
 function Button(props: Props) {
   return <button {...buttonProps(props)} />;
@@ -170,6 +171,8 @@ const Button = styled("button", {
 });
 ```
 
+You can also style other custom React components as long as the accept a `className` prop.
+
 # Tailwind IntelliSense
 
 In order to get auto-completion for the CSS classes themselves, you can use the [Tailwind CSS IntelliSense](https://github.com/tailwindlabs/tailwindcss-intellisense) plugin for VS Code. In order to make it recognize the strings inside your variants config, you have to somehow mark them and configure the plugin accordingly.

package/example.tsx

@@ -1,7 +1,16 @@
-import React from "react";
+import React, { createElement } from "react";
 import ReactDOM from "react-dom";
 import { styled } from "./src/react";
 
+function CustomComponent(props: { className?: string }) {
+  return <div {...props}>I'm a custom component!</div>;
+}
+
+const Card = styled(CustomComponent, {
+  base: "bg-white p-4 border-2 rounded-lg",
+  variants: {},
+});
+
 const Button = styled("button", {
   base: "px-5 py-2 text-white disabled:bg-gray-400 disabled:text-gray-300",
   variants: {
@@ -39,6 +48,7 @@ function App() {
       <Button color="accent" disabled>
         Disabled
       </Button>
+      <Card />
     </div>
   );
 }

package/lib/react.d.ts

@@ -1,9 +1,22 @@
 import { ComponentProps, ElementType, ForwardRefExoticComponent, PropsWithoutRef } from "react";
 import { Variants, VariantsConfig, VariantOptions, Simplify } from ".";
-export declare type VariantProps<T> = T extends (props: infer VariantSelection) => any ? VariantSelection : never;
-export declare function variantProps<C extends VariantsConfig<V>, V extends Variants = C["variants"]>(config: Simplify<C>): <T extends VariantOptions<C, C["variants"]>>(props: T) => {
+/**
+ * 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<T, keyof C["variants"]>;
-declare type StyledComponent<P extends ElementType, C extends VariantsConfig<V>, V extends Variants = C["variants"]> = ForwardRefExoticComponent<PropsWithoutRef<ComponentProps<P> & VariantOptions<C>> & React.RefAttributes<P>>;
-export declare function styled<P extends ElementType, C extends VariantsConfig<V>, V extends Variants = C["variants"]>(type: P, config: Simplify<C>): StyledComponent<P, C>;
+} & Omit<P, keyof C["variants"]>;
+declare type StyledComponent<T extends ElementType<{
+    className: string;
+}>, 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<{
+    className: string;
+}>, C extends VariantsConfig<V>, V extends Variants = C["variants"]>(type: T, config: Simplify<C>): StyledComponent<T, C>;
 export {};

package/lib/react.js

@@ -1,15 +1,19 @@
 import { createElement, forwardRef, } from "react";
 import { variants, } from ".";
 export function variantProps(config) {
-    const mkClass = variants(config);
+    const variantClassName = variants(config);
     return (props) => {
-        const className = mkClass(props);
-        const result = { className };
+        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;
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "classname-variants",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Variant API for plain class names",
   "author": "Felix Gnass <fgnass@gmail.com>",
   "license": "MIT",
@@ -30,7 +30,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "start": "npx vite"
+    "start": "npx vite",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "tailwind",

package/src/react.ts

@@ -15,43 +15,59 @@ import {
   Simplify,
 } from ".";
 
-export type VariantProps<T> = T extends (props: infer VariantSelection) => any
-  ? VariantSelection
-  : never;
+/**
+ * Utility type to infer the first argument of a variantProps function.
+ */
+export 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.
+ */
+type VariantProps<
+  C extends VariantsConfig<V>,
+  V extends Variants = C["variants"]
+> = VariantOptions<C> & { className?: string };
 
 export function variantProps<
   C extends VariantsConfig<V>,
   V extends Variants = C["variants"]
 >(config: Simplify<C>) {
-  const mkClass = variants<C>(config);
-  return <T extends VariantOptions<C>>(props: T) => {
-    const className = mkClass(props);
-    const result: any = { className };
+  const variantClassName = variants<C>(config);
+  return <P extends VariantProps<C>>(props: P) => {
+    const result: any = {};
+
+    // Pass-through all unrelated props
     for (let prop in props) {
       if (config.variants && !(prop in config.variants)) {
         result[prop] = props[prop];
       }
     }
-    return result as { className: string } & Omit<T, keyof C["variants"]>;
+
+    // Add the optionally passed className prop for chaining
+    result.className = [props.className, variantClassName(props)]
+      .filter(Boolean)
+      .join(" ");
+
+    return result as { className: string } & Omit<P, keyof C["variants"]>;
   };
 }
 
 type StyledComponent<
-  P extends ElementType,
+  T extends ElementType<{ className: string }>,
   C extends VariantsConfig<V>,
   V extends Variants = C["variants"]
 > = ForwardRefExoticComponent<
-  PropsWithoutRef<ComponentProps<P> & VariantOptions<C>> &
-    React.RefAttributes<P>
+  PropsWithoutRef<ComponentProps<T> & VariantOptions<C>> &
+    React.RefAttributes<T>
 >;
 
 export function styled<
-  P extends ElementType,
+  T extends ElementType<{ className: string }>,
   C extends VariantsConfig<V>,
   V extends Variants = C["variants"]
->(type: P, config: Simplify<C>): StyledComponent<P, C> {
+>(type: T, config: Simplify<C>): StyledComponent<T, C> {
   const styledProps = variantProps(config);
-  return forwardRef<P, ComponentProps<P> & VariantOptions<C>>((props, ref) =>
+  return forwardRef<T, ComponentProps<T> & VariantOptions<C>>((props, ref) =>
     createElement(type, { ...styledProps(props), ref })
   );
 }