praxis-kit 2.0.0 → 2.0.1

package/dist/contract/index.d.ts

@@ -1,4 +1,4 @@
-import { ReadonlyDeep } from 'type-fest';
+import { RequireAtLeastOne, Simplify, ReadonlyDeep } from 'type-fest';
 
 type AnyRecord = Record<string, unknown>;
 
@@ -11,10 +11,18 @@ type KnownAriaRole = (typeof KNOWN_ARIA_ROLES)[number];
 
 type AriaRole = KnownAriaRole | (string & {});
 
+type ClassName = string | string[];
+
+type EmptyRecord = Record<never, never>;
+
 type IntrinsicProps = AnyRecord & {
     role?: AriaRole;
 };
 
+type NonEmptyArray<T> = [T, ...T[]];
+
+type TagMap = Partial<Record<IntrinsicTag | (string & {}), ClassName>>;
+
 type StrictMode = boolean | 'warn' | 'async-warn' | 'throw';
 
 type CardinalityInput = {
@@ -43,6 +51,99 @@ type ValidResult = {
     valid: true;
 };
 
+type StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;
+
+type VariantValue = string | string[];
+
+type VariantStates<K extends string = string> = Record<K, VariantValue>;
+
+type VariantMap<V extends string = string, K extends string = string> = Record<V, VariantStates<K>>;
+
+type VariantKey<V extends VariantMap, K extends keyof V> = StringToBoolean<keyof V[K] & string>;
+
+type RequireAtLeastOneIfNotEmpty<T> = keyof T extends never ? EmptyRecord : RequireAtLeastOne<T>;
+type CompoundVariantConditionValue<V extends VariantMap, K extends keyof V> = VariantKey<V, K> | NonEmptyArray<VariantKey<V, K>>;
+type CompoundVariantConditions<V extends VariantMap> = Simplify<{
+    [K in keyof V]: CompoundVariantConditionValue<V, K>;
+}>;
+type CompoundVariantRequiredConditions<V extends VariantMap> = RequireAtLeastOneIfNotEmpty<CompoundVariantConditions<V>>;
+type CompoundVariantBase<V extends VariantMap> = keyof V extends never ? EmptyRecord : CompoundVariantRequiredConditions<V>;
+type CompoundVariant<V extends VariantMap> = CompoundVariantBase<V> & {
+    class: VariantValue;
+};
+
+interface CVACompounds<V extends VariantMap> {
+    compoundVariants?: readonly CompoundVariant<V>[];
+}
+
+/** The full optional prop surface exposed to callers for a given variant map. */
+type VariantProps<V extends VariantMap> = {
+    [K in keyof V]?: VariantKey<V, K>;
+};
+type DefaultVariants<V extends VariantMap> = {
+    [K in keyof V]?: VariantKey<V, K>;
+};
+
+interface CVADefaults<V extends VariantMap> {
+    defaultVariants?: DefaultVariants<V>;
+}
+
+interface CVAVariants<V extends VariantMap> {
+    variants?: V;
+}
+
+/**
+ * A partial selection of variant states authored at factory definition time.
+ *
+ * Uses `keyof V[K]` directly (not `VariantKey`) so TypeScript can eagerly
+ * resolve the union at constraint-check time without deferred conditional types.
+ */
+type VariantSelection<V extends VariantMap> = {
+    [K in keyof V]?: keyof V[K];
+};
+
+/**
+ * A static, immutable map of named presets to partial variant selections.
+ *
+ * Presets are named bundles of variant props that callers activate by key,
+ * avoiding the need to repeat variant combinations at each call site.
+ */
+type PresetMap<V extends VariantMap = VariantMap> = Readonly<Record<string, VariantSelection<V>>>;
+
+type PresetTarget<TVariants extends VariantMap = VariantMap> = VariantSelection<TVariants>;
+
+interface BaseClassOptions {
+    baseClassName?: ClassName;
+}
+
+type ClassPipelineFn = (tag: unknown, props: AnyRecord, className?: ClassName, variantKey?: string) => string;
+
+interface PresetOptions<TVariants extends VariantMap = VariantMap> {
+    presetMap?: Record<string, PresetTarget<TVariants>>;
+}
+
+interface TagMapOptions {
+    tagMap?: TagMap;
+}
+
+type CompositionOptions<TVariants extends VariantMap = VariantMap> = Simplify<TagMapOptions & PresetOptions<TVariants>>;
+
+type CVASystemOptions<TVariants extends VariantMap = VariantMap> = Simplify<CVAVariants<TVariants> & CVADefaults<TVariants> & CVACompounds<TVariants>>;
+
+type StyleOptions<TVariants extends VariantMap = VariantMap> = Simplify<BaseClassOptions & CVASystemOptions<TVariants>>;
+
+type ClassPipelineOptions<TVariants extends VariantMap = VariantMap> = Simplify<StyleOptions<TVariants> & CompositionOptions<TVariants>>;
+
+type OwnedPropKeys = ReadonlySet<string>;
+
+type ClassPlugin<TProps extends AnyRecord = EmptyRecord> = Readonly<{
+    pipeline: ClassPipelineFn;
+    ownedKeys?: OwnedPropKeys;
+    readonly _pluginProps?: TProps;
+}>;
+
+type ClassPluginFactory<TProps extends AnyRecord = EmptyRecord> = <V extends VariantMap>(options: ClassPipelineOptions<V>, strict: StrictMode) => ClassPlugin<TProps>;
+
 type AriaContext = {
     readonly tag: IntrinsicTag;
     readonly implicitRole: AriaRole | undefined;
@@ -100,6 +201,30 @@ type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
     readonly allowedAs?: readonly TAllowed[];
 };
 
+type StylingOptions<V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = {
+    readonly base?: ClassName;
+    readonly variants?: V;
+    readonly defaults?: Partial<VariantProps<V>>;
+    readonly compounds?: readonly CompoundVariant<V>[];
+    readonly presets?: TPreset;
+    readonly tags?: Readonly<TagMap>;
+    readonly plugin?: ClassPluginFactory<TPluginProps>;
+    readonly precomputedClasses?: Readonly<Record<string, string>>;
+};
+
+type NormalizeFn<Props extends AnyRecord = AnyRecord> = {
+    normalize(props: Readonly<Props & IntrinsicProps>): Props & IntrinsicProps;
+}['normalize'];
+type AnyFactoryOptions = FactoryOptions<ElementType, AnyRecord, VariantMap, PresetMap<VariantMap>, AnyRecord>;
+type FactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TAllowed extends ElementType = ElementType> = {
+    readonly tag?: TDefault;
+    readonly name?: string;
+    readonly defaults?: Partial<NoInfer<Props>>;
+    readonly normalize?: NormalizeFn<NoInfer<Props>>;
+    readonly styling?: StylingOptions<V, TPreset, TPluginProps>;
+    readonly enforcement?: EnforcementOptions<TAllowed>;
+};
+
 declare const activeProps: PropNormalizer;
 
 declare const disabledProps: PropNormalizer;
@@ -127,4 +252,4 @@ declare const selectedContract: EnforcementOptions;
 
 declare function mergeContracts(...contracts: readonly EnforcementOptions[]): EnforcementOptions;
 
-export { type PropNormalizer, activeContract, activeProps, disabledContract, disabledProps, expandedContract, expandedProps, invalidContract, invalidProps, loadingContract, loadingProps, mergeContracts, pressedContract, pressedProps, readonlyContract, readonlyProps, selectedContract, selectedProps };
+export { type AnyFactoryOptions, type PropNormalizer, activeContract, activeProps, disabledContract, disabledProps, expandedContract, expandedProps, invalidContract, invalidProps, loadingContract, loadingProps, mergeContracts, pressedContract, pressedProps, readonlyContract, readonlyProps, selectedContract, selectedProps };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-kit",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "type": "module",
   "exports": {
     "./react": {
@@ -130,8 +130,8 @@
     "vite": "^8.0.16",
     "vue": "^3.5.38",
     "@praxis-kit/adapter-utils": "0.0.0",
-    "@praxis-kit/shared": "0.8.0-beta.4",
-    "@praxis-kit/core": "0.8.0-beta.4"
+    "@praxis-kit/core": "0.8.0-beta.4",
+    "@praxis-kit/shared": "0.8.0-beta.4"
   },
   "publishConfig": {
     "access": "public"