magnaui 0.1.0

package/dist/utils/cn.d.ts

@@ -0,0 +1,18 @@
+import { type ClassValue } from "clsx";
+export type { ClassValue } from "clsx";
+export declare const twMergeConfig: {
+    extend: {
+        classGroups: {
+            'font-size': {
+                text: string[];
+            }[];
+            shadow: {
+                shadow: string[];
+            }[];
+            rounded: {
+                rounded: string[];
+            }[];
+        };
+    };
+};
+export declare const cn: (...values: ClassValue[]) => string;

package/dist/utils/cn.js

@@ -0,0 +1,14 @@
+import { clsx } from "clsx";
+import { extendTailwindMerge } from "tailwind-merge";
+import { texts, shadows, borderRadii } from "../design/theme.js";
+export const twMergeConfig = {
+    extend: {
+        classGroups: {
+            'font-size': [{ text: Object.keys(texts) }],
+            shadow: [{ shadow: Object.keys(shadows) }],
+            rounded: [{ rounded: Object.keys(borderRadii) }],
+        },
+    },
+};
+const resolveClasses = extendTailwindMerge(twMergeConfig);
+export const cn = (...values) => resolveClasses(clsx(values));

package/dist/utils/polymorphic.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentPropsWithRef, ComponentPropsWithoutRef, ElementType, ReactNode } from "react";
+export type PolymorphicComponentProps<T extends ElementType, P = object> = P & {
+    as?: T;
+    children?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<T>, keyof P | 'as'>;
+export type PolymorphicRef<T extends ElementType> = ComponentPropsWithRef<T>['ref'];
+export type PolymorphicComponentPropsWithRef<T extends ElementType, P = object> = PolymorphicComponentProps<T, P> & {
+    ref?: PolymorphicRef<T>;
+};
+export type PolymorphicComponent<P> = <T extends ElementType>(props: PolymorphicComponentPropsWithRef<T, P>) => ReactNode;

package/dist/utils/polymorphic.js

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

package/dist/utils/tv.d.ts

@@ -0,0 +1,18 @@
+export type { VariantProps, ClassValue } from "../vendor/tailwind-variants/index.js";
+export declare const tv: import("../vendor/tailwind-variants/index.js").CreateTV<{
+    twMergeConfig: {
+        extend: {
+            classGroups: {
+                'font-size': {
+                    text: string[];
+                }[];
+                shadow: {
+                    shadow: string[];
+                }[];
+                rounded: {
+                    rounded: string[];
+                }[];
+            };
+        };
+    };
+}>;

package/dist/utils/tv.js

@@ -0,0 +1,5 @@
+import { createTV } from "tailwind-variants";
+import { twMergeConfig } from "./cn.js";
+export const tv = createTV({
+    twMergeConfig,
+});

package/dist/vendor/tailwind-variants/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Tailwid Variants
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/vendor/tailwind-variants/config.d.ts

@@ -0,0 +1,38 @@
+import type {extendTailwindMerge} from "tailwind-merge";
+import type {TVVariants} from "./index.js";
+import type {TVGeneratedScreens} from "./generated.js";
+
+type MergeConfig = Parameters<typeof extendTailwindMerge>[0];
+type LegacyMergeConfig = Extract<MergeConfig, {extend?: unknown}>["extend"];
+
+export type TWMConfig = {
+  /**
+   * Whether to merge the class names with `tailwind-merge` library.
+   * It's avoid to have duplicate tailwind classes. (Recommended)
+   * @see https://github.com/dcastil/tailwind-merge/blob/v2.2.0/README.md
+   * @default true
+   */
+  twMerge?: boolean;
+  /**
+   * The config object for `tailwind-merge` library.
+   * @see https://github.com/dcastil/tailwind-merge/blob/v2.2.0/docs/configuration.md
+   */
+  twMergeConfig?: MergeConfig & LegacyMergeConfig;
+};
+
+export type TVConfig<
+  // @ts-expect-error
+  V extends TVVariants | undefined = undefined,
+  // @ts-expect-error
+  EV extends TVVariants | undefined = undefined,
+> = {
+  /**
+   * Whether to enable responsive variant transform.
+   * Which variants or screens(breakpoints) for responsive variant transform.
+   * @default false
+   */
+  responsiveVariants?:
+    | boolean
+    | TVGeneratedScreens[]
+    | {[K in keyof V | keyof EV]?: boolean | TVGeneratedScreens[]};
+} & TWMConfig;

package/dist/vendor/tailwind-variants/generated.d.ts

@@ -0,0 +1,3 @@
+// Equivalent to tailwind-variants 0.2.1 TVGeneratedScreens at package build time.
+// Materialized to avoid importing a consumer-specific Tailwind config API.
+export type TVGeneratedScreens = "2xl" | "lg" | "md" | "sm" | "xl";

package/dist/vendor/tailwind-variants/index.d.ts

@@ -0,0 +1,370 @@
+import type {ClassNameValue as ClassValue} from "tailwind-merge";
+
+import {TVConfig, TWMConfig} from "./config.js";
+import {TVGeneratedScreens} from "./generated.js";
+
+/**
+ * ----------------------------------------
+ * Base Types
+ * ----------------------------------------
+ */
+
+export type {ClassValue};
+
+export type ClassProp<V extends unknown = ClassValue> =
+  | {class?: V; className?: never}
+  | {class?: never; className?: V};
+
+type TVBaseName = "base";
+
+type TVScreens = "initial" | TVGeneratedScreens;
+
+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;
+
+export type CnOptions = ClassValue[];
+
+export type CnReturn = string | undefined;
+
+export declare const cnBase: <T extends CnOptions>(...classes: T) => CnReturn;
+
+export declare const cn: <T extends CnOptions>(...classes: T) => (config?: TWMConfig) => CnReturn;
+
+// 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;
+};
+
+type TVVariantsDefault<S extends TVSlots, B extends ClassValue> = S extends undefined
+  ? {}
+  : {
+      [key: string]: {
+        [key: string]: S extends TVSlots ? SlotsClassValue<S, B> | ClassValue : ClassValue;
+      };
+    };
+
+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,
+  C extends TVConfig,
+> = C["responsiveVariants"] extends string[]
+  ? {
+      [Screen in WithInitialScreen<C["responsiveVariants"]>[number]]?: StringToBoolean<keyof V[K]>;
+    }
+  : {
+      [Screen in TVScreens]?: StringToBoolean<keyof V[K]>;
+    };
+
+export type TVProps<
+  V extends TVVariants<S>,
+  S extends TVSlots,
+  C extends TVConfig<V, EV>,
+  EV extends TVVariants<ES>,
+  ES extends TVSlots,
+> = EV extends undefined
+  ? V extends undefined
+    ? ClassProp<ClassValue>
+    : {
+        [K in keyof V]?: isTrueOrArray<C["responsiveVariants"]> extends true
+          ? StringToBoolean<keyof V[K]> | TVScreenPropsValue<V, S, K, C> | undefined
+          : StringToBoolean<keyof V[K]> | undefined;
+      } & ClassProp<ClassValue>
+  : V extends undefined
+  ? {
+      [K in keyof EV]?: isTrueOrArray<C["responsiveVariants"]> extends true
+        ? StringToBoolean<keyof EV[K]> | TVScreenPropsValue<EV, ES, K, C> | undefined
+        : StringToBoolean<keyof EV[K]> | undefined;
+    } & ClassProp<ClassValue>
+  : {
+      [K in keyof V | keyof EV]?: isTrueOrArray<C["responsiveVariants"]> extends true
+        ?
+            | (K extends keyof V ? StringToBoolean<keyof V[K]> : never)
+            | (K extends keyof EV ? StringToBoolean<keyof EV[K]> : never)
+            | TVScreenPropsValue<EV & V, S, K, C>
+            | undefined
+        :
+            | (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 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,
+  C extends TVConfig<V, EV>,
+  EV extends TVVariants<ES>,
+  ES extends TVSlots,
+  // @ts-expect-error
+  E extends TVReturnType = undefined,
+> = {
+  (props?: TVProps<V, S, C, EV, ES>): HasSlots<S, ES> extends true
+    ? {
+        [K in keyof (ES extends undefined ? {} : ES)]: (
+          slotProps?: TVProps<V, S, C, EV, ES>,
+        ) => string;
+      } & {
+        [K in keyof (S extends undefined ? {} : S)]: (
+          slotProps?: TVProps<V, S, C, EV, ES>,
+        ) => string;
+      } & {
+        [K in TVSlotsWithBase<{}, B>]: (slotProps?: TVProps<V, S, C, 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>,
+    C extends TVConfig<V, EV>,
+    B extends ClassValue = undefined,
+    S extends TVSlots = undefined,
+    // @ts-expect-error
+    E extends TVReturnType = TVReturnType<
+      V,
+      S,
+      B,
+      C,
+      // @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;
+    },
+    /**
+     * The config object allows you to modify the default configuration.
+     * @see https://www.tailwind-variants.org/docs/api-reference#config-optional
+     */
+    config?: C,
+  ): TVReturnType<V, S, B, C, EV, ES, E>;
+};
+
+export type CreateTV<RV extends TVConfig["responsiveVariants"] = undefined> = {
+  <
+    V extends TVVariants<S, B, EV>,
+    CV extends TVCompoundVariants<V, S, B, EV, ES>,
+    DV extends TVDefaultVariants<V, S, EV, ES>,
+    C extends TVConfig<V, EV>,
+    B extends ClassValue = undefined,
+    S extends TVSlots = undefined,
+    // @ts-expect-error
+    E extends TVReturnType = TVReturnType<
+      V,
+      S,
+      B,
+      C,
+      // @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;
+    },
+    /**
+     * The config object allows you to modify the default configuration.
+     * @see https://www.tailwind-variants.org/docs/api-reference#config-optional
+     */
+    config?: C,
+  ): TVReturnType<V, S, B, C & RV, EV, ES, E>;
+};
+
+// main function
+export declare const tv: TV;
+
+export declare function createTV<T extends TVConfig["responsiveVariants"]>(
+  config: TVConfig & T,
+): CreateTV<T>;
+
+export declare const defaultConfig: TVConfig;
+
+export type VariantProps<Component extends (...args: any) => any> = Omit<
+  OmitUndefined<Parameters<Component>[0]>,
+  "class" | "className"
+>;

package/docs/implementation-provenance.md

@@ -0,0 +1,96 @@
+# MagnaUI implementation provenance
+
+This record describes the component implementation replacement and the material
+that remains in the repository. It does not change the [MagnaUI Private Use
+License](../LICENSE) or the [third-party notices](../THIRD_PARTY_NOTICES.md).
+
+## Implementation replacement
+
+The base component implementations were rewritten while retaining the public
+compound component APIs, the `magnaui` facade, and the MagnaUI design contract:
+semantic colors, typography, dimensions, corner radii, spacing, and interaction
+states. Existing source, documentation examples, and design snapshots were used
+to understand those contracts.
+
+The replacement includes context-based sharing between component slots, typed
+slot recipes, revised utilities, native OTP fields, tab geometry observation, and
+an external notification store. Installed Radix primitives continue to provide
+accessible selection, keyboard navigation, focus management, and portals; cmdk
+continues to provide command-menu behavior. Select retains its custom scroll
+viewport and thumb. These changes replace implementation structure without
+introducing a new visual design.
+
+This was **not a clean-room implementation**: the previous source was inspected.
+A rewrite, different architecture, or new branding is not proof of exclusive
+ownership or proof that no protected material remains. This record therefore
+does not certify the repository as entirely Magna-owned.
+
+## Design and artwork retained
+
+The supplied Figma design includes inherited structure, Magna modifications, and
+additional images. The checked-in [variable snapshot](../design/figma-tokens.json),
+[style snapshot](../design/figma-styles.json), and
+[design review](figma-review.md) record implementation inputs; they do not establish
+ownership or grant separate rights to all designs or images.
+
+The following artwork modules were deliberately left unchanged in this
+replacement:
+
+- [`avatar-empty-icons.tsx`](../components/ui/avatar-empty-icons.tsx)
+- [`svg-rating-icons.tsx`](../components/ui/svg-rating-icons.tsx)
+
+The artwork under [`public/magna`](../public/magna) and its
+[asset manifest](../design/assets.json) are also retained. Exporting or including
+an image from Figma does not itself establish that the image is exclusively
+owned by Magna. Existing asset notices and applicable source permissions remain
+in effect; this replacement does not remove or reassign them.
+
+## Notices and dependencies
+
+The original MIT copyright and permission notice is preserved verbatim in
+[THIRD_PARTY_NOTICES.md](../THIRD_PARTY_NOTICES.md). It continues to accompany
+covered pre-existing material and any retained portions. Private-use terms apply
+only within the scope stated in [LICENSE](../LICENSE).
+
+React, React DOM, Radix, cmdk, Remix Icon, Next.js, Tailwind, and the other installed
+packages retain their own licenses and notices. The [package manifest](../package.json)
+and [lockfile](../pnpm-lock.yaml) identify the dependency set. Component source
+replacement does not relicense these dependencies, bundled fonts, or assets.
+The `private` and `UNLICENSED` package fields do not transfer third-party rights.
+
+## Verification recorded
+
+The following checks passed during the replacement:
+
+| Check | Scope |
+| --- | --- |
+| `pnpm exec tsc --noEmit` | TypeScript contracts across the project |
+| `pnpm build` | Production compilation, project lint, type validation, and all static routes |
+| `node scripts/verify-library.mjs` | 53 complete assets, 40 applications, 386 token names across 20 theme combinations, 72 desktop states, and Magna control radii |
+| Targeted OTP handler checks | Repeated-digit focus advance, blocked spin/space keys, one-character replacement, mobile deletion, numeric paste, disabled fields, and consumer-cancelled paste |
+| Targeted notification contract checks | Single notification, update, targeted dismissal, removal, and the imperative handle |
+
+## Browser comparison
+
+Compared the replacement with the unchanged baseline documentation at a 1280px
+viewport width. All 59 default previews rendered without browser warnings or
+errors. Matching text, inputs, images, and icons were compared for position,
+dimensions, font metrics, color, background, radius, and shadow with a 0.8px
+geometry tolerance. Divider and tag differences found during that pass were
+corrected and rechecked. Some SVG control marks became CSS shapes, and OTP fields
+have clearer accessible labels; these were reviewed separately.
+
+Eight representative previews were also compared in dark mode: Button,
+FancyButton, Input, Select, Radio, Switch, Alert, and Badge. All measured values
+matched. Screenshot inspection covered FancyButton highlights, the file-format
+icon, and unchecked/checked checkbox states in light and dark themes.
+
+Browser interaction checks covered checkbox keyboard activation, OTP typing,
+paste, backspace and disabled fields, Select keyboard selection, dialog Escape
+and focus restoration, and notification display and dismissal. Focused source
+checks also covered tab indicator movement, notification handle retention,
+nested `asChild`, and polymorphic children types.
+
+These checks cover representative states, not every variant, browser, viewport,
+animation frame, or accessibility workflow. They do not constitute a pixel-diff
+guarantee or determine ownership.