@bridge-ui/vue 0.0.7 → 0.0.8

package/bin/ai.mjs

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+/**
+ * Install Bridge UI agent guidelines, docs, and skills into a consumer app.
+ *
+ * Usage:
+ *   npx bridge-ui-vue-ai install|remove [--copy] [--cwd <dir>]
+ */
+
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  rmdirSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ---------------------------------------------------------------------------
+// Package context
+// ---------------------------------------------------------------------------
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+
+const packageName = pkg.name;
+const aiRoot = join(packageRoot, "ai");
+const docsRoot = join(packageRoot, "docs");
+const binName = Object.keys(pkg.bin ?? {})[0] ?? "bridge-ui-ai";
+
+const MARK_END = "<!-- bridge-ui-ai:end -->";
+const MARK_START = "<!-- bridge-ui-ai:start -->";
+const MARK_BLOCK = new RegExp(`${MARK_START}[\\s\\S]*?${MARK_END}`, "m");
+const MARK_BLOCK_PADDED = new RegExp(
+  `\\n*${MARK_START}[\\s\\S]*?${MARK_END}\\n*`,
+  "m",
+);
+
+/** Paths linked/copied into the consumer app (relative dest → absolute source). */
+function installTargets() {
+  return [
+    { dest: ".ai/docs", src: docsRoot },
+    { dest: "llms.txt", src: join(aiRoot, "llms.txt") },
+    { dest: ".ai/AGENTS.md", src: join(aiRoot, "AGENTS.md") },
+    { dest: ".ai/guidelines", src: join(aiRoot, "guidelines") },
+  ].filter(({ src }) => existsSync(src));
+}
+
+function skillTargets() {
+  const skillsDir = join(aiRoot, "skills");
+
+  if (!existsSync(skillsDir)) return [];
+
+  return readdirSync(skillsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort()
+    .map((name) => ({
+      dest: join(".cursor", "skills", name),
+      src: join(skillsDir, name),
+    }));
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+function printHelp() {
+  console.log(`Usage: ${binName} <command> [options]
+
+Commands:
+  install   Link (or copy) AI guidelines, docs, and skills into the app
+  remove    Remove links/copies created by install
+  help      Show this help
+
+Options:
+  --copy    Copy files instead of symlinking (Windows / PnP fallback)
+  --cwd     App root (default: process.cwd())
+`);
+}
+
+function parseArgs(argv) {
+  const args = { command: "help", copy: false, cwd: process.cwd() };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === "--copy") {
+      args.copy = true;
+    } else if (arg === "--cwd") {
+      args.cwd = resolve(argv[++i] ?? process.cwd());
+    } else if (arg === "-h" || arg === "--help") {
+      args.command = "help";
+    } else if (!arg.startsWith("-") && args.command === "help") {
+      args.command = arg;
+    }
+  }
+
+  return args;
+}
+
+// ---------------------------------------------------------------------------
+// Filesystem helpers
+// ---------------------------------------------------------------------------
+
+function pathExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removePath(path) {
+  if (!pathExists(path)) return;
+
+  rmSync(path, { recursive: true, force: true });
+}
+
+function linkTypeFor(target) {
+  if (lstatSync(target).isDirectory()) {
+    return process.platform === "win32" ? "junction" : "dir";
+  }
+
+  return "file";
+}
+
+/** @returns {"linked" | "copied"} */
+function linkOrCopy(target, dest, { copy }) {
+  mkdirSync(dirname(dest), { recursive: true });
+  removePath(dest);
+
+  if (!copy) {
+    try {
+      symlinkSync(target, dest, linkTypeFor(target));
+      return "linked";
+    } catch (err) {
+      console.warn(`Symlink failed (${err.message}); falling back to copy.`);
+    }
+  }
+
+  cpSync(target, dest, { recursive: true });
+
+  return "copied";
+}
+
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function resolvesUnder(path, root, fileName) {
+  if (!pathExists(path)) return false;
+  try {
+    const real = realpathSync(path);
+
+    return real === join(root, fileName) || real.startsWith(`${root}/`);
+  } catch {
+    return false;
+  }
+}
+
+/** True when `path` is a real file whose contents match the package AGENTS.md. */
+function isPackageAgentsCopy(path) {
+  const src = join(aiRoot, "AGENTS.md");
+
+  if (!existsSync(src) || !existsSync(path) || isSymlink(path)) {
+    return false;
+  }
+
+  try {
+    return readFileSync(path, "utf8") === readFileSync(src, "utf8");
+  } catch {
+    return false;
+  }
+}
+
+function removeEmptyDir(path) {
+  try {
+    rmdirSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function cleanupEmptyDirs(appRoot) {
+  const cleaned = [];
+
+  for (const rel of [".ai", join(".cursor", "skills"), ".cursor"]) {
+    if (removeEmptyDir(join(appRoot, rel))) {
+      cleaned.push(rel.replaceAll("\\", "/"));
+    }
+  }
+
+  return cleaned;
+}
+
+function assertAiPresent() {
+  if (existsSync(aiRoot)) return;
+  console.error(`Missing AI resources in ${packageName}: expected ${aiRoot}`);
+
+  process.exit(1);
+}
+
+function logResults(title, results) {
+  console.log(title);
+
+  for (const { mode, dest } of results) {
+    console.log(`  ${String(mode).padEnd(7)} ${dest}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// AGENTS.md / CLAUDE.md
+// ---------------------------------------------------------------------------
+
+function agentsSnippet(skills) {
+  const skillList = skills
+    .map(({ dest }) => `- \`${dest.replaceAll("\\", "/")}\``)
+    .join("\n");
+
+  return `${MARK_START}
+## Bridge UI
+
+This app uses **${packageName}**. Full agent guide: \`.ai/AGENTS.md\` (also see \`llms.txt\`).
+
+- Docs: \`.ai/docs/\` (component API and examples)
+- Guidelines: \`.ai/guidelines/core.md\`
+- Skills (on demand):
+${skillList}
+
+Install/update: \`npx ${binName} install\`
+${MARK_END}
+`;
+}
+
+function upsertAgentsMd(appRoot, skills) {
+  let next;
+  const snippet = agentsSnippet(skills);
+  const path = join(appRoot, "AGENTS.md");
+
+  // Never write through a symlink (would mutate package sources under file: installs).
+  if (isSymlink(path)) {
+    removePath(path);
+  }
+
+  if (!existsSync(path)) {
+    // Stub only — strip on remove deletes the file cleanly.
+    next = `${snippet.trimEnd()}\n`;
+  } else {
+    const prev = readFileSync(path, "utf8");
+
+    if (prev.includes(MARK_START) && prev.includes(MARK_END)) {
+      next = prev.replace(MARK_BLOCK, snippet.trimEnd());
+    } else {
+      next = `${prev.trimEnd()}\n\n${snippet}\n`;
+    }
+  }
+
+  writeFileSync(path, next.endsWith("\n") ? next : `${next}\n`);
+  return path;
+}
+
+function stripAgentsMd(appRoot) {
+  const path = join(appRoot, "AGENTS.md");
+
+  if (!pathExists(path)) return null;
+
+  // Legacy installs that linked/copied the full package guide to the root.
+  if (isPackageAgentsCopy(path) || resolvesUnder(path, aiRoot, "AGENTS.md")) {
+    removePath(path);
+    return path;
+  }
+
+  if (!existsSync(path)) return null;
+
+  const prev = readFileSync(path, "utf8");
+
+  if (!prev.includes(MARK_START)) return null;
+
+  const next = prev.replace(MARK_BLOCK_PADDED, "\n").trimEnd();
+
+  if (!next.trim()) {
+    rmSync(path, { force: true });
+    return path;
+  }
+
+  writeFileSync(path, `${next}\n`);
+
+  return path;
+}
+
+/**
+ * Root AGENTS.md is always a short stub (or inject into the app's own file).
+ * Full guide lives at `.ai/AGENTS.md` only.
+ */
+function installRootAgents(appRoot, skills) {
+  const dest = join(appRoot, "AGENTS.md");
+  const rel = relative(appRoot, dest);
+
+  // Legacy full-guide link/copy or foreign Bridge symlink → replace with stub.
+  if (
+    isSymlink(dest) ||
+    isPackageAgentsCopy(dest) ||
+    resolvesUnder(dest, aiRoot, "AGENTS.md")
+  ) {
+    removePath(dest);
+  }
+
+  upsertAgentsMd(appRoot, skills);
+
+  return { dest: rel, mode: "updated" };
+}
+
+/** True when CLAUDE.md is our symlink/copy of the root AGENTS.md stub. */
+function isClaudeBridgeManaged(appRoot, claudePath) {
+  const agents = join(appRoot, "AGENTS.md");
+
+  if (!pathExists(claudePath) || !pathExists(agents)) return false;
+
+  if (isSymlink(claudePath)) {
+    try {
+      return realpathSync(claudePath) === realpathSync(agents);
+    } catch {
+      try {
+        const target = readlinkSync(claudePath);
+
+        return resolve(dirname(claudePath), target) === agents;
+      } catch {
+        return false;
+      }
+    }
+  }
+
+  try {
+    return readFileSync(claudePath, "utf8") === readFileSync(agents, "utf8");
+  } catch {
+    return false;
+  }
+}
+
+function installClaudeMd(appRoot, { copy }) {
+  const dest = join(appRoot, "CLAUDE.md");
+  const agents = join(appRoot, "AGENTS.md");
+
+  if (!existsSync(agents)) return null;
+
+  // App already has its own CLAUDE.md → leave it alone.
+  if (pathExists(dest) && !isClaudeBridgeManaged(appRoot, dest)) {
+    return null;
+  }
+
+  return {
+    dest: "CLAUDE.md",
+    mode: linkOrCopy(agents, dest, { copy }),
+  };
+}
+
+function stripClaudeMd(appRoot) {
+  const path = join(appRoot, "CLAUDE.md");
+
+  if (!isClaudeBridgeManaged(appRoot, path)) return null;
+
+  removePath(path);
+  return path;
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+function install({ cwd: appRoot, copy }) {
+  assertAiPresent();
+
+  const results = [];
+  const skills = skillTargets();
+
+  for (const { src, dest } of [...installTargets(), ...skills]) {
+    results.push({
+      dest,
+      mode: linkOrCopy(src, join(appRoot, dest), { copy }),
+    });
+  }
+
+  results.push(installRootAgents(appRoot, skills));
+
+  const claude = installClaudeMd(appRoot, { copy });
+
+  if (claude) results.push(claude);
+
+  logResults(`Installed Bridge UI AI resources from ${packageName}`, results);
+
+  console.log(`\nPackage AI root: ${aiRoot}`);
+
+  try {
+    console.log(`Resolved: ${realpathSync(aiRoot)}`);
+  } catch {
+    /* ignore */
+  }
+}
+
+function remove({ cwd: appRoot }) {
+  const removed = [];
+
+  for (const { dest } of [...installTargets(), ...skillTargets()]) {
+    const absolute = join(appRoot, dest);
+
+    if (!pathExists(absolute)) continue;
+
+    removePath(absolute);
+    removed.push(dest);
+  }
+
+  // CLAUDE before AGENTS so content/realpath checks still resolve.
+  const claude = stripClaudeMd(appRoot);
+  const agents = stripAgentsMd(appRoot);
+  const emptyDirs = cleanupEmptyDirs(appRoot);
+
+  console.log(`Removed Bridge UI AI resources for ${packageName}`);
+
+  for (const path of removed) {
+    console.log(`  removed ${path}`);
+  }
+
+  if (claude) {
+    console.log(`  cleaned ${relative(appRoot, claude)}`);
+  }
+
+  if (agents) {
+    console.log(`  cleaned ${relative(appRoot, agents)}`);
+  }
+
+  for (const dir of emptyDirs) {
+    console.log(`  removed ${dir}/`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Entry
+// ---------------------------------------------------------------------------
+
+const args = parseArgs(process.argv.slice(2));
+
+switch (args.command) {
+  case "install":
+    install(args);
+    break;
+  case "remove":
+    remove(args);
+    break;
+  case "help":
+    printHelp();
+    break;
+  default:
+    printHelp();
+    process.exitCode = 1;
+}

package/dist/Adapters/I18n/useI18nAdapter.d.ts

@@ -7,7 +7,7 @@ export declare function setI18nAdapterForTests(adapter: undefined | I18nAdapter)
 /**
  * Returns the active i18n adapter from {@link BridgeUIProvider}.
  * When unset, {@link useResolveMessage} returns the English source string
- * (see `packages/vue/examples`).
+ * (see `packages/vue/docs/examples`).
  */
 export declare function useI18nAdapter(): ComputedRef<undefined | I18nAdapter>;
 /**

package/dist/Adapters/Icon/useIconAdapter.d.ts

@@ -6,6 +6,6 @@ import { IconAdapter } from '@bridge-ui/core';
 export declare function setIconAdapterForTests(adapter: undefined | IconAdapter): void;
 /**
  * Returns the active icon adapter from {@link BridgeUIProvider}.
- * Semantic icon names require `global.icons` (see `packages/vue/examples`).
+ * Semantic icon names require `global.icons` (see `packages/vue/docs/examples`).
  */
 export declare function useIconAdapter(): ComputedRef<undefined | IconAdapter>;

package/dist/Components/Autocomplete/Autocomplete.vue.d.ts

@@ -9,26 +9,26 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {
     clear: () => any;
     search: (query: string) => any;
     select: (option: import('@bridge-ui/core').ListboxOption) => any;
-    "update:modelValue": (...args: unknown[]) => any;
     change: (value: import('@bridge-ui/core').SelectModel) => any;
     close: () => any;
-    open: () => any;
     deselect: (option: import('@bridge-ui/core').ListboxOption) => any;
+    open: () => any;
+    "update:modelValue": (...args: unknown[]) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onClear?: (() => any) | undefined;
     onSearch?: ((query: string) => any) | undefined;
     onSelect?: ((option: import('@bridge-ui/core').ListboxOption) => any) | undefined;
-    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
     onChange?: ((value: import('@bridge-ui/core').SelectModel) => any) | undefined;
     onClose?: (() => any) | undefined;
-    onOpen?: (() => any) | undefined;
     onDeselect?: ((option: import('@bridge-ui/core').ListboxOption) => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
 }>, {
     showErrorIcon: boolean;
     clearable: boolean;
+    freeSolo: boolean;
     minItemsForSearch: number;
     searchable: boolean;
-    freeSolo: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/Components/Autocomplete/composables/useAutocomplete.d.ts

@@ -436,7 +436,7 @@ export declare function useAutocomplete(props: AutocompleteOwnProps, model: Ref<
             onTransitionend?: ((payload: TransitionEvent) => void) | undefined;
             onTransitionrun?: ((payload: TransitionEvent) => void) | undefined;
             onTransitionstart?: ((payload: TransitionEvent) => void) | undefined;
-        }, Partial<Omit<Omit<FormFieldOwnProps, "field">, "error" | "color" | "end" | "size" | "classes" | "customProps" | "rounded" | "variant" | "label" | "disabled" | "endIcon" | "startIcon" | "start" | "required" | "description" | "errorMessage" | "hideErrorMessage" | "readonly" | "errorIcon" | "showErrorIcon" | "corner">>>>;
+        }, Partial<Omit<Omit<FormFieldOwnProps, "field">, "error" | "color" | "end" | "size" | "classes" | "customProps" | "rounded" | "variant" | "label" | "disabled" | "required" | "corner" | "description" | "errorMessage" | "start" | "endIcon" | "errorIcon" | "hideErrorMessage" | "readonly" | "showErrorIcon" | "startIcon">>>>;
         isNotched: import('vue').ComputedRef<boolean>;
         isStacked: import('vue').ComputedRef<boolean>;
         startBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<object, "class", import('vue').HTMLAttributes | undefined, {}>>;
@@ -719,13 +719,14 @@ export declare function useAutocomplete(props: AutocompleteOwnProps, model: Ref<
         onTransitionend?: ((payload: TransitionEvent) => void) | undefined;
         onTransitionrun?: ((payload: TransitionEvent) => void) | undefined;
         onTransitionstart?: ((payload: TransitionEvent) => void) | undefined;
-    }, Partial<Omit<Omit<FormFieldOwnProps, "field">, "error" | "color" | "end" | "size" | "classes" | "customProps" | "rounded" | "variant" | "label" | "disabled" | "endIcon" | "startIcon" | "start" | "required" | "description" | "errorMessage" | "hideErrorMessage" | "readonly" | "errorIcon" | "showErrorIcon" | "corner">>>>>;
+    }, Partial<Omit<Omit<FormFieldOwnProps, "field">, "error" | "color" | "end" | "size" | "classes" | "customProps" | "rounded" | "variant" | "label" | "disabled" | "required" | "corner" | "description" | "errorMessage" | "start" | "endIcon" | "errorIcon" | "hideErrorMessage" | "readonly" | "showErrorIcon" | "startIcon">>>>>;
     selectOption: (option: SelectOption) => void;
     containerRef: Ref<HTMLElement | null, HTMLElement | null>;
     listboxProps: import('vue').ComputedRef<{
         anchorEl?: null | HTMLElement;
         classes?: import('../../Listbox').ListboxClasses;
         color: "info" | "error" | "success" | "warning" | "dark" | "primary" | "secondary";
+        componentName: "Select" | "Autocomplete";
         customProps?: import('../../Listbox').ListboxCustomProps;
         disableAutoFocus: boolean;
         disableMaxHeight: boolean;

package/dist/Components/Autocomplete/composables/useAutocomplete.js

@@ -136,6 +136,7 @@ function g(g, _, v, y, Ce) {
 		variant: "outline",
 		showErrorIcon: !0
 	}, {
+		componentName: "Autocomplete",
 		likeInput: () => P.value,
 		control: () => P.value ? "textarea" : "input"
 	}), J = (e) => {
@@ -255,13 +256,15 @@ function g(g, _, v, y, Ce) {
 	}
 	let Qe = a(() => {
 		let e = h(d(be, h(Ee.value, [
-			"Listbox",
+			"Autocomplete",
 			"tokens",
+			"listbox",
 			"color"
 		])), q.merged.value.color ?? "primary");
 		return q.invalidated.value ? d(xe, h(Ee.value, [
-			"Listbox",
+			"Autocomplete",
 			"tokens",
+			"listbox",
 			"invalidated"
 		])) : e;
 	}), $e = a(() => Qe.value?.value), et = a(() => {
@@ -330,6 +333,7 @@ function g(g, _, v, y, Ce) {
 		size: q.merged.value.size,
 		color: q.merged.value.color,
 		labelledBy: q.controlId.value,
+		componentName: "Autocomplete",
 		rounded: q.merged.value.rounded,
 		invalidated: q.invalidated.value,
 		highlightedIndex: T.value,

package/dist/Components/Avatar/composables/useAvatar.d.ts

@@ -7,7 +7,7 @@ export declare function useAvatar(props: AvatarProps, libDefaults: AvatarLibDefa
         [name: string]: import('vue').Slot<any> | undefined;
     }>;
     merged: import('vue').ComputedRef<AvatarMerged>;
-    rootBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<object, "class", import('vue').HTMLAttributes | undefined, Omit<AvatarProps, "color" | "icon" | "size" | "classes" | "customProps" | "rounded" | "alt" | "fallback" | "src">>>;
+    rootBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<object, "class", import('vue').HTMLAttributes | undefined, Omit<AvatarProps, "color" | "icon" | "size" | "classes" | "customProps" | "rounded" | "alt" | "src" | "fallback">>>;
     iconBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<object, "class", Partial<Omit<import('../../Icon').IconProps, "icon">> | undefined, {}>>;
     hasImage: import('vue').ComputedRef<boolean>;
     imageBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<object, "class", import('vue').ImgHTMLAttributes | undefined, {

package/dist/Components/BaseField/BaseField.js

@@ -0,0 +1,5 @@
+import e from "./BaseField.vue_vue_type_script_setup_true_lang.js";
+//#region src/Components/BaseField/BaseField.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Components/BaseField/BaseField.vue.d.ts

@@ -0,0 +1,15 @@
+import { BaseFieldSlots } from './baseField.types';
+import { UseBaseFieldReturn } from './composables/useBaseField';
+type __VLS_Slots = BaseFieldSlots;
+type __VLS_Props = {
+    field: UseBaseFieldReturn;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/BaseField/BaseField.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,41 @@
+import { hasNamedSlot as e, hasSlotOrProp as t, resolveNamedSlot as n, resolveSlotOrProp as r } from "../../Utils/slotOrProp.js";
+import i from "./BaseFieldLabel.js";
+import { computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, createElementVNode as l, createVNode as u, defineComponent as d, guardReactiveProps as f, mergeProps as p, normalizeProps as m, openBlock as h, renderSlot as g, resolveDynamicComponent as _, unref as v, useSlots as y } from "vue";
+//#region src/Components/BaseField/BaseField.vue?vue&type=script&setup=true&lang.ts
+var b = [
+	"data-invalid",
+	"aria-disabled",
+	"aria-readonly"
+], x = ["id"], S = ["id", "aria-hidden"], C = /* @__PURE__ */ d({
+	inheritAttrs: !1,
+	__name: "BaseField",
+	props: { field: {} },
+	setup(d) {
+		let C = d, w = y(), T = a(() => ({
+			...C.field,
+			slots: {
+				...C.field.slots,
+				...w
+			}
+		})), E = a(() => t(T.value.slots, "label", T.value.merged.value.label) || t(T.value.slots, "corner", T.value.merged.value.corner));
+		return (a, d) => (h(), c("div", p(T.value.rootBind.value, {
+			"data-invalid": T.value.invalidated.value || void 0,
+			"aria-disabled": T.value.isDisabled.value || void 0,
+			"aria-readonly": T.value.isReadonly.value || void 0
+		}), [
+			E.value ? (h(), c("div", m(p({ key: 0 }, T.value.headerBind.value)), [u(i, { api: T.value }, null, 8, ["api"]), v(t)(T.value.slots, "corner", T.value.merged.value.corner) ? (h(), c("span", m(p({ key: 0 }, T.value.cornerBind.value)), [(h(), o(_(v(r)(T.value.slots, "corner", T.value.merged.value.corner))))], 16)) : s("", !0)], 16)) : s("", !0),
+			l("div", m(f(T.value.groupBind.value)), [
+				v(e)(T.value.slots, "start") ? (h(), c("div", m(p({ key: 0 }, T.value.startSlotBind.value)), [(h(), o(_(v(n)(T.value.slots, "start"))))], 16)) : s("", !0),
+				g(a.$slots, "default"),
+				v(e)(T.value.slots, "end") ? (h(), c("div", m(p({ key: 1 }, T.value.endSlotBind.value)), [(h(), o(_(v(n)(T.value.slots, "end"))))], 16)) : s("", !0)
+			], 16),
+			!T.value.invalidated.value && v(t)(T.value.slots, "description", T.value.merged.value.description) ? (h(), c("p", p({ key: 1 }, T.value.descriptionBind.value, { id: `${T.value.controlId.value}-description` }), [(h(), o(_(v(r)(T.value.slots, "description", T.value.merged.value.description))))], 16, x)) : s("", !0),
+			T.value.merged.value.hideErrorMessage ? s("", !0) : (h(), c("p", p({ key: 2 }, T.value.errorBind.value, {
+				id: `${T.value.controlId.value}-error`,
+				"aria-hidden": T.value.showErrorMessageContent.value ? void 0 : !0
+			}), [T.value.showErrorMessageContent.value ? (h(), o(_(v(r)(T.value.slots, "errorMessage", T.value.merged.value.errorMessage)), { key: 0 })) : s("", !0)], 16, S))
+		], 16, b));
+	}
+});
+//#endregion
+export { C as default };

package/dist/Components/BaseField/BaseFieldLabel.js

@@ -0,0 +1,5 @@
+import e from "./BaseFieldLabel.vue_vue_type_script_setup_true_lang.js";
+//#region src/Components/BaseField/BaseFieldLabel.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Components/{OtpField/OtpFieldLabel.vue.d.ts → BaseField/BaseFieldLabel.vue.d.ts}

@@ -1,6 +1,6 @@
-import { UseOtpFieldReturn } from './composables/useOtpField';
+import { UseBaseFieldReturn } from './composables/useBaseField';
 type __VLS_Props = {
-    api: UseOtpFieldReturn;
+    api: UseBaseFieldReturn;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;