tailwind-variants 3.2.1 → 3.3.0

package/dist/types.d.ts

@@ -1,300 +1,134 @@
-import type {ClassNameValue as ClassValue} from "tailwind-merge";
-import type {TVConfig} from "./config.d.ts";
-
-/**
- * ----------------------------------------
- * Base Types
- * ----------------------------------------
- */
-
-export type {ClassValue};
-
-export type ClassProp<V extends unknown = ClassValue> =
-  | {class?: V; className?: never}
-  | {class?: never; className?: V};
-
+import { C as ClassNameValue, a as TVConfig } from './config-bO3A8WhU.js';
+
+type ClassProp<V = ClassNameValue> = {
+    class?: V;
+    className?: never;
+} | {
+    class?: never;
+    className?: V;
+};
 type TVBaseName = "base";
-
 type TVScreens = "initial";
-
-type TVSlots = Record<string, ClassValue> | undefined;
-
-/**
- * ----------------------------------------------------------------------
- * Utils
- * ----------------------------------------------------------------------
- */
-
-export type OmitUndefined<T> = T extends undefined ? never : T;
-
-export type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
-
-type CnClassValue =
-  | string
-  | number
-  | bigint
-  | boolean
-  | null
-  | undefined
-  | CnClassDictionary
-  | CnClassArray;
-
+type TVSlots = Record<string, ClassNameValue> | undefined;
+type TVVariantsShape = Record<string, Record<string, unknown>> | undefined;
+interface TVReturnTypeLike<V extends TVVariantsShape, S extends TVSlots> {
+    (...args: any[]): any;
+    variants: V;
+    slots: S;
+}
+type OmitUndefined<T> = T extends undefined ? never : T;
+type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
+type VariantValue<V, K> = K extends keyof V ? StringToBoolean<keyof V[K]> : never;
+type VariantValueWithBooleanUndefined<V, K> = VariantValue<V, K> | (boolean extends VariantValue<V, K> ? undefined : never);
+type CnClassValue = string | number | bigint | boolean | null | undefined | CnClassDictionary | CnClassArray;
 interface CnClassDictionary {
-  [key: string]: any;
+    [key: string]: any;
 }
-
-interface CnClassArray extends Array<CnClassValue> {}
-
-export type CnOptions = CnClassValue[];
-
-export type CnReturn = string | undefined;
-
-// compare if the value is true or array of values
-export type isTrueOrArray<T> = T extends true | unknown[] ? true : false;
-
-export type WithInitialScreen<T extends Array<string>> = ["initial", ...T];
-
-/**
- * ----------------------------------------------------------------------
- * TV Types
- * ----------------------------------------------------------------------
- */
-
-type TVSlotsWithBase<S extends TVSlots, B extends ClassValue> = B extends undefined
-  ? keyof S
-  : keyof S | TVBaseName;
-
-type SlotsClassValue<S extends TVSlots, B extends ClassValue> = {
-  [K in TVSlotsWithBase<S, B>]?: ClassValue;
+interface CnClassArray extends Array<CnClassValue> {
+}
+type CnOptions = CnClassValue[];
+type CnReturn = string | undefined;
+type isTrueOrArray<T> = T extends true | unknown[] ? true : false;
+type WithInitialScreen<T extends Array<string>> = ["initial", ...T];
+type TVSlotsWithBase<S extends TVSlots, B extends ClassNameValue> = keyof S | (B extends undefined ? never : TVBaseName);
+type SlotsClassValue<S extends TVSlots, B extends ClassNameValue> = {
+    [K in TVSlotsWithBase<S, B>]?: ClassNameValue;
 };
-
-type TVVariantsDefault<S extends TVSlots, B extends ClassValue> = S extends undefined
-  ? {}
-  : {
-      [key: string]: {
-        [key: string]: S extends TVSlots ? SlotsClassValue<S, B> | ClassValue : ClassValue;
-      };
+type TVVariantsDefault<S extends TVSlots, B extends ClassNameValue> = S extends undefined ? {} : {
+    [key: string]: {
+        [key: string]: S extends TVSlots ? SlotsClassValue<S, B> | ClassNameValue : ClassNameValue;
     };
-
-export type TVVariants<
-  S extends TVSlots | undefined,
-  B extends ClassValue | undefined = undefined,
-  EV extends TVVariants<ES> | undefined = undefined,
-  ES extends TVSlots | undefined = undefined,
-> = EV extends undefined
-  ? TVVariantsDefault<S, B>
-  :
-      | {
-          [K in keyof EV]: {
-            [K2 in keyof EV[K]]: S extends TVSlots
-              ? SlotsClassValue<S, B> | ClassValue
-              : ClassValue;
-          };
-        }
-      | TVVariantsDefault<S, B>;
-
-export type TVCompoundVariants<
-  V extends TVVariants<S>,
-  S extends TVSlots,
-  B extends ClassValue,
-  EV extends TVVariants<ES>,
-  ES extends TVSlots,
-> = Array<
-  {
-    [K in keyof V | keyof EV]?:
-      | (K extends keyof V ? StringToBoolean<keyof V[K]> : never)
-      | (K extends keyof EV ? StringToBoolean<keyof EV[K]> : never)
-      | (K extends keyof V ? StringToBoolean<keyof V[K]>[] : never);
-  } & ClassProp<SlotsClassValue<S, B> | ClassValue>
->;
-
-export type TVCompoundSlots<
-  V extends TVVariants<S>,
-  S extends TVSlots,
-  B extends ClassValue,
-> = Array<
-  V extends undefined
-    ? {
-        slots: Array<TVSlotsWithBase<S, B>>;
-      } & ClassProp
-    : {
-        slots: Array<TVSlotsWithBase<S, B>>;
-      } & {
-        [K in keyof V]?: StringToBoolean<keyof V[K]> | StringToBoolean<keyof V[K]>[];
-      } & ClassProp
->;
-
-export type TVDefaultVariants<
-  V extends TVVariants<S>,
-  S extends TVSlots,
-  EV extends TVVariants<ES>,
-  ES extends TVSlots,
-> = {
-  [K in keyof V | keyof EV]?:
-    | (K extends keyof V ? StringToBoolean<keyof V[K]> : never)
-    | (K extends keyof EV ? StringToBoolean<keyof EV[K]> : never);
 };
-
-export type TVScreenPropsValue<V extends TVVariants<S>, S extends TVSlots, K extends keyof V> = {
-  [Screen in TVScreens]?: StringToBoolean<keyof V[K]>;
+type TVVariants<S extends TVSlots | undefined, B extends ClassNameValue | undefined = undefined, EV extends TVVariantsShape = undefined, _ES extends TVSlots | undefined = undefined> = EV extends undefined ? TVVariantsDefault<S, B> : {
+    [K in keyof EV]: {
+        [K2 in keyof EV[K]]: S extends TVSlots ? SlotsClassValue<S, B> | ClassNameValue : ClassNameValue;
+    };
+} | TVVariantsDefault<S, B>;
+type TVCompoundVariants<V extends TVVariantsShape, S extends TVSlots, B extends ClassNameValue, EV extends TVVariantsShape, _ES extends TVSlots> = Array<{
+    [K in keyof V | keyof EV]?: VariantValueWithBooleanUndefined<V, K> | VariantValueWithBooleanUndefined<EV, K> | (K extends keyof V ? VariantValueWithBooleanUndefined<V, K>[] : never);
+} & ClassProp<SlotsClassValue<S, B> | ClassNameValue>>;
+type TVCompoundSlots<V extends TVVariantsShape, S extends TVSlots, B extends ClassNameValue> = Array<{
+    slots: Array<TVSlotsWithBase<S, B>>;
+} & {
+    [K in keyof V]?: VariantValueWithBooleanUndefined<V, K> | VariantValueWithBooleanUndefined<V, K>[];
+} & ClassProp>;
+type TVDefaultVariants<V extends TVVariantsShape, _S extends TVSlots, EV extends TVVariantsShape, _ES extends TVSlots> = {
+    [K in keyof V | keyof EV]?: VariantValue<V, K> | VariantValue<EV, K>;
 };
-
-export type TVProps<
-  V extends TVVariants<S>,
-  S extends TVSlots,
-  EV extends TVVariants<ES>,
-  ES extends TVSlots,
-> = EV extends undefined
-  ? V extends undefined
-    ? ClassProp<ClassValue>
-    : {
-        [K in keyof V]?: StringToBoolean<keyof V[K]> | undefined;
-      } & ClassProp<ClassValue>
-  : V extends undefined
-    ? {
-        [K in keyof EV]?: StringToBoolean<keyof EV[K]> | undefined;
-      } & ClassProp<ClassValue>
-    : {
-        [K in keyof V | keyof EV]?:
-          | (K extends keyof V ? StringToBoolean<keyof V[K]> : never)
-          | (K extends keyof EV ? StringToBoolean<keyof EV[K]> : never)
-          | undefined;
-      } & ClassProp<ClassValue>;
-
-export type TVVariantKeys<V extends TVVariants<S>, S extends TVSlots> = V extends Object
-  ? Array<keyof V>
-  : undefined;
-
-export type TVReturnProps<
-  V extends TVVariants<S>,
-  S extends TVSlots,
-  B extends ClassValue,
-  EV extends TVVariants<ES>,
-  ES extends TVSlots,
-  // @ts-expect-error
-  E extends TVReturnType = undefined,
-> = {
-  extend: E;
-  base: B;
-  slots: S;
-  variants: V;
-  defaultVariants: TVDefaultVariants<V, S, EV, ES>;
-  compoundVariants: TVCompoundVariants<V, S, B, EV, ES>;
-  compoundSlots: TVCompoundSlots<V, S, B>;
-  variantKeys: TVVariantKeys<V, S>;
+type TVScreenPropsValue<V extends TVVariantsShape, _S extends TVSlots, K extends keyof V> = {
+    [Screen in TVScreens]?: StringToBoolean<keyof V[K]>;
 };
-
-type HasSlots<S extends TVSlots, ES extends TVSlots> = S extends undefined
-  ? ES extends undefined
-    ? false
-    : true
-  : true;
-
-export type TVReturnType<
-  V extends TVVariants<S>,
-  S extends TVSlots,
-  B extends ClassValue,
-  EV extends TVVariants<ES>,
-  ES extends TVSlots,
-  // @ts-expect-error
-  E extends TVReturnType = undefined,
-> = {
-  (props?: TVProps<V, S, EV, ES>): HasSlots<S, ES> extends true
-    ? {
-        [K in keyof (ES extends undefined ? {} : ES)]: (
-          slotProps?: TVProps<V, S, EV, ES>,
-        ) => string;
-      } & {
+type TVProps<V extends TVVariantsShape, _S extends TVSlots, EV extends TVVariantsShape, _ES extends TVSlots> = EV extends undefined ? V extends undefined ? ClassProp<ClassNameValue> : {
+    [K in keyof V]?: VariantValue<V, K> | undefined;
+} & ClassProp<ClassNameValue> : V extends undefined ? {
+    [K in keyof EV]?: VariantValue<EV, K> | undefined;
+} & ClassProp<ClassNameValue> : {
+    [K in keyof V | keyof EV]?: VariantValue<V, K> | VariantValue<EV, K> | undefined;
+} & ClassProp<ClassNameValue>;
+type TVVariantKeys<V extends TVVariantsShape, _S extends TVSlots> = V extends undefined ? undefined : Array<keyof V>;
+type TVMergedVariants<V extends TVVariantsShape, EV extends TVVariantsShape> = V extends undefined ? EV : EV extends undefined ? V : V & EV;
+type TVMergedSlots<S extends TVSlots, ES extends TVSlots> = S extends undefined ? ES : ES extends undefined ? S : S & ES;
+interface TVReturnProps<V extends TVVariantsShape, S extends TVSlots, B extends ClassNameValue, EV extends TVVariantsShape, ES extends TVSlots, E extends TVReturnTypeLike<any, any> | undefined = undefined> {
+    extend: E;
+    base: B;
+    slots: TVMergedSlots<S, ES>;
+    variants: TVMergedVariants<V, EV>;
+    defaultVariants: TVDefaultVariants<V, S, EV, ES>;
+    compoundVariants: TVCompoundVariants<V, S, B, EV, ES>;
+    compoundSlots: TVCompoundSlots<V, S, B>;
+    variantKeys: TVVariantKeys<TVMergedVariants<V, EV>, TVMergedSlots<S, ES>>;
+}
+type HasSlots<S extends TVSlots, ES extends TVSlots> = S extends undefined ? ES extends undefined ? false : true : true;
+interface TVReturnType<V extends TVVariantsShape, S extends TVSlots, B extends ClassNameValue, EV extends TVVariantsShape, ES extends TVSlots, E extends TVReturnTypeLike<any, any> | undefined = undefined> extends TVReturnProps<V, S, B, EV, ES, E> {
+    (props?: TVProps<V, S, EV, ES>): HasSlots<S, ES> extends true ? {
+        [K in keyof (ES extends undefined ? {} : ES)]: (slotProps?: TVProps<V, S, EV, ES>) => string;
+    } & {
         [K in keyof (S extends undefined ? {} : S)]: (slotProps?: TVProps<V, S, EV, ES>) => string;
-      } & {
-        [K in TVSlotsWithBase<{}, B>]: (slotProps?: TVProps<V, S, EV, ES>) => string;
-      }
-    : string;
-} & TVReturnProps<V, S, B, EV, ES, E>;
-
-export type TV = {
-  <
-    V extends TVVariants<S, B, EV>,
-    CV extends TVCompoundVariants<V, S, B, EV, ES>,
-    DV extends TVDefaultVariants<V, S, EV, ES>,
-    B extends ClassValue = undefined,
-    S extends TVSlots = undefined,
-    // @ts-expect-error
-    E extends TVReturnType = TVReturnType<
-      V,
-      S,
-      B,
-      // @ts-expect-error
-      EV extends undefined ? {} : EV,
-      // @ts-expect-error
-      ES extends undefined ? {} : ES
-    >,
-    EV extends TVVariants<ES, B, E["variants"], ES> = E["variants"],
-    ES extends TVSlots = E["slots"] extends TVSlots ? E["slots"] : undefined,
-  >(
-    options: {
-      /**
-       * Extend allows for easy composition of components.
-       * @see https://www.tailwind-variants.org/docs/composing-components
-       */
-      extend?: E;
-      /**
-       * Base allows you to set a base class for a component.
-       */
-      base?: B;
-      /**
-       * Slots allow you to separate a component into multiple parts.
-       * @see https://www.tailwind-variants.org/docs/slots
-       */
-      slots?: S;
-      /**
-       * Variants allow you to create multiple versions of the same component.
-       * @see https://www.tailwind-variants.org/docs/variants#adding-variants
-       */
-      variants?: V;
-      /**
-       * Compound variants allow you to apply classes to multiple variants at once.
-       * @see https://www.tailwind-variants.org/docs/variants#compound-variants
-       */
-      compoundVariants?: CV;
-      /**
-       * Compound slots allow you to apply classes to multiple slots at once.
-       */
-      compoundSlots?: TVCompoundSlots<V, S, B>;
-      /**
-       * Default variants allow you to set default variants for a component.
-       * @see https://www.tailwind-variants.org/docs/variants#default-variants
-       */
-      defaultVariants?: DV;
-    },
+    } & {
+        [K in TVBaseName]: (slotProps?: TVProps<V, S, EV, ES>) => string;
+    } : string;
+}
+type TV = <V extends TVVariants<S, B, EV>, CV extends TVCompoundVariants<V, S, B, EV, ES>, DV extends TVDefaultVariants<V, S, EV, ES>, B extends ClassNameValue = undefined, S extends TVSlots = undefined, E extends TVReturnTypeLike<any, any> = TVReturnTypeLike<V, S>, EV extends TVVariants<ES, B, E["variants"], ES> = E["variants"], ES extends TVSlots = E["slots"] extends TVSlots ? E["slots"] : undefined>(options: {
     /**
-     * The config object allows you to modify the default configuration.
-     * @see https://www.tailwind-variants.org/docs/api-reference#config-optional
+     * Extend allows for easy composition of components.
+     * @see https://www.tailwind-variants.org/docs/composing-components
      */
-    config?: TVConfig,
-  ): TVReturnType<V, S, B, EV, ES, E>;
-};
-
-export type TVLite = {
-  <
-    V extends TVVariants<S, B, EV>,
-    CV extends TVCompoundVariants<V, S, B, EV, ES>,
-    DV extends TVDefaultVariants<V, S, EV, ES>,
-    B extends ClassValue = undefined,
-    S extends TVSlots = undefined,
-    // @ts-expect-error
-    E extends TVReturnType = TVReturnType<
-      V,
-      S,
-      B,
-      // @ts-expect-error
-      EV extends undefined ? {} : EV,
-      // @ts-expect-error
-      ES extends undefined ? {} : ES
-    >,
-    EV extends TVVariants<ES, B, E["variants"], ES> = E["variants"],
-    ES extends TVSlots = E["slots"] extends TVSlots ? E["slots"] : undefined,
-  >(options: {
+    extend?: E;
+    /**
+     * Base allows you to set a base class for a component.
+     */
+    base?: B;
+    /**
+     * Slots allow you to separate a component into multiple parts.
+     * @see https://www.tailwind-variants.org/docs/slots
+     */
+    slots?: S;
+    /**
+     * Variants allow you to create multiple versions of the same component.
+     * @see https://www.tailwind-variants.org/docs/variants#adding-variants
+     */
+    variants?: V;
+    /**
+     * Compound variants allow you to apply classes to multiple variants at once.
+     * @see https://www.tailwind-variants.org/docs/variants#compound-variants
+     */
+    compoundVariants?: CV;
+    /**
+     * Compound slots allow you to apply classes to multiple slots at once.
+     */
+    compoundSlots?: TVCompoundSlots<V, S, B>;
+    /**
+     * Default variants allow you to set default variants for a component.
+     * @see https://www.tailwind-variants.org/docs/variants#default-variants
+     */
+    defaultVariants?: DV;
+}, 
+/**
+ * The config object allows you to modify the default configuration.
+ * @see https://www.tailwind-variants.org/docs/api-reference#config-optional
+ */
+config?: TVConfig) => TVReturnType<V, S, B, EV, ES, E>;
+type TVLite = <V extends TVVariants<S, B, EV>, CV extends TVCompoundVariants<V, S, B, EV, ES>, DV extends TVDefaultVariants<V, S, EV, ES>, B extends ClassNameValue = undefined, S extends TVSlots = undefined, E extends TVReturnTypeLike<any, any> = TVReturnTypeLike<V, S>, EV extends TVVariants<ES, B, E["variants"], ES> = E["variants"], ES extends TVSlots = E["slots"] extends TVSlots ? E["slots"] : undefined>(options: {
     /**
      * Extend allows for easy composition of components.
      * @see https://www.tailwind-variants.org/docs/composing-components
@@ -328,10 +162,7 @@ export type TVLite = {
      * @see https://www.tailwind-variants.org/docs/variants#default-variants
      */
     defaultVariants?: DV;
-  }): TVReturnType<V, S, B, EV, ES, E>;
-};
+}) => TVReturnType<V, S, B, EV, ES, E>;
+type VariantProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className">;
 
-export type VariantProps<Component extends (...args: any) => any> = Omit<
-  OmitUndefined<Parameters<Component>[0]>,
-  "class" | "className"
->;
+export { type ClassProp, ClassNameValue as ClassValue, type CnOptions, type CnReturn, type OmitUndefined, type StringToBoolean, type TV, type TVCompoundSlots, type TVCompoundVariants, type TVDefaultVariants, type TVLite, type TVProps, type TVReturnProps, type TVReturnType, type TVReturnTypeLike, type TVScreenPropsValue, type TVVariantKeys, type TVVariants, type VariantProps, type WithInitialScreen, type isTrueOrArray };

package/dist/types.js

@@ -0,0 +1 @@
+

package/dist/utils.cjs

@@ -1,50 +1,50 @@
 'use strict';
 
-var chunk2JY7EID6_cjs = require('./chunk-2JY7EID6.cjs');
+var chunk2BFDQGZN_cjs = require('./chunk-2BFDQGZN.cjs');
 
 
 
 Object.defineProperty(exports, "cx", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.cx; }
+  get: function () { return chunk2BFDQGZN_cjs.cx; }
 });
 Object.defineProperty(exports, "falsyToString", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.falsyToString; }
+  get: function () { return chunk2BFDQGZN_cjs.falsyToString; }
 });
 Object.defineProperty(exports, "flat", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.flat; }
+  get: function () { return chunk2BFDQGZN_cjs.flat; }
 });
 Object.defineProperty(exports, "flatArray", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.flatArray; }
+  get: function () { return chunk2BFDQGZN_cjs.flatArray; }
 });
 Object.defineProperty(exports, "flatMergeArrays", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.flatMergeArrays; }
+  get: function () { return chunk2BFDQGZN_cjs.flatMergeArrays; }
 });
 Object.defineProperty(exports, "isBoolean", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.isBoolean; }
+  get: function () { return chunk2BFDQGZN_cjs.isBoolean; }
 });
 Object.defineProperty(exports, "isEmptyObject", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.isEmptyObject; }
+  get: function () { return chunk2BFDQGZN_cjs.isEmptyObject; }
 });
 Object.defineProperty(exports, "isEqual", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.isEqual; }
+  get: function () { return chunk2BFDQGZN_cjs.isEqual; }
 });
 Object.defineProperty(exports, "joinObjects", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.joinObjects; }
+  get: function () { return chunk2BFDQGZN_cjs.joinObjects; }
 });
 Object.defineProperty(exports, "mergeObjects", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.mergeObjects; }
+  get: function () { return chunk2BFDQGZN_cjs.mergeObjects; }
 });
 Object.defineProperty(exports, "removeExtraSpaces", {
   enumerable: true,
-  get: function () { return chunk2JY7EID6_cjs.removeExtraSpaces; }
+  get: function () { return chunk2BFDQGZN_cjs.removeExtraSpaces; }
 });

package/dist/utils.d.cts

@@ -0,0 +1,16 @@
+import { CnOptions, CnReturn } from './types.cjs';
+import './config-bO3A8WhU.cjs';
+
+declare const removeExtraSpaces: (str: string) => string;
+declare const cx: <T extends CnOptions>(...classnames: T) => CnReturn;
+declare const falsyToString: <T>(value: T) => T | string;
+declare const isEmptyObject: (obj: unknown) => boolean;
+declare const isEqual: (obj1: object, obj2: object) => boolean;
+declare const isBoolean: (value: unknown) => boolean;
+declare const joinObjects: <T extends Record<string, unknown>, U extends Record<string, unknown>>(obj1: T, obj2: U) => T & U;
+declare const flat: <T>(arr: unknown[], target: T[]) => void;
+declare function flatArray<T>(arr: unknown[]): T[];
+declare const flatMergeArrays: <T>(...arrays: unknown[][]) => T[];
+declare const mergeObjects: <T extends object, U extends object>(obj1: T, obj2: U) => Record<string, unknown>;
+
+export { cx, falsyToString, flat, flatArray, flatMergeArrays, isBoolean, isEmptyObject, isEqual, joinObjects, mergeObjects, removeExtraSpaces };

package/dist/utils.d.ts

@@ -1,32 +1,16 @@
-import type {CnOptions, CnReturn} from "./types.d.ts";
-
-export declare const falsyToString: <T>(value: T) => T | string;
-
-export declare const isEmptyObject: (obj: unknown) => boolean;
-
-export declare const flatArray: <T>(array: unknown[]) => T[];
-
-export declare const flatMergeArrays: <T>(...arrays: unknown[][]) => T[];
-
-export declare const mergeObjects: <T extends object, U extends object>(
-  obj1: T,
-  obj2: U,
-) => Record<string, unknown>;
-
-export declare const removeExtraSpaces: (str: string) => string;
-
-export declare const isEqual: (obj1: object, obj2: object) => boolean;
-
-export declare const isBoolean: (value: unknown) => boolean;
-
-export declare const joinObjects: <
-  T extends Record<string, unknown>,
-  U extends Record<string, unknown>,
->(
-  obj1: T,
-  obj2: U,
-) => T & U;
-
-export declare const flat: <T>(arr: unknown[], target: T[]) => void;
-
-export declare const cx: <T extends CnOptions>(...classes: T) => CnReturn;
+import { CnOptions, CnReturn } from './types.js';
+import './config-bO3A8WhU.js';
+
+declare const removeExtraSpaces: (str: string) => string;
+declare const cx: <T extends CnOptions>(...classnames: T) => CnReturn;
+declare const falsyToString: <T>(value: T) => T | string;
+declare const isEmptyObject: (obj: unknown) => boolean;
+declare const isEqual: (obj1: object, obj2: object) => boolean;
+declare const isBoolean: (value: unknown) => boolean;
+declare const joinObjects: <T extends Record<string, unknown>, U extends Record<string, unknown>>(obj1: T, obj2: U) => T & U;
+declare const flat: <T>(arr: unknown[], target: T[]) => void;
+declare function flatArray<T>(arr: unknown[]): T[];
+declare const flatMergeArrays: <T>(...arrays: unknown[][]) => T[];
+declare const mergeObjects: <T extends object, U extends object>(obj1: T, obj2: U) => Record<string, unknown>;
+
+export { cx, falsyToString, flat, flatArray, flatMergeArrays, isBoolean, isEmptyObject, isEqual, joinObjects, mergeObjects, removeExtraSpaces };

package/dist/utils.js

@@ -1 +1 @@
-export { cx, falsyToString, flat, flatArray, flatMergeArrays, isBoolean, isEmptyObject, isEqual, joinObjects, mergeObjects, removeExtraSpaces } from './chunk-LQJYWU4O.js';
+export { cx, falsyToString, flat, flatArray, flatMergeArrays, isBoolean, isEmptyObject, isEqual, joinObjects, mergeObjects, removeExtraSpaces } from './chunk-OYFAXDFZ.js';