buridan-create 0.1.0__tar.gz

buridan_create-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+.states
+.web
+assets/external/
+*.py[cod]
+*.db
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

buridan_create-0.1.0/.python-version

@@ -0,0 +1 @@
+3.11

buridan_create-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: buridan-create
+Version: 0.1.0
+Summary: CLI to initialize Buridan UI design system in Reflex apps
+Requires-Python: >=3.11
+Requires-Dist: reflex>=0.9.3

buridan_create-0.1.0/app/app.py

@@ -0,0 +1,6 @@
+import reflex as rx
+
+from app.templates.mainpage import mainpage
+
+app = rx.App(stylesheets=["globals.css"])
+app.add_page(component=mainpage(), route="/")

buridan_create-0.1.0/app/base_ui/components/base/accordion.py

@@ -0,0 +1,331 @@
+"""Custom Accordion component."""
+
+from typing import Any, Literal
+
+from reflex.components.component import Component, ComponentNamespace
+from reflex.event import EventHandler, passthrough_event_spec
+from reflex.utils.imports import ImportVar
+from reflex.vars.base import Var
+from reflex.vars.object import ObjectVar
+from reflex_components_core.core.foreach import foreach
+from reflex_components_core.el import Div
+
+from ...icons.hugeicon import hi, icon
+from ..base.button import button
+from ..base_ui import PACKAGE_NAME, BaseUIComponent
+
+LiteralOrientation = Literal["horizontal", "vertical"]
+
+ITEMS_TYPE = list[dict[str, str | Component]]
+
+
+class ClassNames:
+    """Class names for accordion components."""
+
+    ROOT = (
+        "flex flex-col justify-center divide-y divide-input overflow-hidden rounded-xl"
+    )
+    ITEM = "not-last:border-b"
+    HEADER = ""
+    TRIGGER = "group relative flex w-full items-center justify-between gap-4 bg-secondary py-2 text-md font-semibold text-secondary-12 transition-colors disabled:cursor-not-allowed disabled:bg-secondary-3 disabled:text-secondary-8 disabled:[&_svg]:text-secondary-8 [&_svg]:text-secondary-11"
+    PANEL = "h-[var(--accordion-panel-height)] overflow-hidden transition-[height] ease-out data-[ending-style]:h-0 data-[starting-style]:h-0"
+    PANEL_DIV = ""
+    TRIGGER_ICON = "size-4 shrink-0 transition-all ease-out group-data-[panel-open]:scale-110 group-data-[panel-open]:rotate-45"
+
+
+class AccordionBaseComponent(BaseUIComponent):
+    """Base component for accordion components."""
+
+    library = f"{PACKAGE_NAME}/accordion"
+
+    @property
+    def import_var(self):
+        """Return the import variable for the accordion component."""
+        return ImportVar(tag="Accordion", package_path="", install=False)
+
+
+class AccordionRoot(AccordionBaseComponent):
+    """Groups all parts of the accordion."""
+
+    tag = "Accordion.Root"
+
+    # The uncontrolled value of the item(s) that should be initially expanded. To render a controlled accordion, use the `value` prop instead.
+    default_value: Var[list[Any]]
+
+    # The controlled value of the item(s) that should be expanded. To render an uncontrolled accordion, use the `default_value` prop instead.
+    value: Var[list[Any]]
+
+    # Event handler called when an accordion item is expanded or collapsed. Provides the new value as an argument.
+    on_value_change: EventHandler[passthrough_event_spec(list[str])]
+
+    # Allows the browser's built-in page search to find and expand the panel contents. Overrides the `keep_mounted` prop and uses `hidden="until-found"` to hide the element without removing it from the DOM. Defaults to False.
+    hidden_until_found: Var[bool]
+
+    # Whether multiple items can be open at the same time. Defaults to True.
+    multiple: Var[bool]
+
+    # Whether the component should ignore user interaction. Defaults to False.
+    disabled: Var[bool]
+
+    # Whether to loop keyboard focus back to the first item when the end of the list is reached while using the arrow keys. Defaults to True.
+    loop_focus: Var[bool]
+
+    # The visual orientation of the accordion. Controls whether roving focus uses left/right or up/down arrow keys. Defaults to 'vertical'.
+    orientation: Var[LiteralOrientation]
+
+    # Whether to keep the element in the DOM while the panel is closed. This prop is ignored when hidden_until_found is used. Defaults to False.
+    keep_mounted: Var[bool]
+
+    # The render prop.
+    render_: Var[Component]
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the accordion root component."""
+        props["data-slot"] = "accordion"
+        cls.set_class_name(ClassNames.ROOT, props)
+        return super().create(*children, **props)
+
+
+class AccordionItem(AccordionBaseComponent):
+    """Groups an accordion header with the corresponding panel."""
+
+    tag = "Accordion.Item"
+
+    # The value that identifies this item.
+    value: Var[str]
+
+    # Event handler called when the panel is opened or closed.
+    on_open_change: EventHandler[passthrough_event_spec(bool)]
+
+    # Whether the component should ignore user interaction. Defaults to False.
+    disabled: Var[bool]
+
+    # The render prop.
+    render_: Var[Component]
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the accordion item component."""
+        props["data-slot"] = "accordion-item"
+        cls.set_class_name(ClassNames.ITEM, props)
+        return super().create(*children, **props)
+
+
+class AccordionHeader(AccordionBaseComponent):
+    """A heading that labels the corresponding panel."""
+
+    tag = "Accordion.Header"
+
+    # The render prop.
+    render_: Var[Component]
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the accordion header component."""
+        props["data-slot"] = "accordion-header"
+        cls.set_class_name(ClassNames.HEADER, props)
+        return super().create(*children, **props)
+
+
+class AccordionTrigger(AccordionBaseComponent):
+    """A button that opens and closes the corresponding panel."""
+
+    tag = "Accordion.Trigger"
+
+    title: Var[str]
+    native_button: Var[bool]
+
+    # Default is None so we can detect overrides
+    render_: Var[Component] = None
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        props["data-slot"] = "accordion-trigger"
+        cls.set_class_name(ClassNames.TRIGGER, props)
+
+        # 1️⃣ If render_ is NOT provided, we must resolve title
+        if "render_" not in props or props["render_"] is None:
+            if "title" not in props:
+                if len(children) == 1 and isinstance(children[0], str):
+                    props["title"] = children[0]
+                elif children:
+                    raise TypeError(
+                        "AccordionTrigger expects a single string child "
+                        "when used without a `title` prop."
+                    )
+                else:
+                    raise ValueError("AccordionTrigger requires a `title`.")
+
+            # 2️⃣ Generate default render_
+            props["render_"] = button(
+                props["title"],
+                hi(
+                    "Add01Icon",
+                    class_name=(
+                        "size-3 transition-transform duration-50 ease-in-out "
+                        "group-aria-[expanded=true]:rotate-45"
+                    ),
+                ),
+                variant="ghost",
+                class_name=(
+                    "w-full flex items-center justify-between group py-2 "
+                    "font-medium !text-sm hover:bg-transparent !px-0"
+                ),
+            )
+
+        # 3️⃣ render_ was supplied → leave it untouched
+        return super().create(*children, **props)
+
+
+class AccordionPanel(AccordionBaseComponent):
+    """A collapsible panel with the accordion item contents."""
+
+    tag = "Accordion.Panel"
+
+    # Allows the browser's built-in page search to find and expand the panel contents. Overrides the `keep_mounted` prop and uses `hidden="until-found"` to hide the element without removing it from the DOM. Defaults to False.
+    hidden_until_found: Var[bool]
+
+    # Whether to keep the element in the DOM while the panel is closed. This prop is ignored when `hidden_until_found` is used. Defaults to False.
+    keep_mounted: Var[bool]
+
+    # The render prop.
+    render_: Var[Component]
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the accordion panel component."""
+        props["data-slot"] = "accordion-panel"
+        cls.set_class_name(ClassNames.PANEL, props)
+        return super().create(*children, **props)
+
+
+class HighLevelAccordion(AccordionRoot):
+    """High level wrapper for the Accordion component."""
+
+    items: Var[ITEMS_TYPE] | ITEMS_TYPE
+
+    _item_props = {"on_open_change", "disabled"}
+    _trigger_props = {"native_button"}
+    _panel_props = {"hidden_until_found", "keep_mounted"}
+
+    @classmethod
+    def create(
+        cls,
+        items: Var[ITEMS_TYPE] | ITEMS_TYPE,
+        **props,
+    ) -> BaseUIComponent:
+        """Create a high level accordion component.
+
+        Args:
+            items: List of dictionaries with 'trigger', 'content', and optional 'value' and 'disabled' keys.
+            **props: Additional properties to apply to the accordion component.
+
+        Returns:
+            The accordion component with all necessary subcomponents.
+        """
+        # Extract props for different parts
+        item_props = {k: props.pop(k) for k in cls._item_props & props.keys()}
+        trigger_props = {k: props.pop(k) for k in cls._trigger_props & props.keys()}
+        panel_props = {k: props.pop(k) for k in cls._panel_props & props.keys()}
+
+        if isinstance(items, Var):
+            accordion_items = foreach(
+                items,
+                lambda item: cls._create_accordion_item_dynamic(
+                    item, item_props, trigger_props, panel_props
+                ),
+            )
+            return AccordionRoot.create(accordion_items, **props)
+        accordion_items = [
+            cls._create_accordion_item(
+                item, index, item_props, trigger_props, panel_props
+            )
+            for index, item in enumerate(items)
+        ]
+        return AccordionRoot.create(*accordion_items, **props)
+
+    @classmethod
+    def _create_trigger_icon(cls) -> Component:
+        """Create the accordion trigger icon."""
+        return icon(
+            "PlusSignIcon",
+            class_name=ClassNames.TRIGGER_ICON,
+            data_slot="accordion-trigger-icon",
+        )
+
+    @classmethod
+    def _create_accordion_item(
+        cls,
+        item: dict[str, str | Component],
+        index: int,
+        item_props: dict,
+        trigger_props: dict,
+        panel_props: dict,
+    ) -> BaseUIComponent:
+        """Create a single accordion item from a dictionary (for normal lists)."""
+        return AccordionItem.create(
+            AccordionHeader.create(
+                AccordionTrigger.create(
+                    item.get("trigger"),
+                    cls._create_trigger_icon(),
+                    **trigger_props,
+                ),
+            ),
+            AccordionPanel.create(
+                Div.create(
+                    item.get("content"),
+                    class_name=ClassNames.PANEL_DIV,
+                    data_slot="accordion-panel-div",
+                ),
+                **panel_props,
+            ),
+            value=item.get("value", f"item-{index + 1}"),
+            disabled=item.get("disabled", False),
+            **item_props,
+        )
+
+    @classmethod
+    def _create_accordion_item_dynamic(
+        cls,
+        item: ObjectVar[dict[str, str | Component]],
+        item_props: dict,
+        trigger_props: dict,
+        panel_props: dict,
+    ) -> BaseUIComponent:
+        """Create a single accordion item from a dictionary (for Var items)."""
+        return AccordionItem.create(
+            AccordionHeader.create(
+                AccordionTrigger.create(
+                    item["trigger"],
+                    cls._create_trigger_icon(),
+                    **trigger_props,
+                ),
+            ),
+            AccordionPanel.create(
+                Div.create(
+                    item["content"],
+                    class_name=ClassNames.PANEL_DIV,
+                    data_slot="accordion-panel-div",
+                ),
+                **panel_props,
+            ),
+            value=item.get("value", ""),
+            disabled=item.get("disabled", False).bool(),
+            **item_props,
+        )
+
+
+class Accordion(ComponentNamespace):
+    """Namespace for Accordion components."""
+
+    root = staticmethod(AccordionRoot.create)
+    item = staticmethod(AccordionItem.create)
+    header = staticmethod(AccordionHeader.create)
+    trigger = staticmethod(AccordionTrigger.create)
+    panel = staticmethod(AccordionPanel.create)
+    class_names = ClassNames
+    __call__ = staticmethod(HighLevelAccordion.create)
+
+
+accordion = Accordion()

buridan_create-0.1.0/app/base_ui/components/base/avatar.py

@@ -0,0 +1,126 @@
+"""Custom avatar component."""
+
+from reflex.components.component import Component, ComponentNamespace
+from reflex.event import EventHandler, passthrough_event_spec
+from reflex.utils.imports import ImportVar
+from reflex.vars.base import Var
+
+from ..base_ui import PACKAGE_NAME, BaseUIComponent
+
+
+class ClassNames:
+    """Class names for avatar components."""
+
+    ROOT = "shrink-0 inline-flex size-8 items-center justify-center overflow-hidden rounded-full align-middle text-base font-medium select-none"
+    IMAGE = "size-full object-cover shrink-0"
+    FALLBACK = "flex size-full items-center justify-center text-sm bg-muted"
+
+
+class AvatarBaseComponent(BaseUIComponent):
+    """Base component for avatar components."""
+
+    library = f"{PACKAGE_NAME}/avatar"
+
+    @property
+    def import_var(self):
+        """Return the import variable for the avatar component."""
+        return ImportVar(tag="Avatar", package_path="", install=False)
+
+
+class AvatarRoot(AvatarBaseComponent):
+    """Displays a user's profile picture, initials, or fallback icon."""
+
+    tag = "Avatar.Root"
+
+    # The component to render
+    render_: Var[Component]
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the avatar root component."""
+        props["data-slot"] = "avatar"
+        cls.set_class_name(ClassNames.ROOT, props)
+        return super().create(*children, **props)
+
+
+class AvatarImage(AvatarBaseComponent):
+    """The image to be displayed in the avatar."""
+
+    tag = "Avatar.Image"
+
+    # The image source URL
+    src: Var[str]
+
+    # Callback when loading status changes
+    on_loading_status_change: EventHandler[passthrough_event_spec(str)]
+
+    # The component to render
+    render_: Var[Component]
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the avatar image component."""
+        props["data-slot"] = "avatar-image"
+        cls.set_class_name(ClassNames.IMAGE, props)
+        return super().create(*children, **props)
+
+
+class AvatarFallback(AvatarBaseComponent):
+    """Rendered when the image fails to load or when no image is provided."""
+
+    tag = "Avatar.Fallback"
+
+    # How long to wait before showing the fallback. Specified in milliseconds
+    delay: Var[int]
+
+    # The component to render
+    render_: Var[Component]
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the avatar fallback component."""
+        props["data-slot"] = "avatar-fallback"
+        cls.set_class_name(ClassNames.FALLBACK, props)
+        return super().create(*children, **props)
+
+
+class HighLevelAvatar(AvatarRoot):
+    """High level wrapper for the Avatar component."""
+
+    # The image source URL
+    src: Var[str]
+
+    # Image props
+    _image_props = {"src", "on_loading_status_change", "render_"}
+
+    # Fallback props
+    _fallback_props = {"delay"}
+
+    @classmethod
+    def create(cls, *children, **props) -> BaseUIComponent:
+        """Create the avatar component."""
+        # Extract props for each subcomponent
+        image_props = {k: props.pop(k) for k in cls._image_props & props.keys()}
+        fallback_props = {k: props.pop(k) for k in cls._fallback_props & props.keys()}
+
+        fallback_content = props.pop("fallback", "")
+
+        return AvatarRoot.create(
+            AvatarImage.create(**image_props),
+            AvatarFallback.create(fallback_content, **fallback_props),
+            *children,
+            **props,
+        )
+
+
+class Avatar(ComponentNamespace):
+    """Namespace for Avatar components."""
+
+    root = staticmethod(AvatarRoot.create)
+    image = staticmethod(AvatarImage.create)
+    fallback = staticmethod(AvatarFallback.create)
+    class_names = ClassNames
+    __call__ = staticmethod(HighLevelAvatar.create)
+
+
+avatar = Avatar()

buridan_create-0.1.0/app/base_ui/components/base/badge.py

@@ -0,0 +1,88 @@
+from typing import Literal
+
+from reflex.vars.base import Var
+from reflex_components_core.el import Span
+
+from ..component import CoreComponent
+
+LiteralBadgeVariant = Literal["default", "secondary", "destructive", "outline"]
+
+DEFAULT_BASE_CLASSES = (
+    "inline-flex items-center justify-center rounded-md border px-2 py-0.5 text-xs font-medium "
+    "w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none "
+    "focus-visible:border-[var(--ring)] focus-visible:ring-[var(--ring)]/50 focus-visible:ring-[3px] "
+    "aria-invalid:ring-[var(--destructive)]/20 dark:aria-invalid:ring-[var(--destructive)]/40 "
+    "aria-invalid:border-[var(--destructive)] transition-[color,box-shadow] overflow-hidden"
+)
+
+BADGE_VARIANTS = {
+    "default": (
+        "border-transparent bg-[var(--primary)] text-[var(--primary-foreground)] "
+        "[a&]:hover:bg-[var(--primary)]/90"
+    ),
+    "secondary": (
+        "border-transparent bg-[var(--secondary)] text-[var(--secondary-foreground)] "
+        "[a&]:hover:bg-[var(--secondary)]/90"
+    ),
+    "destructive": (
+        "border-transparent bg-[var(--destructive)] text-white "
+        "[a&]:hover:bg-[var(--destructive)]/90 "
+        "focus-visible:ring-[var(--destructive)]/20 dark:focus-visible:ring-[var(--destructive)]/40 "
+        "dark:bg-[var(--destructive)]/60"
+    ),
+    "outline": (
+        "text-[var(--foreground)] border-[var(--input)] "
+        "[a&]:hover:bg-[var(--accent)] [a&]:hover:text-[var(--accent-foreground)]"
+    ),
+}
+
+
+def get_badge_classes(variant: LiteralBadgeVariant) -> str:
+    """Get the complete badge class string.
+
+    Args:
+        variant: The badge variant to apply
+
+    Returns:
+        The complete class string for the badge
+    """
+    variant_classes = BADGE_VARIANTS[variant]
+    return f"{DEFAULT_BASE_CLASSES} {variant_classes}"
+
+
+class Badge(Span, CoreComponent):
+    """A badge component that displays a label."""
+
+    # Badge variant
+    variant: Var[LiteralBadgeVariant]
+
+    @classmethod
+    def create(cls, *children, **props) -> Span:
+        """Create the badge component.
+
+        Args:
+            *children: The badge content
+            **props: Component properties including variant
+
+        Returns:
+            A configured Span component
+        """
+        variant = props.pop("variant", "default")
+
+        cls.set_class_name(get_badge_classes(variant), props)
+
+        # Add data-slot attribute
+        props.setdefault("data_slot", "badge")
+
+        return super().create(*children, **props)
+
+    def _exclude_props(self) -> list[str]:
+        """Exclude component-specific props from being passed to the DOM.
+
+        Returns:
+            List of prop names to exclude
+        """
+        return [*super()._exclude_props(), "variant"]
+
+
+badge = Badge.create

buridan_create-0.1.0/app/base_ui/components/base/breadcrumb.py

@@ -0,0 +1,95 @@
+import reflex as rx
+
+
+def breadcrumb(*children, **props):
+    """Breadcrumb navigation container"""
+    return rx.el.nav(
+        *children, aria_label="breadcrumb", data_slot="breadcrumb", **props
+    )
+
+
+def breadcrumb_list(*children, class_name: str = "", **props):
+    """Ordered list container for breadcrumb items"""
+    base_classes = (
+        "text-[var(--muted-foreground)] flex flex-wrap items-center gap-1 text-sm "
+        "break-words sm:gap-2.5"
+    )
+
+    return rx.el.ol(
+        *children,
+        data_slot="breadcrumb-list",
+        class_name=f"{base_classes} {class_name}".strip(),
+        **props,
+    )
+
+
+def breadcrumb_item(*children, class_name: str = "", **props):
+    """Individual breadcrumb item"""
+    base_classes = "inline-flex items-center gap-1.5"
+
+    return rx.el.li(
+        *children,
+        data_slot="breadcrumb-item",
+        class_name=f"{base_classes} {class_name}".strip(),
+        **props,
+    )
+
+
+def breadcrumb_link(*children, href: str = "#", class_name: str = "", **props):
+    """Breadcrumb link (clickable)"""
+    base_classes = "hover:text-[var(--foreground)] transition-colors no-underline"
+
+    return rx.el.a(
+        *children,
+        href=href,
+        data_slot="breadcrumb-link",
+        class_name=f"{base_classes} {class_name}".strip(),
+        **props,
+    )
+
+
+def breadcrumb_page(*children, class_name: str = "", **props):
+    """Current page breadcrumb (non-clickable)"""
+    base_classes = "text-[var(--foreground)] font-normal"
+
+    return rx.el.span(
+        *children,
+        role="link",
+        aria_disabled="true",
+        aria_current="page",
+        data_slot="breadcrumb-page",
+        class_name=f"{base_classes} {class_name}".strip(),
+        **props,
+    )
+
+
+def breadcrumb_separator(*children, class_name: str = "", **props):
+    """Separator between breadcrumb items"""
+    base_classes = "[&>svg]:size-3.5"
+
+    if not children:
+        children = (rx.icon(tag="chevron-right", size=14),)
+
+    return rx.el.li(
+        *children,
+        role="presentation",
+        aria_hidden="true",
+        data_slot="breadcrumb-separator",
+        class_name=f"{base_classes} {class_name}".strip(),
+        **props,
+    )
+
+
+def breadcrumb_ellipsis(class_name: str = "", **props):
+    """Ellipsis for collapsed breadcrumb items"""
+    base_classes = "flex size-9 items-center justify-center"
+
+    return rx.el.span(
+        rx.icon(tag="ellipsis", size=16),
+        rx.el.span("More", class_name="sr-only"),
+        role="presentation",
+        aria_hidden="true",
+        data_slot="breadcrumb-ellipsis",
+        class_name=f"{base_classes} {class_name}".strip(),
+        **props,
+    )