tembro 1.0.0

package/packages/cli/vendor/src/hooks/use-before-unload-when-dirty.ts

@@ -0,0 +1,21 @@
+import * as React from "react"
+
+function useBeforeUnloadWhenDirty(isDirty: boolean, message = "Changes you made may not be saved.") {
+  React.useEffect(() => {
+    if (!isDirty) return
+
+    const handleBeforeUnload = (event: BeforeUnloadEvent) => {
+      event.preventDefault()
+      event.returnValue = message
+      return message
+    }
+
+    window.addEventListener("beforeunload", handleBeforeUnload)
+
+    return () => {
+      window.removeEventListener("beforeunload", handleBeforeUnload)
+    }
+  }, [isDirty, message])
+}
+
+export { useBeforeUnloadWhenDirty }

package/packages/cli/vendor/src/hooks/use-data-table-view-state.ts

@@ -0,0 +1,122 @@
+import * as React from "react"
+
+export type DataTableViewStorage = "local" | "session" | "memory"
+
+export type UseDataTableViewStateOptions<TValue extends string> = {
+  key: string
+  defaultValue?: TValue
+  allowedValues?: readonly TValue[]
+  storage?: DataTableViewStorage
+  syncAcrossTabs?: boolean
+  serialize?: (value: TValue) => string
+  deserialize?: (value: string) => TValue
+  onValueChange?: (value: TValue | undefined) => void
+}
+
+export type UseDataTableViewStateReturn<TValue extends string> = {
+  value: TValue | undefined
+  setValue: (value: TValue | undefined) => void
+  clearValue: () => void
+  resetValue: () => void
+  isDefaultValue: boolean
+}
+
+const defaultSerialize = <TValue extends string>(value: TValue) => value
+const defaultDeserialize = <TValue extends string>(value: string) => value as TValue
+
+function getStorage(storage: DataTableViewStorage) {
+  if (typeof window === "undefined" || storage === "memory") return undefined
+  return storage === "local" ? window.localStorage : window.sessionStorage
+}
+
+function isAllowedValue<TValue extends string>(
+  value: TValue | undefined,
+  allowedValues?: readonly TValue[]
+) {
+  if (value === undefined) return true
+  if (!allowedValues?.length) return true
+  return allowedValues.includes(value)
+}
+
+function useDataTableViewState<TValue extends string>({
+  key,
+  defaultValue,
+  allowedValues,
+  storage = "local",
+  syncAcrossTabs = true,
+  serialize = defaultSerialize,
+  deserialize = defaultDeserialize,
+  onValueChange,
+}: UseDataTableViewStateOptions<TValue>): UseDataTableViewStateReturn<TValue> {
+  const readValue = React.useCallback(() => {
+    const fallbackValue = isAllowedValue(defaultValue, allowedValues) ? defaultValue : undefined
+    const targetStorage = getStorage(storage)
+
+    if (!targetStorage) return fallbackValue
+
+    try {
+      const storedValue = targetStorage.getItem(key)
+      if (!storedValue) return fallbackValue
+
+      const parsedValue = deserialize(storedValue)
+      return isAllowedValue(parsedValue, allowedValues) ? parsedValue : fallbackValue
+    } catch {
+      return fallbackValue
+    }
+  }, [allowedValues, defaultValue, deserialize, key, storage])
+
+  const [value, setInternalValue] = React.useState<TValue | undefined>(readValue)
+
+  const setValue = React.useCallback(
+    (nextValue: TValue | undefined) => {
+      const normalizedValue = isAllowedValue(nextValue, allowedValues) ? nextValue : undefined
+      const targetStorage = getStorage(storage)
+
+      setInternalValue(normalizedValue)
+
+      if (targetStorage) {
+        try {
+          if (normalizedValue === undefined) {
+            targetStorage.removeItem(key)
+          } else {
+            targetStorage.setItem(key, serialize(normalizedValue))
+          }
+        } catch {
+          // Ignore storage failures. State still updates in memory.
+        }
+      }
+
+      onValueChange?.(normalizedValue)
+    },
+    [allowedValues, key, onValueChange, serialize, storage]
+  )
+
+  const clearValue = React.useCallback(() => setValue(undefined), [setValue])
+  const resetValue = React.useCallback(() => setValue(defaultValue), [defaultValue, setValue])
+
+  React.useEffect(() => {
+    setInternalValue(readValue())
+  }, [readValue])
+
+  React.useEffect(() => {
+    if (!syncAcrossTabs || storage !== "local" || typeof window === "undefined") return undefined
+
+    const handleStorage = (event: StorageEvent) => {
+      if (event.storageArea !== window.localStorage || event.key !== key) return
+      setInternalValue(readValue())
+    }
+
+    window.addEventListener("storage", handleStorage)
+    return () => window.removeEventListener("storage", handleStorage)
+  }, [key, readValue, storage, syncAcrossTabs])
+
+  return {
+    value,
+    setValue,
+    clearValue,
+    resetValue,
+    isDefaultValue: value === defaultValue,
+  }
+}
+
+export { useDataTableViewState }

package/packages/cli/vendor/src/hooks/use-debounce.ts

@@ -0,0 +1,52 @@
+import * as React from "react"
+
+function useDebouncedValue<TValue>(value: TValue, delay = 300) {
+  const [debouncedValue, setDebouncedValue] = React.useState(value)
+
+  React.useEffect(() => {
+    const timer = window.setTimeout(() => {
+      setDebouncedValue(value)
+    }, delay)
+
+    return () => {
+      window.clearTimeout(timer)
+    }
+  }, [delay, value])
+
+  return debouncedValue
+}
+
+function useDebouncedCallback<TArgs extends unknown[]>(
+  callback: (...args: TArgs) => void,
+  delay = 300
+) {
+  const callbackRef = React.useRef(callback)
+  const timerRef = React.useRef<number | null>(null)
+
+  React.useEffect(() => {
+    callbackRef.current = callback
+  }, [callback])
+
+  React.useEffect(() => {
+    return () => {
+      if (timerRef.current) {
+        window.clearTimeout(timerRef.current)
+      }
+    }
+  }, [])
+
+  return React.useCallback(
+    (...args: TArgs) => {
+      if (timerRef.current) {
+        window.clearTimeout(timerRef.current)
+      }
+
+      timerRef.current = window.setTimeout(() => {
+        callbackRef.current(...args)
+      }, delay)
+    },
+    [delay]
+  )
+}
+
+export { useDebouncedCallback, useDebouncedValue }

package/packages/cli/vendor/src/hooks/use-disclosure.ts

@@ -0,0 +1,38 @@
+import * as React from "react"
+
+export type UseDisclosureOptions = {
+  defaultOpen?: boolean
+  open?: boolean
+  onOpenChange?: (open: boolean) => void
+}
+
+function useDisclosure({ defaultOpen = false, open, onOpenChange }: UseDisclosureOptions = {}) {
+  const isControlled = open !== undefined
+  const [internalOpen, setInternalOpen] = React.useState(defaultOpen)
+  const currentOpen = isControlled ? open : internalOpen
+
+  const setOpen = React.useCallback(
+    (nextOpen: boolean) => {
+      if (!isControlled) {
+        setInternalOpen(nextOpen)
+      }
+
+      onOpenChange?.(nextOpen)
+    },
+    [isControlled, onOpenChange]
+  )
+
+  const openDisclosure = React.useCallback(() => setOpen(true), [setOpen])
+  const closeDisclosure = React.useCallback(() => setOpen(false), [setOpen])
+  const toggleDisclosure = React.useCallback(() => setOpen(!currentOpen), [currentOpen, setOpen])
+
+  return {
+    open: currentOpen,
+    setOpen,
+    openDisclosure,
+    closeDisclosure,
+    toggleDisclosure,
+  } as const
+}
+
+export { useDisclosure }

package/packages/cli/vendor/src/hooks/use-is-mobile.ts

@@ -0,0 +1,28 @@
+import * as React from "react"
+
+const DEFAULT_MOBILE_BREAKPOINT = 768
+
+function useIsMobile(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
+  const [isMobile, setIsMobile] = React.useState(false)
+
+  React.useEffect(() => {
+    if (typeof window === "undefined") return
+
+    const query = window.matchMedia(`(max-width: ${breakpoint - 1}px)`)
+
+    const update = () => {
+      setIsMobile(query.matches)
+    }
+
+    update()
+    query.addEventListener("change", update)
+
+    return () => {
+      query.removeEventListener("change", update)
+    }
+  }, [breakpoint])
+
+  return isMobile
+}
+
+export { useIsMobile, DEFAULT_MOBILE_BREAKPOINT }

package/packages/cli/vendor/src/hooks/use-session-storage-state.ts

@@ -0,0 +1,85 @@
+import * as React from "react"
+
+type SessionStorageOptions<T> = {
+  serialize?: (value: T) => string
+  deserialize?: (value: string) => T
+}
+
+type SetSessionStorageStateAction<T> = T | ((previousValue: T) => T)
+
+const defaultSerialize = JSON.stringify
+const defaultDeserialize = JSON.parse
+
+function getInitialValue<T>(initialValue: T | (() => T)) {
+  return typeof initialValue === "function"
+    ? (initialValue as () => T)()
+    : initialValue
+}
+
+function useSessionStorageState<T>(
+  key: string,
+  initialValue: T | (() => T),
+  options: SessionStorageOptions<T> = {}
+) {
+  const { serialize = defaultSerialize, deserialize = defaultDeserialize } = options
+
+  const readValue = React.useCallback(() => {
+    const fallbackValue = getInitialValue(initialValue)
+
+    if (typeof window === "undefined") {
+      return fallbackValue
+    }
+
+    try {
+      const item = window.sessionStorage.getItem(key)
+      return item ? (deserialize(item) as T) : fallbackValue
+    } catch {
+      return fallbackValue
+    }
+  }, [deserialize, initialValue, key])
+
+  const [state, setState] = React.useState<T>(readValue)
+
+  const setValue = React.useCallback(
+    (value: SetSessionStorageStateAction<T>) => {
+      setState((previousValue) => {
+        const nextValue =
+          typeof value === "function"
+            ? (value as (previousValue: T) => T)(previousValue)
+            : value
+
+        if (typeof window !== "undefined") {
+          try {
+            window.sessionStorage.setItem(key, serialize(nextValue))
+          } catch {
+            // Ignore storage failures. State still updates in memory.
+          }
+        }
+
+        return nextValue
+      })
+    },
+    [key, serialize]
+  )
+
+  const removeValue = React.useCallback(() => {
+    if (typeof window !== "undefined") {
+      try {
+        window.sessionStorage.removeItem(key)
+      } catch {
+        // Ignore storage failures.
+      }
+    }
+
+    setState(getInitialValue(initialValue))
+  }, [initialValue, key])
+
+  React.useEffect(() => {
+    setState(readValue())
+  }, [readValue])
+
+  return [state, setValue, removeValue] as const
+}
+
+export { useSessionStorageState }
+export type { SessionStorageOptions, SetSessionStorageStateAction }

package/packages/cli/vendor/src/index.ts

@@ -0,0 +1,50 @@
+// Foundation components
+export * from './components/ui/button'
+export * from './components/ui/textarea'
+export * from './components/ui/input'
+export * from './components/ui/checkbox'
+export * from './components/ui/switch'
+export * from './components/ui/card'
+export * from './components/ui/badge'
+export * from './components/ui/tabs'
+export * from './components/ui/dialog'
+export * from './components/ui/dropdown-menu'
+export * from './components/ui/popover'
+export * from './components/ui/select'
+export * from './components/ui/table'
+export * from './components/ui/collapse'
+export * from './components/ui/accordion'
+export * from './components/ui/skeleton'
+export * from './components/ui/divider'
+export * from './components/ui/segmented-control'
+export * from './components/ui/spinner'
+export * from './components/ui/tooltip'
+export * from './components/ui/hover-card'
+export * from './components/ui/kbd'
+export * from './components/ui/radio-group'
+export * from './components/ui/scroll-box'
+export * from './components/ui/right-click-menu'
+
+// Reusable groups
+export * from './components/actions/public'
+export * from './components/layout/public'
+export * from './components/navigation'
+export * from './components/filters'
+export * from './components/overlay'
+export * from './components/inputs/public'
+export * from './components/form/public'
+export * from './components/feedback'
+export * from './components/display'
+export * from './components/modern'
+export * from './components/data-table/public'
+export * from './components/notifications'
+export * from './components/command'
+export * from './components/calendar'
+export * from './components/upload'
+export * from './components/charts'
+export * from './components/wizard'
+
+// Meta and helpers
+export * from './families'
+export * from './hooks'
+export * from './lib/utils'

package/packages/cli/vendor/src/lib/deprecated-warning.ts

@@ -0,0 +1,15 @@
+const warnedDeprecatedComponents = new Set<string>()
+
+export function warnDeprecatedComponent(name: string, replacement: string) {
+  const nodeEnv = (globalThis as { process?: { env?: { NODE_ENV?: string } } }).process?.env?.NODE_ENV
+  if (nodeEnv === "production") return
+
+  if (warnedDeprecatedComponents.has(name)) return
+
+  warnedDeprecatedComponents.add(name)
+  if (console?.warn) {
+    console.warn(
+      `[tembro] ${name} is deprecated. ${replacement} This alias is kept for compatibility only.`
+    )
+  }
+}

package/packages/cli/vendor/src/lib/utils.ts

@@ -0,0 +1,11 @@
+import type * as React from "react"
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+export function stopInteractivePropagation(event: React.SyntheticEvent) {
+  event.stopPropagation()
+}

package/packages/cli/vendor/src/public-component-surface.ts

@@ -0,0 +1,109 @@
+export type PublicComponentSurfaceEntry = {
+  slug: string
+  registryName: string
+  surface: "documented" | "standalone"
+}
+
+export const documentedPublicComponentSurfaces: readonly PublicComponentSurfaceEntry[] = [
+  { slug: "button", registryName: "button", surface: "documented" },
+  { slug: "input", registryName: "input", surface: "documented" },
+  { slug: "select", registryName: "select", surface: "documented" },
+  { slug: "card", registryName: "card", surface: "documented" },
+  { slug: "badge", registryName: "badge", surface: "documented" },
+  { slug: "checkbox", registryName: "checkbox", surface: "documented" },
+  { slug: "overlay", registryName: "dialog", surface: "documented" },
+  { slug: "form-field", registryName: "form-field-shell", surface: "documented" },
+  { slug: "data-table", registryName: "data-table", surface: "documented" },
+  { slug: "alert", registryName: "alert", surface: "documented" },
+  { slug: "bar-chart", registryName: "charts", surface: "documented" },
+  { slug: "sidebar", registryName: "sidebar", surface: "documented" },
+  { slug: "file-upload", registryName: "file-upload", surface: "documented" },
+  { slug: "progress", registryName: "progress", surface: "documented" },
+] as const
+
+export const standalonePublicComponentSurfaces: readonly PublicComponentSurfaceEntry[] = [
+  { slug: "accordion", registryName: "accordion", surface: "standalone" },
+  { slug: "divider", registryName: "divider", surface: "standalone" },
+  { slug: "segmented-control", registryName: "segmented-control", surface: "standalone" },
+  { slug: "skeleton", registryName: "skeleton", surface: "standalone" },
+  { slug: "spinner", registryName: "spinner", surface: "standalone" },
+  { slug: "command-bar", registryName: "command-bar", surface: "standalone" },
+  { slug: "quantity-stepper", registryName: "quantity-stepper", surface: "standalone" },
+  { slug: "inline-editable", registryName: "inline-editable", surface: "standalone" },
+  { slug: "repeater-field", registryName: "repeater-field", surface: "standalone" },
+  { slug: "empty-search-state", registryName: "empty-search-state", surface: "standalone" },
+  { slug: "avatar", registryName: "avatar", surface: "standalone" },
+  { slug: "code-block", registryName: "code-block", surface: "standalone" },
+  { slug: "data-state", registryName: "data-state", surface: "standalone" },
+  { slug: "descriptions", registryName: "descriptions", surface: "standalone" },
+  { slug: "keyboard-shortcut", registryName: "keyboard-shortcut", surface: "standalone" },
+  { slug: "key-value-card", registryName: "key-value-card", surface: "standalone" },
+  { slug: "kanban", registryName: "kanban", surface: "standalone" },
+  { slug: "list", registryName: "list", surface: "standalone" },
+  { slug: "property-grid", registryName: "property-grid", surface: "standalone" },
+  { slug: "statistic", registryName: "statistic", surface: "standalone" },
+  { slug: "tag-list", registryName: "tag-list", surface: "standalone" },
+  { slug: "tree-view", registryName: "tree-view", surface: "standalone" },
+  { slug: "skeleton-table", registryName: "skeleton-table", surface: "standalone" },
+  { slug: "skeleton-form", registryName: "skeleton-form", surface: "standalone" },
+  { slug: "copy-button", registryName: "copy-button", surface: "standalone" },
+  { slug: "copy-field", registryName: "copy-field", surface: "standalone" },
+  { slug: "section", registryName: "section", surface: "standalone" },
+  { slug: "stack", registryName: "stack", surface: "standalone" },
+  { slug: "sticky-footer-bar", registryName: "sticky-footer-bar", surface: "standalone" },
+  { slug: "affix", registryName: "affix", surface: "standalone" },
+  { slug: "calendar-scheduler", registryName: "calendar-scheduler", surface: "standalone" },
+  { slug: "dual-list-picker", registryName: "dual-list-picker", surface: "standalone" },
+  { slug: "menubar", registryName: "menubar", surface: "standalone" },
+  { slug: "navigation-menu", registryName: "navigation-menu", surface: "standalone" },
+  { slug: "resizable-panel", registryName: "resizable-panel", surface: "standalone" },
+  { slug: "rich-text-editor", registryName: "rich-text-editor", surface: "standalone" },
+  { slug: "tour", registryName: "tour", surface: "standalone" },
+  { slug: "qr-code", registryName: "qr-code", surface: "standalone" },
+  { slug: "tag", registryName: "tag", surface: "standalone" },
+  { slug: "aspect-ratio", registryName: "aspect-ratio", surface: "standalone" },
+  { slug: "carousel", registryName: "carousel", surface: "standalone" },
+  { slug: "float-button", registryName: "float-button", surface: "standalone" },
+  { slug: "typography", registryName: "typography", surface: "standalone" },
+  { slug: "watermark", registryName: "watermark", surface: "standalone" },
+  { slug: "cascader", registryName: "cascader", surface: "standalone" },
+  { slug: "json-input", registryName: "json-input", surface: "standalone" },
+  { slug: "mention-input", registryName: "mention-input", surface: "standalone" },
+  { slug: "time-picker", registryName: "time-picker", surface: "standalone" },
+] as const
+
+export const publicComponentSurfaceEntries = [
+  ...documentedPublicComponentSurfaces,
+  ...standalonePublicComponentSurfaces,
+] as const
+
+const publicComponentSurfaceOrder = new Map(
+  publicComponentSurfaceEntries.map((entry, index) => [entry.slug, index] as const)
+)
+
+const publicComponentSurfaceRegistryMap = new Map(
+  publicComponentSurfaceEntries.map((entry) => [entry.slug, entry.registryName] as const)
+)
+
+export const publicComponentSurfaceSlugs = publicComponentSurfaceEntries.map((entry) => entry.slug)
+export const publicComponentSurfaceSlugSet = new Set(publicComponentSurfaceSlugs)
+export const standalonePublicComponentSlugs = standalonePublicComponentSurfaces.map((entry) => entry.slug)
+export const documentedPublicRegistrySurfaceNames = documentedPublicComponentSurfaces.map((entry) => entry.registryName)
+export const standalonePublicRegistrySurfaceNames = standalonePublicComponentSurfaces.map((entry) => entry.registryName)
+export const publicRegistrySurfaceNames = publicComponentSurfaceEntries.map((entry) => entry.registryName)
+
+export function getPublicComponentSurfaceOrder(slug: string) {
+  return publicComponentSurfaceOrder.get(slug) ?? Number.MAX_SAFE_INTEGER
+}
+
+export function isPublicComponentSurfaceSlug(slug: string) {
+  return publicComponentSurfaceSlugSet.has(slug)
+}
+
+export function getPublicComponentRegistryName(slug: string) {
+  return publicComponentSurfaceRegistryMap.get(slug)
+}
+
+export function comparePublicComponentSurfaceOrder(leftSlug: string, rightSlug: string) {
+  return getPublicComponentSurfaceOrder(leftSlug) - getPublicComponentSurfaceOrder(rightSlug)
+}