tembro 2.0.3 → 2.0.5

package/packages/cli/vendor/src/components/display/tag-list.tsx

@@ -1,52 +0,0 @@
-import * as React from "react"
-import { XIcon } from "lucide-react"
-
-import { Badge } from "@/components/ui/badge"
-import { cn } from "@/lib/utils"
-
-export type TagListItem = {
-  key: string
-  label: React.ReactNode
-  variant?: React.ComponentProps<typeof Badge>["variant"]
-  disabled?: boolean
-}
-
-export type TagListProps = React.ComponentProps<"div"> & {
-  items: TagListItem[]
-  max?: number
-  removable?: boolean
-  onRemove?: (item: TagListItem) => void
-  overflowLabel?: (count: number) => React.ReactNode
-}
-
-function TagList({ items, max, removable = false, onRemove, overflowLabel = (count) => `+${count}`, className, ...props }: TagListProps) {
-  const visibleItems = typeof max === "number" ? items.slice(0, max) : items
-  const overflowCount = typeof max === "number" ? Math.max(items.length - max, 0) : 0
-
-  return (
-    <div data-slot="tag-list" className={cn("flex flex-wrap items-center gap-1.5", className)} {...props}>
-      {visibleItems.map((item) => (
-        <Badge
-          key={item.key}
-          variant={item.variant}
-          className={cn("gap-1", item.disabled && "opacity-55")}
-        >
-          <span>{item.label}</span>
-          {removable && !item.disabled && (
-            <button
-              type="button"
-              aria-label="Remove tag"
-              className="rounded-sm text-muted-foreground hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-              onClick={() => onRemove?.(item)}
-            >
-              <XIcon className="size-3" />
-            </button>
-          )}
-        </Badge>
-      ))}
-      {overflowCount > 0 && <Badge variant="outline">{overflowLabel(overflowCount)}</Badge>}
-    </div>
-  )
-}
-
-export { TagList }

package/packages/cli/vendor/src/components/display/watermark.tsx

@@ -1,20 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-export type WatermarkProps = React.ComponentProps<"div"> & {
-  text?: string
-}
-
-function Watermark({ text = "Azamat UI", className, children, ...props }: WatermarkProps) {
-  return (
-    <div data-slot="watermark" className={cn("relative overflow-hidden", className)} {...props}>
-      <div className="pointer-events-none absolute inset-0 z-0 grid place-items-center opacity-10">
-        <span className="rotate-[-24deg] select-none text-4xl font-bold tracking-widest text-muted-foreground">{text}</span>
-      </div>
-      <div className="relative z-10">{children}</div>
-    </div>
-  )
-}
-
-export { Watermark }

package/packages/cli/vendor/src/components/feedback/empty-search-state.tsx

@@ -1,65 +0,0 @@
-import * as React from "react"
-import { SearchXIcon } from "lucide-react"
-
-import { Button } from "@/components/ui/button"
-import { cn } from "@/lib/utils"
-
-export type EmptySearchStateProps = React.ComponentProps<"div"> & {
-  query?: string
-  title?: React.ReactNode
-  description?: React.ReactNode
-  suggestions?: React.ReactNode
-  onClear?: () => void
-  clearLabel?: React.ReactNode
-}
-
-function EmptySearchState({
-  query,
-  title = "No results found",
-  description,
-  suggestions,
-  onClear,
-  clearLabel = "Clear search",
-  className,
-  ...props
-}: EmptySearchStateProps) {
-  return (
-    <div
-      data-slot="empty-search-state"
-      className={cn(
-        "flex flex-col items-center justify-center p-8 text-center min-h-[300px]",
-        className
-      )}
-      {...props}
-    >
-      <div className="mb-4 flex size-12 items-center justify-center rounded-full bg-muted/50 text-muted-foreground">
-        <SearchXIcon className="size-6" />
-      </div>
-      <h3 className="text-lg font-semibold tracking-tight">
-        {title} {query ? `for "${query}"` : ""}
-      </h3>
-      
-      {description && (
-        <p className="mt-2 text-sm text-muted-foreground max-w-sm">
-          {description}
-        </p>
-      )}
-
-      {suggestions && (
-        <div className="mt-4 text-sm text-muted-foreground">
-          {suggestions}
-        </div>
-      )}
-
-      {onClear && (
-        <div className="mt-6">
-          <Button variant="outline" onClick={onClear}>
-            {clearLabel}
-          </Button>
-        </div>
-      )}
-    </div>
-  )
-}
-
-export { EmptySearchState }

package/packages/cli/vendor/src/components/feedback/empty-state.tsx

@@ -1,56 +0,0 @@
-import * as React from "react"
-import { InboxIcon } from "lucide-react"
-
-import { Button } from "@/components/ui/button"
-import { cn } from "@/lib/utils"
-
-export type EmptyStateProps = React.ComponentProps<"div"> & {
-  icon?: React.ReactNode
-  title?: React.ReactNode
-  description?: React.ReactNode
-  action?: React.ReactNode
-  actionLabel?: React.ReactNode
-  onAction?: () => void
-}
-
-function EmptyState({
-  className,
-  icon,
-  title = "No data",
-  description,
-  action,
-  actionLabel,
-  onAction,
-  ...props
-}: EmptyStateProps) {
-  return (
-    <div
-      data-slot="empty-state"
-      className={cn(
-        "flex min-h-52 flex-col items-center justify-center gap-4 rounded-[var(--radius-3xl)] border border-dashed border-border/80 bg-muted/25 p-10 text-center shadow-sm ring-1 ring-foreground/4",
-        className
-      )}
-      {...props}
-    >
-      <div className="flex size-12 items-center justify-center rounded-full border border-border/70 bg-background/92 text-muted-foreground shadow-[0_1px_0_rgba(255,255,255,0.08)]">
-        {icon ?? <InboxIcon className="size-5" />}
-      </div>
-
-      <div className="grid gap-1.5">
-        {title && <h3 className="text-base font-semibold tracking-tight text-foreground">{title}</h3>}
-        {description && (
-          <p className="max-w-sm text-sm leading-6 text-muted-foreground">{description}</p>
-        )}
-      </div>
-
-      {action ??
-        (actionLabel && onAction ? (
-          <Button type="button" variant="outline" size="sm" onClick={onAction}>
-            {actionLabel}
-          </Button>
-        ) : null)}
-    </div>
-  )
-}
-
-export { EmptyState }

package/packages/cli/vendor/src/components/filters/filter-chips.tsx

@@ -1,89 +0,0 @@
-import * as React from "react"
-import { XIcon } from "lucide-react"
-
-import { Badge } from "@/components/ui/badge"
-import { Button } from "@/components/ui/button"
-import { cn, stopInteractivePropagation } from "@/lib/utils"
-
-export type FilterChip = {
-  key: string
-  label: React.ReactNode
-  value?: React.ReactNode
-  tone?: "default" | "success" | "warning" | "danger" | "info" | "muted"
-  disabled?: boolean
-  hidden?: boolean
-}
-
-export type FilterChipsProps = React.ComponentProps<"div"> & {
-  chips: FilterChip[]
-  clearLabel?: React.ReactNode
-  empty?: React.ReactNode
-  onRemove?: (key: string) => void
-  onClear?: () => void
-}
-
-const chipVariant: Record<NonNullable<FilterChip["tone"]>, React.ComponentProps<typeof Badge>["variant"]> = {
-  default: "secondary",
-  success: "secondary",
-  warning: "outline",
-  danger: "destructive",
-  info: "outline",
-  muted: "outline",
-}
-
-function FilterChips({
-  chips,
-  clearLabel = "Clear all",
-  empty = "No active filters",
-  onRemove,
-  onClear,
-  className,
-  ...props
-}: FilterChipsProps) {
-  const visibleChips = chips.filter((chip) => !chip.hidden)
-  if (!visibleChips.length) {
-    return <div data-slot="filter-chips-empty" className={cn("text-sm text-muted-foreground", className)} {...props}>{empty}</div>
-  }
-
-  return (
-    <div data-slot="filter-chips" className={cn("flex flex-wrap items-center gap-2", className)} {...props}>
-      {visibleChips.map((chip) => (
-        <Badge key={chip.key} variant={chipVariant[chip.tone ?? "default"]} className={cn("gap-1.5", chip.disabled && "opacity-60")}>
-          <span>{chip.label}</span>
-          {chip.value !== undefined && <span className="text-muted-foreground">{chip.value}</span>}
-          {onRemove && !chip.disabled && (
-            <button
-              type="button"
-              className="rounded-full p-0.5 hover:bg-muted"
-              onClick={(event) => {
-                stopInteractivePropagation(event)
-                onRemove(chip.key)
-              }}
-              onMouseDown={stopInteractivePropagation}
-              onDoubleClick={stopInteractivePropagation}
-            >
-              <XIcon className="size-3" />
-            </button>
-          )}
-        </Badge>
-      ))}
-      {onClear && (
-        <Button
-          type="button"
-          variant="ghost"
-          size="xs"
-          onClick={(event) => {
-            stopInteractivePropagation(event)
-            onClear()
-          }}
-          onMouseDown={stopInteractivePropagation}
-          onDoubleClick={stopInteractivePropagation}
-        >
-          {clearLabel}
-        </Button>
-      )}
-    </div>
-  )
-}
-
-export { FilterChips }

package/packages/cli/vendor/src/components/form/repeater-field.tsx

@@ -1,93 +0,0 @@
-import * as React from "react"
-import { PlusIcon, Trash2Icon } from "lucide-react"
-
-import { Button } from "@/components/ui/button"
-import { cn } from "@/lib/utils"
-
-export type RepeaterFieldProps<T> = Omit<React.ComponentProps<"div">, "value" | "onChange"> & {
-  value: T[]
-  onValueChange: (value: T[]) => void
-  renderItem: (item: T, index: number, helpers: { remove: () => void; update: (item: T) => void }) => React.ReactNode
-  createItem: () => T
-  addLabel?: React.ReactNode
-  max?: number
-  min?: number
-  disabled?: boolean
-}
-
-function RepeaterField<T>({
-  value,
-  onValueChange,
-  renderItem,
-  createItem,
-  addLabel = "Add item",
-  max = Infinity,
-  min = 0,
-  disabled = false,
-  className,
-  ...props
-}: RepeaterFieldProps<T>) {
-  const handleAdd = () => {
-    if (value.length < max) {
-      onValueChange([...value, createItem()])
-    }
-  }
-
-  const handleRemove = (indexToRemove: number) => {
-    if (value.length > min) {
-      onValueChange(value.filter((_, index) => index !== indexToRemove))
-    }
-  }
-
-  const handleUpdate = (indexToUpdate: number, newItem: T) => {
-    const newItems = [...value]
-    newItems[indexToUpdate] = newItem
-    onValueChange(newItems)
-  }
-
-  const canAdd = value.length < max && !disabled
-  const canRemove = value.length > min && !disabled
-
-  return (
-    <div data-slot="repeater-field" className={cn("flex flex-col gap-4", className)} {...props}>
-      {value.map((item, index) => (
-        <div key={index} className="flex items-start gap-2">
-          <div className="flex-1 min-w-0">
-            {renderItem(item, index, {
-              remove: () => handleRemove(index),
-              update: (newItem: T) => handleUpdate(index, newItem),
-            })}
-          </div>
-          {canRemove && (
-            <Button
-              type="button"
-              variant="outline"
-              size="icon"
-              className="shrink-0 text-muted-foreground hover:text-destructive"
-              onClick={() => handleRemove(index)}
-              aria-label="Remove item"
-            >
-              <Trash2Icon className="size-4" />
-            </Button>
-          )}
-        </div>
-      ))}
-      {canAdd && (
-        <div>
-          <Button
-            type="button"
-            variant="outline"
-            size="sm"
-            onClick={handleAdd}
-            className="w-full sm:w-auto"
-          >
-            <PlusIcon className="mr-2 size-4" />
-            {addLabel}
-          </Button>
-        </div>
-      )}
-    </div>
-  )
-}
-
-export { RepeaterField }

package/packages/cli/vendor/src/components/inputs/cascader.tsx

@@ -1,41 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-export type CascaderOption = {
-  label: React.ReactNode
-  value: string
-  children?: CascaderOption[]
-}
-
-export type CascaderProps = React.ComponentProps<"div"> & {
-  options: CascaderOption[]
-  value?: string[]
-  onValueChange?: (value: string[]) => void
-}
-
-function Cascader({ options, value = [], onValueChange, className, ...props }: CascaderProps) {
-  const firstValue = value[0] ?? ""
-  const secondOptions = options.find((item) => item.value === firstValue)?.children ?? []
-  const secondValue = value[1] ?? ""
-  const thirdOptions = secondOptions.find((item) => item.value === secondValue)?.children ?? []
-
-  return (
-    <div data-slot="cascader" className={cn("grid gap-2 sm:grid-cols-3", className)} {...props}>
-      <select className="h-10 rounded-md border bg-background px-3 text-sm" value={firstValue} onChange={(event) => onValueChange?.([event.target.value])}>
-        <option value="">Select</option>
-        {options.map((option) => <option key={option.value} value={option.value}>{option.label}</option>)}
-      </select>
-      <select className="h-10 rounded-md border bg-background px-3 text-sm" value={secondValue} disabled={!secondOptions.length} onChange={(event) => onValueChange?.([firstValue, event.target.value])}>
-        <option value="">Select</option>
-        {secondOptions.map((option) => <option key={option.value} value={option.value}>{option.label}</option>)}
-      </select>
-      <select className="h-10 rounded-md border bg-background px-3 text-sm" value={value[2] ?? ""} disabled={!thirdOptions.length} onChange={(event) => onValueChange?.([firstValue, secondValue, event.target.value])}>
-        <option value="">Select</option>
-        {thirdOptions.map((option) => <option key={option.value} value={option.value}>{option.label}</option>)}
-      </select>
-    </div>
-  )
-}
-
-export { Cascader }

package/packages/cli/vendor/src/components/inputs/mention-input.tsx

@@ -1,162 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-export type MentionOption = {
-  label: React.ReactNode
-  value: string
-  searchText?: string
-  insertValue?: string
-}
-
-export type MentionInputProps = Omit<React.ComponentProps<"textarea">, "value" | "defaultValue"> & {
-  value?: string
-  defaultValue?: string
-  options?: MentionOption[]
-  onMentionSelect?: (value: string) => void
-  onValueChange?: (value: string) => void
-  trigger?: string
-  maxSuggestions?: number
-}
-
-function getTriggerMatch(value: string, selectionStart: number, trigger: string) {
-  const prefix = value.slice(0, selectionStart)
-  const triggerIndex = prefix.lastIndexOf(trigger)
-
-  if (triggerIndex < 0) return null
-
-  const previousCharacter = prefix[triggerIndex - 1]
-  if (previousCharacter && /\S/.test(previousCharacter)) return null
-
-  const query = prefix.slice(triggerIndex + trigger.length)
-  if (/\s/.test(query)) return null
-
-  return { triggerIndex, query }
-}
-
-function MentionInput({
-  value,
-  defaultValue = "",
-  options = [],
-  onMentionSelect,
-  onValueChange,
-  className,
-  trigger = "@",
-  maxSuggestions = 6,
-  onChange,
-  onKeyDown,
-  ...props
-}: MentionInputProps) {
-  const textareaRef = React.useRef<HTMLTextAreaElement>(null)
-  const [internalValue, setInternalValue] = React.useState(defaultValue)
-  const [selectionStart, setSelectionStart] = React.useState(0)
-  const [activeIndex, setActiveIndex] = React.useState(0)
-  const currentValue = value ?? internalValue
-  const triggerMatch = getTriggerMatch(currentValue, selectionStart, trigger)
-  const filteredOptions = React.useMemo(() => {
-    if (!triggerMatch) return []
-    const normalizedQuery = triggerMatch.query.trim().toLowerCase()
-
-    return options
-      .filter((option) => {
-        if (!normalizedQuery) return true
-        const rawLabel = typeof option.label === "string" ? option.label : option.value
-        const haystack = `${option.value} ${option.searchText ?? ""} ${rawLabel}`.toLowerCase()
-        return haystack.includes(normalizedQuery)
-      })
-      .slice(0, maxSuggestions)
-  }, [maxSuggestions, options, triggerMatch])
-  const showSuggestions = filteredOptions.length > 0 && triggerMatch !== null
-
-  React.useEffect(() => {
-    if (!showSuggestions) setActiveIndex(0)
-  }, [showSuggestions])
-
-  function updateValue(nextValue: string, event?: React.ChangeEvent<HTMLTextAreaElement>) {
-    if (value === undefined) setInternalValue(nextValue)
-    onValueChange?.(nextValue)
-    if (event) onChange?.(event)
-  }
-
-  function insertMention(option: MentionOption) {
-    if (!triggerMatch) return
-
-    const mentionValue = option.insertValue ?? option.value
-    const nextValue = `${currentValue.slice(0, triggerMatch.triggerIndex)}${trigger}${mentionValue} ${currentValue.slice(selectionStart)}`
-    const nextCursor = triggerMatch.triggerIndex + trigger.length + mentionValue.length + 1
-
-    if (value === undefined) setInternalValue(nextValue)
-    onValueChange?.(nextValue)
-    onMentionSelect?.(option.value)
-
-    requestAnimationFrame(() => {
-      textareaRef.current?.focus()
-      textareaRef.current?.setSelectionRange(nextCursor, nextCursor)
-      setSelectionStart(nextCursor)
-    })
-  }
-
-  return (
-    <div data-slot="mention-input" className="grid gap-2">
-      <textarea
-        ref={textareaRef}
-        value={currentValue}
-        className={cn("min-h-24 rounded-md border bg-background p-3 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring", className)}
-        onChange={(event) => {
-          updateValue(event.target.value, event)
-          setSelectionStart(event.target.selectionStart ?? event.target.value.length)
-        }}
-        onClick={(event) => setSelectionStart(event.currentTarget.selectionStart ?? 0)}
-        onKeyUp={(event) => setSelectionStart(event.currentTarget.selectionStart ?? 0)}
-        onKeyDown={(event) => {
-          if (showSuggestions) {
-            if (event.key === "ArrowDown") {
-              event.preventDefault()
-              setActiveIndex((current) => (current + 1) % filteredOptions.length)
-              return
-            }
-            if (event.key === "ArrowUp") {
-              event.preventDefault()
-              setActiveIndex((current) => (current - 1 + filteredOptions.length) % filteredOptions.length)
-              return
-            }
-            if (event.key === "Enter" || event.key === "Tab") {
-              event.preventDefault()
-              insertMention(filteredOptions[activeIndex] ?? filteredOptions[0])
-              return
-            }
-            if (event.key === "Escape") {
-              event.preventDefault()
-              setSelectionStart(currentValue.length)
-              return
-            }
-          }
-
-          onKeyDown?.(event)
-        }}
-        {...props}
-      />
-      {showSuggestions ? (
-        <div className="grid gap-1 rounded-xl border bg-card p-2 shadow-sm">
-          {filteredOptions.map((option, index) => (
-            <button
-              key={option.value}
-              type="button"
-              className={cn(
-                "flex items-center justify-between rounded-lg px-3 py-2 text-left text-sm transition-colors hover:bg-muted",
-                index === activeIndex && "bg-muted"
-              )}
-              onMouseDown={(event) => event.preventDefault()}
-              onClick={() => insertMention(option)}
-            >
-              <span className="font-medium">{option.label}</span>
-              <span className="text-xs text-muted-foreground">{trigger}{option.insertValue ?? option.value}</span>
-            </button>
-          ))}
-        </div>
-      ) : null}
-    </div>
-  )
-}
-
-export { MentionInput }

package/packages/cli/vendor/src/components/layout/stack.tsx

@@ -1,106 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-type StackGap = "xs" | "sm" | "md" | "lg" | "xl"
-type InlineAlign = "start" | "center" | "end" | "stretch"
-type InlineJustify = "start" | "center" | "end" | "between"
-type GridColumns = 1 | 2 | 3 | 4 | 5 | 6
-
-const stackGapClassName: Record<StackGap, string> = {
-  xs: "gap-2",
-  sm: "gap-3",
-  md: "gap-4",
-  lg: "gap-6",
-  xl: "gap-8",
-}
-
-const inlineAlignClassName: Record<InlineAlign, string> = {
-  start: "items-start",
-  center: "items-center",
-  end: "items-end",
-  stretch: "items-stretch",
-}
-
-const inlineJustifyClassName: Record<InlineJustify, string> = {
-  start: "justify-start",
-  center: "justify-center",
-  end: "justify-end",
-  between: "justify-between",
-}
-
-const gridColumnClassName: Record<GridColumns, string> = {
-  1: "grid-cols-1",
-  2: "grid-cols-2",
-  3: "grid-cols-3",
-  4: "grid-cols-4",
-  5: "grid-cols-5",
-  6: "grid-cols-6",
-}
-
-export type StackProps = React.ComponentProps<"div"> & {
-  gap?: StackGap
-  splitAfter?: React.ReactNode
-}
-
-function Stack({ gap = "md", splitAfter, className, children, ...props }: StackProps) {
-  return (
-    <div data-slot="stack" className={cn("flex min-w-0 flex-col", stackGapClassName[gap], className)} {...props}>
-      {children}
-      {splitAfter ? <div data-slot="stack-split-after">{splitAfter}</div> : null}
-    </div>
-  )
-}
-
-export type InlineProps = React.ComponentProps<"div"> & {
-  gap?: StackGap
-  align?: InlineAlign
-  justify?: InlineJustify
-  wrap?: boolean
-}
-
-export type GridProps = React.ComponentProps<"div"> & {
-  gap?: StackGap
-  columns?: GridColumns
-}
-
-function Inline({
-  gap = "md",
-  align = "center",
-  justify = "start",
-  wrap = true,
-  className,
-  children,
-  ...props
-}: InlineProps) {
-  return (
-    <div
-      data-slot="inline"
-      className={cn(
-        "flex min-w-0",
-        stackGapClassName[gap],
-        inlineAlignClassName[align],
-        inlineJustifyClassName[justify],
-        wrap ? "flex-wrap" : "flex-nowrap",
-        className
-      )}
-      {...props}
-    >
-      {children}
-    </div>
-  )
-}
-
-function Grid({ gap = "md", columns = 2, className, children, ...props }: GridProps) {
-  return (
-    <div
-      data-slot="grid"
-      className={cn("grid min-w-0", stackGapClassName[gap], gridColumnClassName[columns], className)}
-      {...props}
-    >
-      {children}
-    </div>
-  )
-}
-
-export { Grid, Inline, Stack }