@bridge-ui/vue 0.0.6 → 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/Actions/Snackbar/BridgeSnackbarAction.vue_vue_type_script_setup_true_lang.js

@@ -2,8 +2,8 @@ import { mergeNestedComponentProps as e } from "../../Utils/index.js";
 import t from "../../Components/Button/Button.js";
 import n from "../../Components/Link/Link.js";
 import { computed as r, createBlock as i, createTextVNode as a, defineComponent as o, mergeProps as s, openBlock as c, toDisplayString as l, unref as u, withCtx as d } from "vue";
-import { get as f } from "es-toolkit/compat";
-import { cn as p, snackbarRoundedProps as m } from "@bridge-ui/core";
+import { cn as f, snackbarRoundedProps as p } from "@bridge-ui/core";
+import { get as m } from "es-toolkit/compat";
 //#region src/Actions/Snackbar/BridgeSnackbarAction.vue?vue&type=script&setup=true&lang.ts
 var h = /* @__PURE__ */ o({
 	__name: "BridgeSnackbarAction",
@@ -23,24 +23,24 @@ var h = /* @__PURE__ */ o({
 			let { onClick: e, ...t } = g.action.link;
 			return t;
 		}), x = r(() => {
-			let e = f(m, g.snackbarRounded ?? "lg"), t = f(e, "tr"), n = f(e, "br");
-			return f({
+			let e = m(p, g.snackbarRounded ?? "lg"), t = m(e, "tr"), n = m(e, "br");
+			return m({
 				trailing: "mr-4 shrink-0",
-				"right-accept": p({
+				"right-accept": f({
 					"w-full rounded-none": !0,
 					[t ?? ""]: !0,
 					[n ?? ""]: !g.hasReject
 				}),
-				"right-reject": p({
+				"right-reject": f({
 					"w-full rounded-none": !0,
 					[n ?? ""]: !0,
 					[t ?? ""]: !g.hasAccept
 				})
 			}, g.layout, "");
-		}), S = r(() => p({
+		}), S = r(() => f({
 			[x.value]: !0,
 			[g.action.className ?? ""]: !0
-		})), C = r(() => e(b.value, { classes: { root: S.value } })), w = r(() => e(g.action.button, { classes: { root: p({
+		})), C = r(() => e(b.value, { classes: { root: S.value } })), w = r(() => e(g.action.button, { classes: { root: f({
 			[S.value]: !0,
 			"w-full": g.layout === "right-accept" || g.layout === "right-reject"
 		}) } }));

package/dist/Actions/Snackbar/BridgeSnackbarHost.vue_vue_type_script_setup_true_lang.js

@@ -3,8 +3,8 @@ import { BRIDGE_SNACKBAR_INJECTION_KEY as t } from "./bridgeSnackbarInjectionKey
 import n from "./BridgeSnackbarItem.js";
 import { createBridgeSnackbarApi as r } from "./createBridgeSnackbarApi.js";
 import { Fragment as i, Teleport as a, computed as o, createBlock as s, createElementBlock as c, createElementVNode as l, defineComponent as u, inject as d, normalizeClass as f, openBlock as p, provide as m, renderList as h, renderSlot as g, unref as _ } from "vue";
-import { get as v } from "es-toolkit/compat";
-import { cn as y, mergeBridgeUILayeredClasses as b, snackbarPositionProps as x } from "@bridge-ui/core";
+import { cn as v, mergeBridgeUILayeredClasses as y, snackbarPositionProps as b } from "@bridge-ui/core";
+import { get as x } from "es-toolkit/compat";
 //#region src/Actions/Snackbar/BridgeSnackbarHost.vue?vue&type=script&setup=true&lang.ts
 var S = "[Bridge UI] Nested <BridgeSnackbarHost /> detected. useSnackbarAction() will target the nearest host only. Remove the extra host.", C = /* @__PURE__ */ u({
 	__name: "BridgeSnackbarHost",
@@ -26,17 +26,17 @@ var S = "[Bridge UI] Nested <BridgeSnackbarHost /> detected. useSnackbarAction()
 			timeout: C.timeout
 		}), T = e();
 		m(t, w);
-		let E = o(() => w.entries.value), D = o(() => T?.components.value.Snackbar), O = o(() => C.position ?? D.value?.defaultProps?.position ?? "bottom-center"), k = o(() => v(b(x, D.value?.tokens?.position), O.value)), A = o(() => C.teleportTo === !1), j = o(() => C.teleportTo === !1 ? "body" : C.teleportTo), M = o(() => O.value.startsWith("top") ? "flex-col" : "flex-col-reverse");
+		let E = o(() => w.entries.value), D = o(() => T?.components.value.Snackbar), O = o(() => C.position ?? D.value?.defaultProps?.position ?? "bottom-center"), k = o(() => x(y(b, D.value?.tokens?.position), O.value)), A = o(() => C.teleportTo === !1), j = o(() => C.teleportTo === !1 ? "body" : C.teleportTo), M = o(() => O.value.startsWith("top") ? "flex-col" : "flex-col-reverse");
 		return (e, t) => (p(), c(i, null, [g(e.$slots, "default"), (p(), s(a, {
 			to: j.value,
 			disabled: A.value
 		}, [l("div", {
 			"data-snackbar-host": "",
-			class: f(_(y)({
+			class: f(_(v)({
 				"fixed inset-0 z-40 flex pointer-events-none px-4 py-6 sm:p-5 sm:pt-4": !0,
 				[k.value ?? ""]: !0
 			}))
-		}, [l("div", { class: f(_(y)({
+		}, [l("div", { class: f(_(v)({
 			"flex w-full max-w-sm gap-y-2 pointer-events-auto": !0,
 			[M.value]: !0
 		})) }, [(p(!0), c(i, null, h(E.value, (e) => (p(), s(n, {

package/dist/Actions/Snackbar/createBridgeSnackbarApi.js

@@ -1,47 +1,47 @@
 import { shallowRef as e } from "vue";
-import { isNil as t } from "es-toolkit/compat";
-import { closeAllLayers as n, closeLayer as r, closeTopLayer as i, createLayerId as a, createOpenLayerEntry as o, isLayerMounted as s, removeLayer as c, syncLayerShow as l, trimLayersToMax as u, updateLayerMerged as d } from "@bridge-ui/core";
+import { closeAllLayers as t, closeLayer as n, closeTopLayer as r, createLayerId as i, createOpenLayerEntry as a, isLayerMounted as o, removeLayer as s, syncLayerShow as c, trimLayersToMax as l, updateLayerMerged as u } from "@bridge-ui/core";
+import { isNil as d } from "es-toolkit/compat";
 //#region src/Actions/Snackbar/createBridgeSnackbarApi.ts
 function f(e, t) {
 	let { onClose: n, onClosed: r, ...i } = t;
-	return o(e, {
+	return a(e, {
 		props: i,
 		onClose: n,
 		onClosed: r
 	});
 }
-function p(e, n) {
-	return !t(e.duration) || t(n) ? e : {
+function p(e, t) {
+	return !d(e.duration) || d(t) ? e : {
 		...e,
-		duration: n
+		duration: t
 	};
 }
-function m(t = {}) {
-	let { max: o, timeout: m = 5e3 } = t, h = e([]);
+function m(a = {}) {
+	let { max: d, timeout: m = 5e3 } = a, h = e([]);
 	function g(e) {
-		let t = a(), n = h.value;
-		return o != null && o > 0 && (n = u(n, o)), h.value = [...n, f(t, p(e, m))], t;
+		let t = i(), n = h.value;
+		return d != null && d > 0 && (n = l(n, d)), h.value = [...n, f(t, p(e, m))], t;
 	}
 	function _(e) {
-		h.value = r(h.value, e);
+		h.value = n(h.value, e);
 	}
 	function v() {
-		h.value = i(h.value);
+		h.value = r(h.value);
 	}
 	function y() {
-		h.value = n(h.value);
+		h.value = t(h.value);
 	}
 	function b(e) {
-		return s(h.value, e);
+		return o(h.value, e);
 	}
 	function x(e) {
-		h.value = c(h.value, e);
+		h.value = s(h.value, e);
 	}
 	function S(e, t) {
-		h.value = d(h.value, e, t, ["props"]);
+		h.value = u(h.value, e, t, ["props"]);
 	}
 	function C(e, t) {
-		h.value = l(h.value, e, t);
+		h.value = c(h.value, e, t);
 	}
 	return {
 		open: g,

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

@@ -1 +1 @@
-export { setI18nAdapterForTests, useI18nAdapter, } from './useI18nAdapter';
+export { setI18nAdapterForTests, useI18nAdapter, useResolveMessage, } from './useI18nAdapter';

package/dist/Adapters/I18n/index.js

@@ -1,2 +1,2 @@
-import { setI18nAdapterForTests as e, useI18nAdapter as t } from "./useI18nAdapter.js";
-export { e as setI18nAdapterForTests, t as useI18nAdapter };
+import { setI18nAdapterForTests as e, useI18nAdapter as t, useResolveMessage as n } from "./useI18nAdapter.js";
+export { e as setI18nAdapterForTests, t as useI18nAdapter, n as useResolveMessage };

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

@@ -1,12 +1,16 @@
 import { ComputedRef } from 'vue';
-import { I18nAdapter } from '@bridge-ui/core';
+import { I18nAdapter, MessageParams } from '@bridge-ui/core';
 /**
  * Sets a process-wide i18n adapter fallback. For tests only.
  */
 export declare function setI18nAdapterForTests(adapter: undefined | I18nAdapter): void;
 /**
  * Returns the active i18n adapter from {@link BridgeUIProvider}.
- * When unset, `resolveMessage` returns the English source string
- * (see `examples/adapters/vue`).
+ * When unset, {@link useResolveMessage} returns the English source string
+ * (see `packages/vue/docs/examples`).
  */
 export declare function useI18nAdapter(): ComputedRef<undefined | I18nAdapter>;
+/**
+ * Resolves Bridge chrome strings through the active i18n adapter.
+ */
+export declare function useResolveMessage(): (message: string, params?: MessageParams) => string;

package/dist/Adapters/I18n/useI18nAdapter.js

@@ -1,13 +1,18 @@
 import { useBridgeUI as e } from "../../Provider/useBridgeUI.js";
 import { computed as t } from "vue";
+import { resolveMessage as n } from "@bridge-ui/core";
 //#region src/Adapters/I18n/useI18nAdapter.ts
-var n;
-function r(e) {
-	n = e;
+var r;
+function i(e) {
+	r = e;
 }
-function i() {
-	let r = e();
-	return t(() => r?.global.value.i18n ?? n);
+function a() {
+	let n = e();
+	return t(() => n?.global.value.i18n ?? r);
+}
+function o() {
+	let e = a();
+	return (t, r) => n(t, e.value, r);
 }
 //#endregion
-export { r as setI18nAdapterForTests, i as useI18nAdapter };
+export { i as setI18nAdapterForTests, a as useI18nAdapter, o as useResolveMessage };

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 `examples/adapters/vue`).
+ * Semantic icon names require `global.icons` (see `packages/vue/docs/examples`).
  */
 export declare function useIconAdapter(): ComputedRef<undefined | IconAdapter>;

package/dist/Adapters/index.d.ts

@@ -1,3 +1,3 @@
-export { setI18nAdapterForTests, useI18nAdapter } from './I18n';
+export { setI18nAdapterForTests, useI18nAdapter, useResolveMessage, } from './I18n';
 export { setIconAdapterForTests, useIconAdapter } from './Icon';
 export type { IconElement, IconSource, IconSourceValueOverrides, SemanticIconName, } from './Icon';

package/dist/Adapters/index.js

@@ -1,3 +1,3 @@
-import { setI18nAdapterForTests as e, useI18nAdapter as t } from "./I18n/useI18nAdapter.js";
-import { setIconAdapterForTests as n, useIconAdapter as r } from "./Icon/useIconAdapter.js";
-export { e as setI18nAdapterForTests, n as setIconAdapterForTests, t as useI18nAdapter, r as useIconAdapter };
+import { setI18nAdapterForTests as e, useI18nAdapter as t, useResolveMessage as n } from "./I18n/useI18nAdapter.js";
+import { setIconAdapterForTests as r, useIconAdapter as i } from "./Icon/useIconAdapter.js";
+export { e as setI18nAdapterForTests, r as setIconAdapterForTests, t as useI18nAdapter, i as useIconAdapter, n as useResolveMessage };