@ekanos/ui 0.1.0

package/dist/if.d.ts

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * The falsy values a condition may legitimately carry.
+ *
+ * This mirrors JavaScript's own falsy set as far as the type system can
+ * express it: `NaN` has no literal type, and `0n` is deliberately omitted so
+ * the emitted declaration stays usable by consumers whose `lib` predates
+ * ES2020 bigint literals.
+ */
+type Falsy = false | null | undefined | 0 | '';
+/** What a condition of type `Condition` narrows to once it passes. */
+type Truthy<Condition> = Exclude<Condition, Falsy>;
+type IfProps<Condition> = {
+    /** Rendered when truthy; otherwise `fallback` is rendered. */
+    condition: Condition;
+    /**
+     * Either static content, or a render function handed the condition narrowed
+     * to its truthy form — `condition={user}` passes a `User` to the callback,
+     * not a `User | undefined`.
+     */
+    children: ReactNode | ((value: Truthy<Condition>) => ReactNode);
+    /** Rendered when `condition` is falsy. Nothing renders when omitted. */
+    fallback?: ReactNode | (() => ReactNode);
+};
+/**
+ * Conditional renderer, so a branch reads as markup instead of a ternary.
+ *
+ * Deliberately hook-free: this ships from a module with no `'use client'`
+ * directive, so it must stay renderable from a React Server Component.
+ *
+ * `ReactNode` does not include functions, which makes `typeof x === 'function'`
+ * a sound discriminator between static content and a render callback.
+ */
+declare function If<Condition>({ condition, children, fallback, }: IfProps<Condition>): React.JSX.Element;
+
+export { If, type IfProps };

package/dist/if.js

@@ -0,0 +1,15 @@
+// src/_impl/if.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+function If({
+  condition,
+  children,
+  fallback
+}) {
+  if (condition) {
+    return /* @__PURE__ */ jsx(Fragment, { children: typeof children === "function" ? children(condition) : children });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: typeof fallback === "function" ? fallback() : fallback });
+}
+export {
+  If
+};

package/dist/input.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+
+declare function Input({ className, type, ...props }: React.ComponentProps<'input'>): React.JSX.Element;
+
+export { Input };

package/dist/input.js

@@ -0,0 +1,28 @@
+// ../ui/src/lib/utils/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// ../ui/src/shadcn/input.tsx
+import { jsx } from "react/jsx-runtime";
+function Input({ className, type, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      type,
+      "data-slot": "input",
+      className: cn(
+        "border-input selection:bg-primary selection:text-primary-foreground file:text-foreground placeholder:text-muted-foreground dark:bg-input/30 h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
+        "aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40",
+        className
+      ),
+      ...props
+    }
+  );
+}
+export {
+  Input
+};

package/dist/label.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+
+declare function Label({ className, ...props }: React.ComponentProps<'label'>): React.JSX.Element;
+
+export { Label };

package/dist/label.js

@@ -0,0 +1,27 @@
+'use client';
+
+// ../ui/src/lib/utils/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// ../ui/src/shadcn/label.tsx
+import { jsx } from "react/jsx-runtime";
+function Label({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "label",
+    {
+      "data-slot": "label",
+      className: cn(
+        "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+        className
+      ),
+      ...props
+    }
+  );
+}
+export {
+  Label
+};

package/dist/select.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { Select as Select$1 } from '@base-ui/react/select';
+
+/**
+ * Base UI's `<Select.Value>` renders the label of the selected item only when
+ * the root is given an `items` map — otherwise it stringifies the raw value, so
+ * a trigger shows `12months` instead of `12 months`. Deriving `items` from the
+ * `SelectItem` children a caller already declares keeps the Radix-era API
+ * (`<SelectValue />` shows the selected item's content) working everywhere
+ * without every call site restating its options.
+ */
+declare function Select<Value, Multiple extends boolean | undefined = false>({ children, items, ...props }: Select$1.Root.Props<Value, Multiple>): React.JSX.Element;
+declare function SelectGroup({ className, ...props }: Select$1.Group.Props): React.JSX.Element;
+declare function SelectValue({ className, ...props }: Select$1.Value.Props): React.JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: Select$1.Trigger.Props & {
+    size?: 'sm' | 'default';
+}): React.JSX.Element;
+declare function SelectContent({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, ...props }: Select$1.Popup.Props & Pick<Select$1.Positioner.Props, 'align' | 'alignOffset' | 'side' | 'sideOffset' | 'alignItemWithTrigger'>): React.JSX.Element;
+declare function SelectLabel({ className, ...props }: Select$1.GroupLabel.Props): React.JSX.Element;
+declare function SelectItem({ className, children, ...props }: Select$1.Item.Props): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: Select$1.Separator.Props): React.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: Select$1.ScrollUpArrow.Props): React.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: Select$1.ScrollDownArrow.Props): React.JSX.Element;
+
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue };