@sewadah/selaras 0.1.1

package/dist/runtime/utils/messages.js

@@ -0,0 +1,68 @@
+export const defaultMessages = {
+  loading: "Loading",
+  clear: "Clear",
+  close: "Close",
+  cancel: "Cancel",
+  continue: "Continue",
+  colorModeToggle: "Toggle color mode",
+  colorPicker: "Color picker",
+  colorPickerDescription: "Drag to adjust hue, saturation, and lightness",
+  search: "Search...",
+  searchDescription: "Type to filter, then use arrow keys and enter to select",
+  columns: "Columns",
+  filterPlaceholder: "Filter...",
+  previous: "Previous",
+  next: "Next",
+  first: "First",
+  last: "Last",
+  pagination: "Pagination",
+  datePicker: "Date picker",
+  datePickerDescription: "Use arrow keys to navigate days, enter to select",
+  dateRangePicker: "Date range picker",
+  dateRangePickerDescription: "Use arrow keys to navigate days, enter to select a start and end date",
+  timePicker: "Time picker",
+  timePickerDescription: "Use arrow keys to adjust the highlighted field",
+  pickTime: "Pick a time",
+  previousMonth: "Previous month",
+  nextMonth: "Next month",
+  previousYear: "Previous year",
+  nextYear: "Next year",
+  previousDecade: "Previous decade",
+  nextDecade: "Next decade",
+  pickDate: "Pick a date",
+  chooseMonth: "Choose month",
+  chooseYear: "Choose year",
+  hour: "Hour",
+  minute: "Minute",
+  done: "Done",
+  increment: "Increment",
+  decrement: "Decrement",
+  noOptions: "No options",
+  noResultsFound: "No results found",
+  noData: "No data",
+  expandRow: "Expand row",
+  collapseRow: "Collapse row",
+  maximize: "Maximize",
+  minimize: "Minimize",
+  removeItem: (label) => label ? `Remove ${label}` : "Remove",
+  moreItems: (count) => `+${count} more`,
+  avatarGroupOverflow: (count) => `+${count}`,
+  paginationInfo: (page, total) => `Page ${page} of ${total}`,
+  codeTabFallback: (index) => `Tab ${index}`,
+  dropFiles: "Drop files here or click to browse",
+  invalidFileType: (name) => `${name}: invalid file type`,
+  invalidFileSize: (name, max) => `${name}: exceeds the ${max} size limit`,
+  tooManyFiles: (max) => `Only ${max} file${max === 1 ? "" : "s"} allowed`,
+  showMore: "Show more",
+  showLess: "Show less",
+  selectFile: "Select a file to view its content",
+  toggleSidebar: "Toggle sidebar",
+  breadcrumb: "Breadcrumb",
+  showHiddenBreadcrumbItems: "Show hidden breadcrumb items",
+  commandPalette: "Command palette",
+  commandPaletteDescription: "Search for a command and press enter",
+  navigate: "Navigate",
+  select: "Select",
+  onThisPage: "On this page",
+  upToSize: (size) => `Up to ${size}`
+};

package/dist/runtime/utils/navigation-menu.d.ts

@@ -0,0 +1,32 @@
+export interface NavigationMenuItem {
+    label: string;
+    icon?: string;
+    to?: string;
+    disabled?: boolean;
+    /** Force active state - otherwise auto-detected against the current route when `to` is set. */
+    active?: boolean;
+    /** One level for horizontal (Reka's own real limit for its shared-viewport flyout); arbitrary depth for vertical, which falls back to a recursive accordion instead. */
+    children?: NavigationMenuItem[];
+    onSelect?: (event: Event) => void;
+    /** Targets this item's own named slots (`#{slot}`, `#{slot}-leading`, `#{slot}-label`, `#{slot}-trailing`, `#{slot}-content`) ahead of the generic `#item`/`#item-leading`/etc, when the named one is actually provided. */
+    slot?: string;
+    /**
+     * `'link'` (default) is a real navigable/selectable item - everything
+     * above applies. `'label'` renders a non-interactive section heading
+     * above the items that follow it in the same top-level array - only
+     * `label` (and optionally `icon`) are read, everything else is
+     * ignored. `'separator'` renders a thin divider line and reads nothing
+     * but still needs a unique `label` (unused for display) since every
+     * item's `label` doubles as its list key.
+     *
+     * Top-level only - a `children` array doesn't check this, so a nested
+     * tree can't group its own children under a sub-heading. A comparable
+     * reference's own "group" concept isn't a separate type here either -
+     * it's just a `'label'` item followed by the ordinary items it's meant
+     * to introduce, no wrapping structure needed for a flat array.
+     */
+    type?: 'link' | 'label' | 'separator';
+    /** Not read by NavigationMenu's own default rendering - carried purely so a custom #item-content/#{slot}-content slot override can display one (a "mega menu" style description under each link, say). */
+    description?: string;
+}
+export declare function isNavigationMenuItemActive(item: NavigationMenuItem, currentPath: string): boolean;

package/dist/runtime/utils/navigation-menu.js

@@ -0,0 +1,5 @@
+export function isNavigationMenuItemActive(item, currentPath) {
+  if (item.active !== void 0)
+    return item.active;
+  return item.to !== void 0 && item.to === currentPath;
+}

package/dist/runtime/utils/table-columns.d.ts

@@ -0,0 +1,30 @@
+import type { VNode } from 'vue';
+/**
+ * Builds TanStack ColumnDef-shaped plain objects from <SColumn>/<SColumnGroup>
+ * VNodes - read directly off slots.default(), before either component ever
+ * mounts. A ColumnGroup VNode always becomes a group def (columns: [...]
+ * recursing over its own children); a Column VNode always becomes a leaf
+ * def, forwarding its own default-slot function as the cell renderer.
+ *
+ * Loosely typed (`any`) rather than `ColumnDef<TFeatures, TData>` - this path
+ * can't statically connect a runtime-scanned column list back to a specific
+ * TData, the same accepted trade-off as SColumn's `field: string` prop. Power
+ * users who want full TanStack type inference use STable's `columns` prop
+ * instead of <SColumn> children.
+ */
+export declare function convertChildrenToColumns(vnodes: VNode[] | undefined): any[];
+/**
+ * Reads each leaf column's own `meta.pinned` (set from <SColumn pinned="...">
+ * by convertChildrenToColumns above) into the { start, end } shape
+ * TanStack v9's columnPinningFeature wants as table-level state - "start"/
+ * "end" is its own (RTL-aware) naming; `pinned="left"|"right"` is the
+ * public <SColumn> API since that's the more familiar term (matching a
+ * comparable reference's own column-freezing option), mapped 1:1
+ * assuming LTR. Declarative, one-way: pin arrangement comes from which
+ * columns you marked pinned in your template, not a separate piece of
+ * state to manage yourself.
+ */
+export declare function collectColumnPinning(columns: any[]): {
+    start: string[];
+    end: string[];
+};

package/dist/runtime/utils/table-columns.js

@@ -0,0 +1,89 @@
+import { Comment, Fragment, h, Text } from "vue";
+import Column from "../components/Column.js";
+import ColumnGroup from "../components/ColumnGroup.js";
+function toBooleanProp(value, defaultValue) {
+  if (value === void 0)
+    return defaultValue;
+  if (value === "")
+    return true;
+  return !!value;
+}
+function buildHeaderOrFooter(slot, fallback) {
+  if (!slot)
+    return fallback;
+  return (context) => h(Fragment, slot({ column: context.column }));
+}
+function flattenColumnChildren(vnodes) {
+  const result = [];
+  for (const vnode of vnodes) {
+    if (vnode.type === Comment) {
+      continue;
+    }
+    if (vnode.type === Fragment) {
+      const children = vnode.children;
+      if (Array.isArray(children))
+        result.push(...flattenColumnChildren(children));
+      continue;
+    }
+    if (vnode.type === Text) {
+      continue;
+    }
+    result.push(vnode);
+  }
+  return result;
+}
+export function convertChildrenToColumns(vnodes) {
+  if (!vnodes?.length)
+    return [];
+  return flattenColumnChildren(vnodes).map((vnode) => {
+    if (vnode.type === ColumnGroup) {
+      const props = vnode.props ?? {};
+      const slots = vnode.children ?? {};
+      const slotChildren = slots.default?.();
+      return {
+        header: buildHeaderOrFooter(slots.header, props.header),
+        footer: buildHeaderOrFooter(slots.footer, props.footer),
+        columns: convertChildrenToColumns(slotChildren)
+      };
+    }
+    if (vnode.type === Column) {
+      const props = vnode.props ?? {};
+      const slots = vnode.children ?? {};
+      return {
+        id: props.field,
+        accessorKey: props.field,
+        header: buildHeaderOrFooter(slots.header, props.header ?? props.field),
+        footer: buildHeaderOrFooter(slots.footer, props.footer),
+        enableSorting: toBooleanProp(props.sortable, true),
+        sortFn: "alphanumeric",
+        enableColumnFilter: toBooleanProp(props.filterable, false),
+        filterFn: "includesString",
+        meta: { pinned: props.pinned },
+        // A slot always returns an array of VNodes, even for a single
+        // child - TanStack's flexRender only recognizes a single VNode
+        // (isVNode check) or a component/string, so an array falls into
+        // its object branch and gets wrongly treated as a component
+        // (h(array, props)), rendering nothing. Wrapping in a Fragment
+        // gives flexRender one real VNode to render.
+        cell: slots.default ? (context) => h(Fragment, slots.default({ row: context.row.original, value: context.getValue() })) : (context) => context.getValue()
+      };
+    }
+    return null;
+  }).filter((column) => column !== null);
+}
+export function collectColumnPinning(columns) {
+  const start = [];
+  const end = [];
+  function visit(column) {
+    if (Array.isArray(column.columns)) {
+      column.columns.forEach(visit);
+      return;
+    }
+    if (column.meta?.pinned === "left")
+      start.push(column.id);
+    else if (column.meta?.pinned === "right")
+      end.push(column.id);
+  }
+  columns.forEach(visit);
+  return { start, end };
+}

package/dist/runtime/utils/table-export.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Builds a CSV string from a table's current filtered+sorted rows (every
+ * matching row across all pages, not just the current page -
+ * getPrePaginatedRowModel is the row model before pagination slices it
+ * down). Synthetic columns (the selection checkbox, the expand toggle) are
+ * skipped since they carry no exportable data. Pure and side-effect-free,
+ * separated from exportTableToCsv's actual download trigger so it's
+ * testable without a real DOM/Blob/anchor-click environment.
+ */
+export declare function tableToCsvString(table: any): string;
+/** Serializes the table to CSV via tableToCsvString and triggers a browser download. */
+export declare function exportTableToCsv(table: any, filename?: string): void;

package/dist/runtime/utils/table-export.js

@@ -0,0 +1,29 @@
+export function tableToCsvString(table) {
+  const columns = table.getVisibleLeafColumns().filter((column) => !column.id.startsWith("__"));
+  const rows = table.getPrePaginatedRowModel().rows;
+  function escapeCsvValue(value) {
+    const text = value === null || value === void 0 ? "" : String(value);
+    if (/[",\n]/.test(text))
+      return `"${text.replace(/"/g, '""')}"`;
+    return text;
+  }
+  function headerText(column) {
+    const header = column.columnDef.header;
+    return typeof header === "string" ? header : column.id;
+  }
+  const lines = [
+    columns.map(headerText).map(escapeCsvValue).join(","),
+    ...rows.map((row) => columns.map((column) => escapeCsvValue(row.getValue(column.id))).join(","))
+  ];
+  return lines.join("\n");
+}
+export function exportTableToCsv(table, filename = "table.csv") {
+  const csv = tableToCsvString(table);
+  const blob = new Blob([csv], { type: "text/csv;charset=utf-8;" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  link.click();
+  URL.revokeObjectURL(url);
+}

package/dist/runtime/utils/ui.d.ts

@@ -0,0 +1,124 @@
+import type { ComputedRef } from 'vue';
+export type UiSlotValue = string | ({
+    class?: string;
+} & Record<string, unknown>);
+export type UiProp<Slots extends string = string> = Partial<Record<Slots, UiSlotValue>>;
+/**
+ * tailwind-variants' own generated slot-function type is a union of several
+ * variant-prop shapes (one per possible variant combination, more of them
+ * the fewer variants a theme declares), each intersected with its `ClassProp`
+ * union (`{class} | {className}`, never both). No single hand-written object
+ * type is structurally assignable to every branch of that union at once, so
+ * `resolveSlot`/`useRootProps` are generic over the slot fn's real type
+ * instead of pinning it to one - avoiding a wrong-in-every-direction manual
+ * approximation (and the `as any` it previously forced on every call site).
+ * `any` in this constraint's parameter position is what makes the match
+ * trivially succeed regardless of that union's shape; the cast just inside
+ * each function body does the same for the one call they each make.
+ */
+type AnySlotFn = (opts?: any) => string;
+/**
+ * Applies a Tailwind v4 class-prefix (`@import "tailwindcss" prefix(tw);`)
+ * to a class string. The prefix always lands as the outermost segment of
+ * a class (`tw:hover:bg-red-500`, never `hover:tw:bg-red-500`), so this is
+ * a plain per-token prepend - no variant-aware parsing needed. `selaras-*`
+ * classes are hand-authored literal selectors (see theme.css), not
+ * Tailwind utilities, and must be skipped or they stop matching their own
+ * CSS. A token that already starts with `${prefix}:` is left alone too -
+ * a consumer's own `:ui` override or custom component can't be covered by
+ * Selaras's build-time safelist (module.ts only scans Selaras's own shipped
+ * files), so writing it already-prefixed themselves is the documented way
+ * to make Tailwind generate CSS for it; without this guard that would get
+ * double-prefixed into garbage instead of passing through untouched.
+ *
+ * `prefix` defaults to the `classPrefix` module option (threaded through
+ * via a build-time virtual module, `#build/selaras-class-prefix.mjs` -
+ * see module.ts) when omitted, so call sites wrapping a hardcoded literal
+ * class (`applyClassPrefix('sr-only')`) don't each need to read it
+ * themselves. Pass it explicitly only where the prefix is already in hand
+ * (as `resolveSlot` does) or in a unit test.
+ *
+ * `classString` itself is nullable despite the type: a `tv()` slot with no
+ * base classes and no active override (an empty-string slot like
+ * Accordion's `header`/`label`) resolves to `undefined`, not `''` - passed
+ * straight through here rather than crashing, the same as it would if
+ * this function didn't exist at all.
+ */
+export declare function applyClassPrefix(classString: string, prefix?: string): string;
+/**
+ * Strips a leading `${prefix}:` from each space-separated token of a class
+ * string - the inverse of `applyClassPrefix`'s per-token prepend. `resolveSlot`
+ * applies this to a `:ui` override *before* handing it to the slot function,
+ * because `tailwind-merge` (bundled by `tailwind-variants`) has no concept
+ * of Tailwind v4's `tw:`-style prefix syntax: a mixed merge - an unprefixed
+ * base class (`bg-[var(--ui-primary)]`) against an already-prefixed override
+ * (`tw:bg-red-500`, exactly what a consumer is documented to write once a
+ * prefix is configured) - never dedupes, confirmed directly (both classes
+ * survive as-is). Since Selaras's own safelist stylesheet loads after the
+ * consumer's own, that would mean Selaras's default silently wins over the
+ * consumer's override - the opposite of what `:ui` is for. Normalizing the
+ * override back to its unprefixed form before merging (where tailwind-merge
+ * already works correctly), then letting `applyClassPrefix` re-prefix the
+ * whole merged result afterward, sidesteps this - correct regardless of
+ * whether the bundled tailwind-merge version understands `tw:` syntax at all.
+ */
+export declare function stripClassPrefix(classString: string | undefined, prefix: string | null | undefined): string | undefined;
+/**
+ * Resolves a single slot's classes/attrs from a `:ui` override.
+ * A string override is treated as extra classes (tailwind-merge'd by the slot fn).
+ * An object override's `class` is merged the same way, everything else is
+ * applied as raw attrs/handlers via `mergeProps` (never tailwind-merged).
+ */
+export declare function resolveSlot<T extends AnySlotFn>(slotFn: T, override?: UiSlotValue): {
+    [x: string]: unknown;
+};
+/**
+ * Vue always merges a parent's fallthrough `class` onto a single-root
+ * component's root element via raw string concatenation - completely
+ * separate from (and unaware of) the tailwind-merge resolveSlot does. That
+ * means a plain `class="w-40"` on a component whose root slot has `w-full`
+ * can silently lose depending on Tailwind's generated CSS order, not source
+ * order - defeating the whole point of the :ui system.
+ *
+ * A component styling its root/base slot via resolveSlot should instead set
+ * `inheritAttrs: false`, fold the fallthrough class into that slot's :ui
+ * override with `withFallthroughClass` so it goes through tailwind-merge too,
+ * and bind `attrsWithoutClass` (not raw $attrs) alongside it so every other
+ * fallthrough attr still passes through untouched.
+ */
+export declare function useRootFallthrough(): {
+    fallthroughClass: ComputedRef<string | undefined>;
+    attrsWithoutClass: ComputedRef<{
+        [x: string]: unknown;
+        style?: import("vue").StyleValue;
+    }>;
+};
+/** Folds a fallthrough class into a slot's `:ui` override, ahead of resolveSlot. */
+export declare function withFallthroughClass(fallthroughClass: string | undefined, override?: UiSlotValue): UiSlotValue | undefined;
+/**
+ * Combines resolveSlot with useRootFallthrough for a component's root/base
+ * slot in one call - requires `defineOptions({ inheritAttrs: false })` on the
+ * component. Bind the result with a single `v-bind` (Vue's template compiler
+ * rejects two bare v-bind spreads on the same element).
+ */
+export declare function useRootProps<T extends AnySlotFn>(slotFn: () => T, override: () => UiSlotValue | undefined): ComputedRef<{
+    [x: string]: unknown;
+}>;
+/**
+ * Merges a component's global `app.config.ui.<key>` override, then any
+ * ancestor STheme's scoped `ui.<key>` override, into its base `tv()`
+ * theme - each layered via tv()'s own `extend` composition, so an
+ * override only needs to name the slots it actually changes. Falls back
+ * to the base theme untouched when neither exists.
+ */
+export declare function useComponentTheme<T extends (...args: any[]) => any>(key: string, base: T): ComputedRef<T>;
+/**
+ * The nearest (chain-merged) STheme `props.<key>` override, if any - a
+ * component reads this as its own prop's fallback, one level below its
+ * own explicit prop but above whatever hardcoded/tv() default it'd
+ * otherwise use (`props.size ?? useThemeProps('button').value.size`),
+ * mirroring the existing AvatarGroup/FormField "inject a default" precedent
+ * generically instead of each needing its own bespoke injection key.
+ */
+export declare function useThemeProps(key: string): ComputedRef<Record<string, unknown>>;
+export {};

package/dist/runtime/utils/ui.js

@@ -0,0 +1,74 @@
+import { tv } from "tailwind-variants";
+import { computed, inject, mergeProps, useAttrs } from "vue";
+import { classPrefix as globalClassPrefix } from "#build/selaras-class-prefix.mjs";
+import { useAppConfig } from "#imports";
+import { THEME_INJECTION_KEY } from "./injection-keys.js";
+export function applyClassPrefix(classString, prefix) {
+  if (!classString)
+    return classString;
+  const resolvedPrefix = prefix ?? globalClassPrefix ?? void 0;
+  if (!resolvedPrefix)
+    return classString;
+  return classString.split(/\s+/).filter(Boolean).map((cls) => cls.startsWith("selaras-") || cls.startsWith(`${resolvedPrefix}:`) ? cls : `${resolvedPrefix}:${cls}`).join(" ");
+}
+export function stripClassPrefix(classString, prefix) {
+  if (!classString || !prefix)
+    return classString;
+  return classString.split(/\s+/).filter(Boolean).map((cls) => cls.startsWith(`${prefix}:`) ? cls.slice(prefix.length + 1) : cls).join(" ");
+}
+export function resolveSlot(slotFn, override) {
+  const call = slotFn;
+  if (typeof override !== "object" || override === null) {
+    return { class: applyClassPrefix(call({ class: stripClassPrefix(override, globalClassPrefix) })) };
+  }
+  const { class: overrideClass, ...attrs } = override;
+  return mergeProps({ class: applyClassPrefix(call({ class: stripClassPrefix(overrideClass, globalClassPrefix) })) }, attrs);
+}
+export function useRootFallthrough() {
+  const attrs = useAttrs();
+  const fallthroughClass = computed(() => typeof attrs.class === "string" ? attrs.class : void 0);
+  const attrsWithoutClass = computed(() => {
+    const { class: _class, ...rest } = attrs;
+    return rest;
+  });
+  return { fallthroughClass, attrsWithoutClass };
+}
+export function withFallthroughClass(fallthroughClass, override) {
+  if (typeof override === "object" && override !== null) {
+    return { ...override, class: [fallthroughClass, override.class].filter(Boolean).join(" ") || void 0 };
+  }
+  return [fallthroughClass, override].filter(Boolean).join(" ") || void 0;
+}
+export function useRootProps(slotFn, override) {
+  const { fallthroughClass, attrsWithoutClass } = useRootFallthrough();
+  return computed(() => mergeProps(
+    attrsWithoutClass.value,
+    resolveSlot(slotFn(), withFallthroughClass(fallthroughClass.value, override()))
+  ));
+}
+function collectThemeChain(context, pick, key) {
+  const chain = [];
+  for (let current = context; current; current = current.parent) {
+    const value = pick(current)?.[key];
+    if (value)
+      chain.unshift(value);
+  }
+  return chain;
+}
+export function useComponentTheme(key, base) {
+  const appConfig = useAppConfig();
+  const themeContext = inject(THEME_INJECTION_KEY, void 0);
+  return computed(() => {
+    let result = base;
+    const globalOverride = appConfig.ui?.[key];
+    if (globalOverride)
+      result = tv({ extend: result, ...globalOverride });
+    for (const override of collectThemeChain(themeContext?.value, (c) => c.ui, key))
+      result = tv({ extend: result, ...override });
+    return result;
+  });
+}
+export function useThemeProps(key) {
+  const themeContext = inject(THEME_INJECTION_KEY, void 0);
+  return computed(() => Object.assign({}, ...collectThemeChain(themeContext?.value, (c) => c.props, key)));
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@sewadah/selaras",
+  "type": "module",
+  "version": "0.1.1",
+  "description": "A UI component library for Nuxt",
+  "license": "MIT",
+  "repository": "sewadahapp/selaras",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "style": "./dist/runtime/theme.css",
+      "import": "./dist/module.mjs"
+    },
+    "./directives": {
+      "types": "./dist/runtime/directives/index.d.ts",
+      "import": "./dist/runtime/directives/index.js"
+    },
+    "./types": {
+      "types": "./dist/runtime/types/index.d.ts",
+      "import": "./dist/runtime/types/index.js"
+    },
+    "./components/*": "./dist/runtime/components/*",
+    "./theme.css": "./dist/runtime/theme.css",
+    "./prose.css": "./dist/runtime/prose.css"
+  },
+  "main": "./dist/module.mjs",
+  "style": "./dist/runtime/theme.css",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ],
+      "directives": [
+        "./dist/runtime/directives/index.d.ts"
+      ],
+      "types": [
+        "./dist/runtime/types/index.d.ts"
+      ],
+      "components/*": [
+        "./dist/runtime/components/*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "bun run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:generate": "nuxt generate playground",
+    "dev:preview": "NODE_ENV=production bun playground/.output/server/index.mjs",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "bun run lint && bun run test && changelogen --bump && bun run prepack && npm publish --access public && bash scripts/tag-and-push-release.sh && changelogen gh release",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "peerDependencies": {
+    "tailwindcss": "^4.1.11"
+  },
+  "dependencies": {
+    "@internationalized/date": "^3.5.0",
+    "@nuxt/icon": "^1.10.3",
+    "@nuxt/kit": "^4.5.2",
+    "@nuxtjs/color-mode": "^4.0.1",
+    "@tailwindcss/oxide": "^4.1.11",
+    "@tailwindcss/vite": "^4.1.11",
+    "@tanstack/vue-table": "^9.1.2",
+    "@tanstack/vue-virtual": "^3.13.36",
+    "reka-ui": "^2.2.0",
+    "tailwind-merge": "^3.6.0",
+    "tailwind-variants": "^3.3.1",
+    "tw-animate-css": "^1.4.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^9.3.0",
+    "@nuxt/devtools": "^3.4.1",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.5.2",
+    "@nuxt/test-utils": "^4.1.0",
+    "@types/node": "latest",
+    "@vue/test-utils": "^2.4.11",
+    "better-sqlite3": "^13.0.3",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.8.1",
+    "happy-dom": "^20.11.6",
+    "nuxt": "^4.5.2",
+    "tailwindcss": "^4.1.11",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "vue-tsc": "^3.3.9"
+  }
+}