@wssto2/vue-core 0.1.0 → 0.3.0

package/dist/suggestions-BJAqOj4c.js

@@ -0,0 +1,138 @@
+import { inject as O, shallowRef as S, ref as p, computed as y, onBeforeUnmount as R } from "vue";
+import { i as x } from "./error-CD7x0Jrz.js";
+import { c as m } from "./options-BXkMR63B.js";
+const W = Symbol("vue-core.recentChoices"), D = 5, j = (e) => {
+  if (typeof e != "object" || e === null) return !1;
+  const n = e;
+  return (typeof n.value == "string" || typeof n.value == "number") && typeof n.label == "string";
+}, J = {
+  read(e) {
+    try {
+      const n = JSON.parse(localStorage.getItem(`vue-core.recent.${e}`) ?? "[]");
+      return Array.isArray(n) ? n.filter(j).slice(0, D) : [];
+    } catch {
+      return [];
+    }
+  },
+  write(e, n) {
+    try {
+      localStorage.setItem(`vue-core.recent.${e}`, JSON.stringify(n));
+    } catch {
+    }
+  }
+};
+function _(e, n) {
+  const r = m(n.trim());
+  if (r === "") return { before: "", match: "", after: e };
+  let s = "";
+  const c = [];
+  let a = 0;
+  for (const d of e) {
+    const v = m(d);
+    for (let h = 0; h < v.length; h++) c.push(a);
+    s += v, a += d.length;
+  }
+  const o = s.indexOf(r);
+  if (o < 0) return { before: "", match: "", after: e };
+  const u = c[o] ?? 0, i = c[o + r.length] ?? e.length;
+  return { before: e.slice(0, u), match: e.slice(u, i), after: e.slice(i) };
+}
+function q(e, n) {
+  return e === "" || n.length <= e.length ? "" : n.toLocaleLowerCase().startsWith(e.toLocaleLowerCase()) ? n.slice(e.length) : "";
+}
+function K(e, n) {
+  const r = m(n.trim());
+  if (r === "") return [...e];
+  const s = [], c = [];
+  for (const a of e) {
+    const o = m(a.label);
+    o.startsWith(r) ? s.push(a) : (o.includes(r) || a.description !== void 0 && m(a.description).includes(r)) && c.push(a);
+  }
+  return [...s, ...c];
+}
+function z(e, n, r, s) {
+  return e && (n > 0 || r === "loading" || r === "failed" || r === "loaded" && s);
+}
+function P() {
+  const e = S([]), n = p("idle");
+  let r = 0, s = null;
+  function c() {
+    r++, s?.abort(), s = null;
+  }
+  async function a(o, u = (i) => i) {
+    c();
+    const i = r;
+    s = new AbortController(), n.value = "loading";
+    try {
+      const d = await o(s.signal);
+      if (i !== r) return;
+      e.value = u(d), n.value = "loaded";
+    } catch (d) {
+      if (i !== r || x(d)) return;
+      e.value = [], n.value = "failed";
+    }
+  }
+  return { items: e, status: n, run: a, cancel: c };
+}
+function F(e) {
+  const n = O(W, J), r = P(), { items: s, status: c } = r, a = S([]), o = p(!1), u = p(0), i = p(!1);
+  let d = "", v = null;
+  const h = y(() => c.value === "idle" ? a.value : s.value), T = y(() => c.value === "idle" && a.value.length > 0), w = y(() => h.value[u.value]);
+  function g() {
+    r.cancel(), v && clearTimeout(v), v = null;
+  }
+  R(g);
+  function b(t) {
+    return u.value = 0, i.value = !1, t.slice(0, e.limit());
+  }
+  const E = (t, l) => r.run((f) => l(t, { signal: f }), b);
+  function L(t) {
+    d = t, g(), o.value = !0;
+    const l = e.source(), f = t.trim() === "";
+    if (!l || f && !e.listAllWhenEmpty || typeof l == "function" && t.trim().length < e.minLength()) {
+      c.value = "idle", s.value = [], u.value = 0, i.value = !1;
+      return;
+    }
+    typeof l == "function" ? v = setTimeout(() => void E(t, l), e.debounce()) : (s.value = b(K(l, t)), c.value = "loaded");
+  }
+  function k(t) {
+    const l = e.recents();
+    a.value = l ? n.read(l) : [], L(t), o.value = h.value.length > 0;
+  }
+  function A() {
+    g(), o.value = !1, c.value === "loading" && (c.value = "idle");
+  }
+  function I(t) {
+    const l = e.recents();
+    if (!l) return;
+    const f = n.read(l).filter((N) => N.value !== t.value);
+    n.write(l, [{ value: t.value, label: t.label, ...t.description !== void 0 ? { description: t.description } : {} }, ...f].slice(0, D));
+  }
+  function C(t, l = !0) {
+    u.value = t, l && (i.value = !0);
+  }
+  function M(t, l) {
+    if (t.key === "Escape" && o.value)
+      t.stopPropagation(), t.preventDefault(), A();
+    else if (t.key === "ArrowDown" || t.key === "ArrowUp") {
+      if (t.preventDefault(), !o.value) {
+        k(d), o.value = !0;
+        return;
+      }
+      const f = h.value.length - 1;
+      C(t.key === "ArrowDown" ? Math.min(u.value + 1, f) : Math.max(u.value - 1, 0));
+    } else if (t.key === "Enter" && o.value) {
+      const f = w.value;
+      f && !f.disabled && (i.value || !l.enterNeedsMove) && (t.preventDefault(), l.pick(f));
+    } else t.key === "Tab" && !t.shiftKey && o.value && l.complete?.() && t.preventDefault();
+  }
+  return { items: h, showingRecent: T, status: c, open: o, highlighted: u, moved: i, current: w, ask: L, show: k, close: A, cancel: g, remember: I, highlight: C, keydown: M };
+}
+export {
+  P as a,
+  q as c,
+  z as l,
+  _ as m,
+  W as r,
+  F as u
+};

package/dist/testing/app.d.ts

@@ -0,0 +1,61 @@
+import { type App, type Plugin } from "vue";
+import { type RouteRecordRaw, type Router } from "vue-router";
+import { type Platform } from "../platform";
+import { createTestI18n, type TestMessages } from "./i18n";
+/**
+ * The route records with every page replaced by an empty stand-in (nested records still render
+ * their children), keeping names, paths, meta, redirects and guards: a view under test can link to
+ * and navigate among the application's real routes without loading the other pages.
+ *
+ *   createTestApp({ routes: stubRoutes(ticketRoutes.records) })
+ */
+export declare function stubRoutes(records: readonly RouteRecordRaw[]): RouteRecordRaw[];
+export interface TestAppOptions {
+    /** Default: `createTestPlatform()`, a signed-in user holding nothing. */
+    platform?: Platform;
+    /** The routes; default: one that matches every address with an empty page. */
+    routes?: readonly RouteRecordRaw[];
+    /** Where the router starts, query included; default `/`. */
+    location?: string;
+    /** Use this router instead of making one (`routes` and `location` are then not used). */
+    router?: Router;
+    /** Default `en`. */
+    locale?: string;
+    /** Your texts per locale, over the library's. */
+    messages?: TestMessages;
+    /** More plugins, installed last: provide a feature's context here (`{ install: (app) => app.provide(key, value) }`). */
+    plugins?: readonly Plugin[];
+}
+/** What a component needs around it to run as it does in the application. */
+export interface TestApp {
+    /** For `render(Component, { global: { plugins: app.plugins } })` of @testing-library/vue, `mount` of @vue/test-utils, or `withSetup`. */
+    readonly plugins: readonly Plugin[];
+    readonly platform: Platform;
+    readonly router: Router;
+    readonly i18n: ReturnType<typeof createTestI18n>;
+}
+/**
+ * The application's environment for a test: the platform, a memory-history router, vue-i18n with
+ * the library's texts and your own, and formatting that follows the locale. The router starts
+ * navigating to `location` when it is installed: `await app.router.isReady()` before asserting on
+ * what a route renders (or `await app.router.push(...)` to go elsewhere).
+ *
+ *   const app = createTestApp({ platform: createTestPlatform({ permissions: ["tickets:view"] }), location: "/tickets" });
+ *   render(TicketList, { global: { plugins: app.plugins } });
+ *   await app.router.isReady();
+ */
+export declare function createTestApp(options?: TestAppOptions): TestApp;
+/**
+ * Runs a composable inside a mounted component of an application (`environment`: a `createTestApp()`
+ * by default, or just `{ plugins }`), as it is used: injections, the router and `onScopeDispose`
+ * work. Unmount to stop what it started.
+ *
+ *   const { result, unmount } = withSetup(() => useCollection(definition, { state: { kind: "memory" } }));
+ */
+export declare function withSetup<T>(setup: () => T, environment?: {
+    readonly plugins: readonly Plugin[];
+}): {
+    result: T;
+    app: App;
+    unmount: () => void;
+};

package/dist/testing/async.d.ts

@@ -0,0 +1,12 @@
+/** A promise you settle by hand: to make a request race or a slow answer deterministic. */
+export interface Deferred<T> {
+    readonly promise: Promise<T>;
+    resolve(value: T): void;
+    reject(error: unknown): void;
+}
+export declare function deferred<T>(): Deferred<T>;
+/**
+ * Lets pending promises, timers of 0 ms, router navigations and Vue's update queue run: a macrotask
+ * and a render per round (`rounds`, default 5). For what a single `await nextTick()` does not reach.
+ */
+export declare function settle(rounds?: number): Promise<void>;

package/dist/testing/collection.d.ts

@@ -0,0 +1,18 @@
+import type { CollectionQuery, ListPage, LoadContext } from "../collection";
+/** One page of a list as a loader returns it: the rows and the counts a pager shows, from the rows alone (`overrides` for a page of many). */
+export declare function listPage<Row>(rows: readonly Row[], overrides?: Partial<ListPage<Row>>): ListPage<Row>;
+/**
+ * A collection loader that records every call (the query it was asked, the signal it was given) and
+ * answers from a function of the query, so a test can assert what a list asked the backend for.
+ *
+ *   const { load, calls } = fakeLoader((query) => listPage(tickets));
+ *   const list = defineCollection({ id: "tickets", stateVersion: 1, load, key: (ticket) => ticket.id, query: { sorts: [], filters: [] } });
+ *   expect(calls[0]?.query.page).toBe(1);
+ */
+export declare function fakeLoader<Row>(answer: (query: CollectionQuery, context: LoadContext, call: number) => Promise<ListPage<Row>> | ListPage<Row>): {
+    load: (query: CollectionQuery, context: LoadContext) => Promise<ListPage<Row>>;
+    calls: {
+        query: CollectionQuery;
+        signal: AbortSignal;
+    }[];
+};

package/dist/testing/format.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "vue";
+/** A plugin installing `Intl` formatting (`useFormat()`) that follows a test i18n's locale. */
+export declare function testFormatting(i18n: {
+    global: {
+        locale: {
+            value: string;
+        };
+    };
+}): Plugin;

package/dist/testing/i18n.d.ts

@@ -0,0 +1,16 @@
+import { type I18n } from "vue-i18n";
+/** Messages per locale: `{ en: { tickets: { title: "Tickets" } } }`. */
+export type TestMessages = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+export interface TestI18nOptions {
+    /** Default `en`. */
+    locale?: string;
+    /** Your texts, merged over the library's (`core.*`) per locale; a key you give wins. */
+    messages?: TestMessages;
+}
+/**
+ * A vue-i18n instance (composition API) with the library's messages in every locale it ships and
+ * yours merged on top, so a component under test says what it says in production.
+ *
+ *   const i18n = createTestI18n({ messages: { en: { tickets: { title: "Tickets" } } } });
+ */
+export declare function createTestI18n(options?: TestI18nOptions): I18n<Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, string, false>;

package/dist/testing/index.d.ts

@@ -0,0 +1,14 @@
+export { deferred, settle } from "./async";
+export type { Deferred } from "./async";
+export { createTestApp, stubRoutes, withSetup } from "./app";
+export type { TestApp, TestAppOptions } from "./app";
+export { fakeLoader, listPage } from "./collection";
+export { testFormatting } from "./format";
+export { createTestI18n } from "./i18n";
+export type { TestI18nOptions, TestMessages } from "./i18n";
+export { mockMedia } from "./media";
+export type { MediaState } from "./media";
+export { createTestPlatform, createTestSession, heldAccess } from "./platform";
+export type { TestPlatformOptions, TestSessionOptions } from "./platform";
+export { jsonResponse, routedTransport, scriptedTransport } from "./transport";
+export type { Answer, RecordedCall } from "./transport";

package/dist/testing/index.js

@@ -0,0 +1,178 @@
+import { nextTick as b, createApp as j, defineComponent as m, h as u } from "vue";
+import { createMemoryHistory as P, createRouter as E, RouterView as $ } from "vue-router";
+import { a as A, i as O } from "../platform-hunMqFdB.js";
+import { createI18n as k } from "vue-i18n";
+import { coreMessages as M } from "../i18n/index.js";
+import { i as R, c as S } from "../format-B8mJm946.js";
+function K() {
+  let e, t;
+  return { promise: new Promise((s, r) => {
+    e = s, t = r;
+  }), resolve: e, reject: t };
+}
+async function Q(e = 5) {
+  for (let t = 0; t < e; t++)
+    await new Promise((n) => setTimeout(n, 0)), await b();
+}
+const f = (e) => typeof e == "object" && e !== null && !Array.isArray(e);
+function g(e, t) {
+  const n = { ...e };
+  for (const [s, r] of Object.entries(t)) {
+    const a = n[s];
+    n[s] = f(r) && f(a) ? g(a, r) : r;
+  }
+  return n;
+}
+function x(e = {}) {
+  const t = { ...M };
+  for (const [n, s] of Object.entries(e.messages ?? {})) t[n] = g(t[n] ?? {}, s);
+  return k({ legacy: !1, locale: e.locale ?? "en", fallbackLocale: "en", messages: t });
+}
+function L(e) {
+  return { install: (t) => R(t, S({ locale: () => e.global.locale.value })) };
+}
+function C(e, t, n = "all", s) {
+  const r = t === void 0 ? { level: e } : { level: e, id: t };
+  return { scope: r, qualifier: n, clauses: s ?? [{ scope: r, qualifier: n }] };
+}
+function B(e = {}) {
+  const { permissions: t = [] } = e, n = Array.isArray(t) ? Object.fromEntries(t.map((r) => [r, C("organization")])) : { ...t }, s = { root: e.root ?? !1, permissions: n, unavailable: e.unavailable ?? [] };
+  return {
+    user: e.user ?? { id: 1 },
+    expiresAt: e.expiresAt ?? null,
+    access: s,
+    ...e.navigation ? { navigation: e.navigation } : {}
+  };
+}
+const F = async (e, t) => {
+  throw new Error(`createTestPlatform: an unexpected request ${(t.method ?? "GET").toUpperCase()} ${e}. Pass a \`transport\` that answers it (scriptedTransport or routedTransport).`);
+};
+function U(e = {}) {
+  const { user: t, permissions: n, unavailable: s, root: r, navigation: a, expiresAt: o, transport: c, config: i, session: l, ...T } = e, p = t === null ? null : B({ user: t, permissions: n, unavailable: s, root: r, navigation: a, expiresAt: o }), y = l ?? { load: async () => p, signOut: async () => {
+  } }, d = A({
+    ...T,
+    config: { apiBase: "", locale: "en", appName: "Test app", capabilities: [], ...i },
+    transport: c ?? F,
+    session: y
+  });
+  return !l && p && d.session.establish(p), d;
+}
+const z = m({ name: "TestBlankPage", render: () => u("div") }), h = m({ name: "TestRouteStub", render: () => u("div", [u($)]) });
+function G(e) {
+  return e.map((t) => {
+    const { component: n, components: s, children: r, ...a } = t, o = { ...a };
+    return r && (o.children = G(r)), s ? o.components = Object.fromEntries(Object.keys(s).map((c) => [c, h])) : n !== void 0 && (o.component = h), o;
+  });
+}
+function H(e = {}) {
+  const t = e.platform ?? U();
+  let n = e.router;
+  if (!n) {
+    const a = P();
+    a.replace(e.location ?? "/"), n = E({ history: a, routes: [...e.routes ?? [{ path: "/:pathMatch(.*)*", component: z }]] });
+  }
+  const s = x({ locale: e.locale, messages: e.messages });
+  return { plugins: [n, s, L(s), { install: (a) => O(a, t) }, ...e.plugins ?? []], platform: t, router: n, i18n: s };
+}
+function W(e, t = H()) {
+  let n;
+  const s = j(
+    m({
+      setup() {
+        return n = e(), () => u("div");
+      }
+    })
+  );
+  for (const r of t.plugins) s.use(r);
+  return s.mount(document.createElement("div")), { result: n, app: s, unmount: () => s.unmount() };
+}
+function X(e, t = {}) {
+  return {
+    rows: e,
+    total: e.length,
+    page: 1,
+    pageSize: 25,
+    lastPage: e.length === 0 ? 0 : 1,
+    from: e.length === 0 ? 0 : 1,
+    to: e.length,
+    ...t
+  };
+}
+function Y(e) {
+  const t = [];
+  return { load: (s, r) => (t.push({ query: s, signal: r.signal }), Promise.resolve(e(s, r, t.length))), calls: t };
+}
+function Z(e = {}) {
+  const t = { compact: !1, narrow: !1, reducedMotion: !1, standalone: !1, ...e }, n = window.matchMedia, s = /* @__PURE__ */ new Set(), r = (o) => o.includes("prefers-reduced-motion") ? t.reducedMotion : o.includes("display-mode: standalone") ? t.standalone : o.includes("min-width: 48rem") ? !t.compact : o.includes("max-width: 1023px") ? t.narrow || t.compact : o.includes("pointer: coarse") || o.includes("max-width: 47.999rem") ? t.compact : !1, a = (o) => o.split(",").some(r);
+  return window.matchMedia = ((o) => {
+    const c = { query: o, last: a(o), listeners: /* @__PURE__ */ new Set() };
+    return s.add(c), {
+      media: o,
+      get matches() {
+        return a(o);
+      },
+      addEventListener: (i, l) => c.listeners.add(l),
+      removeEventListener: (i, l) => c.listeners.delete(l)
+    };
+  }), {
+    state: t,
+    set(o) {
+      Object.assign(t, o);
+      for (const c of s) {
+        const i = a(c.query);
+        i !== c.last && (c.last = i, c.listeners.forEach((l) => l()));
+      }
+    },
+    restore() {
+      window.matchMedia = n;
+    }
+  };
+}
+const q = (e, t, n = {}) => new Response(t === void 0 ? null : JSON.stringify(t), { status: e, headers: { "Content-Type": "application/json", ...n } }), w = (e, t) => ({
+  url: e,
+  method: (t.method ?? "GET").toUpperCase(),
+  headers: new Headers(t.headers),
+  init: t
+});
+async function v(e, t) {
+  if (e instanceof Error) throw e;
+  return typeof e == "function" ? e(t) : e.clone();
+}
+function ee(...e) {
+  const t = [], n = [...e];
+  return { transport: async (r, a) => {
+    const o = w(r, a);
+    t.push(o);
+    const c = n.length > 1 ? n.shift() : n[0];
+    if (c === void 0) throw new Error("scriptedTransport: no answer left");
+    return v(c, o);
+  }, calls: t };
+}
+function te(e) {
+  const t = [];
+  return { transport: async (s, r) => {
+    const a = w(s, r);
+    t.push(a);
+    const { pathname: o, search: c } = new URL(s, "http://test.invalid"), i = e[`${a.method} ${o}${c}`] ?? e[`${a.method} ${o}`];
+    if (i === void 0) throw new Error(`routedTransport: no route for ${a.method} ${o}${c}; it has ${Object.keys(e).join(", ") || "none"}`);
+    return v(i, a);
+  }, calls: t };
+}
+export {
+  H as createTestApp,
+  x as createTestI18n,
+  U as createTestPlatform,
+  B as createTestSession,
+  K as deferred,
+  Y as fakeLoader,
+  C as heldAccess,
+  q as jsonResponse,
+  X as listPage,
+  Z as mockMedia,
+  te as routedTransport,
+  ee as scriptedTransport,
+  Q as settle,
+  G as stubRoutes,
+  L as testFormatting,
+  W as withSetup
+};

package/dist/testing/media.d.ts

@@ -0,0 +1,23 @@
+/** What the mocked `matchMedia` answers. */
+export interface MediaState {
+    /** Phones and touch-first screens (the `compact:` condition). */
+    compact: boolean;
+    /** Below 1024 px, phones and tablets: where lists turn into phone rows. */
+    narrow: boolean;
+    reducedMotion: boolean;
+    /** Running as an installed app (`display-mode: standalone`). */
+    standalone: boolean;
+}
+/**
+ * Replaces `window.matchMedia` for a test: the library's conditions (compact, narrow, reduced motion, standalone) are answered from
+ * `state`, everything else is false. Change `state` through `set` to fire `change` listeners.
+ * Returns `restore`: call it in `afterEach`.
+ *
+ *   const media = mockMedia({ compact: true });
+ *   afterEach(() => media.restore());
+ */
+export declare function mockMedia(initial?: Partial<MediaState>): {
+    state: MediaState;
+    set(next: Partial<MediaState>): void;
+    restore(): void;
+};

package/dist/testing/platform.d.ts

@@ -0,0 +1,40 @@
+import { type AccessClause, type AccessQualifier, type BootstrapConfig, type HeldAccess, type NavigationNode, type Platform, type PlatformOptions, type SessionAdapter, type SessionSnapshot, type SessionUser } from "../platform";
+import type { Transport } from "../client";
+/**
+ * How a permission is held: at a level of your scope hierarchy (`organization`, `dealer`, ...) with an
+ * optional id, for `all` records, only the user's `own` or those of their `own_location`. For the
+ * `permissions` record of `createTestSession`; a plain permission name there means "everything, at the organization".
+ */
+export declare function heldAccess(level: string, id?: number, qualifier?: AccessQualifier, clauses?: readonly AccessClause[]): HeldAccess;
+export interface TestSessionOptions<U extends SessionUser = SessionUser> {
+    /** Default `{ id: 1 }`. */
+    user?: U;
+    /** Permissions held at the organization for every record (names), or exactly how each is held (`heldAccess`). */
+    permissions?: readonly string[] | Readonly<Record<string, HeldAccess>>;
+    /** Granted by a role but switched off for the tenant: not held. */
+    unavailable?: readonly string[];
+    /** Some binding is at the root scope. */
+    root?: boolean;
+    navigation?: readonly NavigationNode[];
+    expiresAt?: Date | null;
+}
+/** What `/auth/me` would say for a user: for `session.establish(...)` mid-test, or an adapter that answers it. */
+export declare function createTestSession<U extends SessionUser = SessionUser>(options?: TestSessionOptions<U>): SessionSnapshot<U>;
+export interface TestPlatformOptions<U extends SessionUser = SessionUser> extends Omit<TestSessionOptions<U>, "user">, Omit<PlatformOptions<U, BootstrapConfig>, "config" | "transport" | "session"> {
+    /** `null`: nobody is signed in (the session answers "none" when asked). Default: the user of `createTestSession`. */
+    user?: U | null;
+    /** Answers the requests the code under test makes: `scriptedTransport` or `routedTransport`. Default: any request fails the test. */
+    transport?: Transport;
+    /** Fields of the bootstrap config over the test's (`apiBase: ""`, `locale: "en"`, `appName: "Test app"`). */
+    config?: Partial<BootstrapConfig>;
+    /** A session adapter of your own; then `user`, `permissions` and the like are not used and the session starts unasked. */
+    session?: SessionAdapter<U>;
+}
+/**
+ * A platform for a test: an HTTP client over a fake transport, a session that is already signed in
+ * (no request) and the access it grants. Independent of every other platform, as production's.
+ *
+ *   const platform = createTestPlatform({ user: { id: 7 }, permissions: ["tickets:view"], transport });
+ *   platform.access.can("tickets:view"); // true, at once
+ */
+export declare function createTestPlatform<U extends SessionUser = SessionUser>(options?: TestPlatformOptions<U>): Platform<U>;

package/dist/testing/transport.d.ts

@@ -0,0 +1,40 @@
+import type { Transport } from "../client";
+/** One request a fake transport received. */
+export interface RecordedCall {
+    /** The URL as the client sent it, with the API base and the query string. */
+    readonly url: string;
+    /** Upper case; `GET` when the client set none. */
+    readonly method: string;
+    readonly headers: Headers;
+    /** The request as `fetch` received it (body, signal). */
+    readonly init: RequestInit;
+}
+/** What a fake transport answers: a response (served again for every matching call), a failure to throw, or a function of the call. */
+export type Answer = Response | Error | ((call: RecordedCall) => Response | Promise<Response>);
+/** A JSON response, as go-core answers: `jsonResponse(404, { error: "…" })`. A body of `undefined` is an empty one (204). */
+export declare const jsonResponse: (status: number, body?: unknown, headers?: Record<string, string>) => Response;
+/**
+ * A transport answering from a queue, one answer per call in order (the last one repeats), and
+ * recording what it was sent. For a test about a sequence: a retry, a 401 then a renewal, a race.
+ *
+ *   const { transport, calls } = scriptedTransport(jsonResponse(503, {}), jsonResponse(200, { id: 1 }));
+ */
+export declare function scriptedTransport(...answers: Answer[]): {
+    transport: Transport;
+    calls: RecordedCall[];
+};
+/**
+ * A transport answering by route, whatever the order: keys are `"METHOD /path"` (the path with the
+ * API base, the query string optional: `"GET /api/v1/tickets"` matches `/api/v1/tickets?page=2` unless a
+ * key with that exact query exists). A request nothing matches fails the test with the routes it
+ * knows, so a view that asks for something unexpected is never answered by accident.
+ *
+ *   const { transport, calls } = routedTransport({
+ *     "GET /tickets": jsonResponse(200, { data: [] }),
+ *     "POST /tickets": (call) => jsonResponse(201, { id: 7 }),
+ *   });
+ */
+export declare function routedTransport(routes: Readonly<Record<string, Answer>>): {
+    transport: Transport;
+    calls: RecordedCall[];
+};

package/dist/toast-D9Z5To38.js

@@ -0,0 +1,13 @@
+import { toast as i } from "vue-sonner";
+const t = {
+  success: (s, o) => i.success(s, o),
+  info: (s, o) => i.info(s, o),
+  warning: (s, o) => i.warning(s, o),
+  error: (s, o) => i.error(s, o),
+  loading: (s, o) => i.loading(s, o),
+  /** Dismisses one toast, or all of them without an id. */
+  dismiss: (s) => void i.dismiss(s)
+};
+export {
+  t
+};