@wssto2/vue-core 0.1.0 → 0.3.0

package/dist/form/suggestions.d.ts

@@ -32,6 +32,17 @@ export declare function matchParts(label: string, query: string): {
 export declare function completionOf(typed: string, label: string): string;
 /** Whether the list has anything to say: rows, a loading or failed line, or (a pick list) that nothing matched. */
 export declare function listShows(open: boolean, count: number, status: SuggestionStatus, emptyMessage: boolean): boolean;
+/**
+ * One load at a time, the latest wins: asking again aborts the older request and its late answer (or late failure) is dropped.
+ * The status is the discriminated state of the wait (`idle` until something is asked). Shared by the suggestions engine and by
+ * `useOptions`, so a typed search and a dependent select race the same way.
+ */
+export declare function useLatestLoad<Item>(): {
+    items: import("vue").ShallowRef<readonly Item[], readonly Item[]>;
+    status: import("vue").Ref<SuggestionStatus, SuggestionStatus>;
+    run: (load: (signal: AbortSignal) => Promise<readonly Item[]>, settle?: (found: readonly Item[]) => readonly Item[]) => Promise<void>;
+    cancel: () => void;
+};
 export interface SuggestionsOptions<Value extends string | number> {
     source: () => SuggestionSource<Value> | undefined;
     /** The fewest characters before a function source is asked. */

package/dist/form/useOptions.d.ts

@@ -0,0 +1,60 @@
+import type { SelectOption } from "./options";
+import { type SuggestionStatus } from "./suggestions";
+/**
+ * The options of a select that arrive from the server. `status` is the state of the wait, `options` the last answer that
+ * landed (kept while the next is loading, so the chosen option keeps its label). Pass it where a list goes:
+ * `<SelectField :options="models" />`, `<MultiSelectField :options="models" />`.
+ */
+export interface AsyncOptions<Value extends string | number = string | number> {
+    /** `idle`: nothing to ask yet (the input this depends on is empty). */
+    readonly status: SuggestionStatus;
+    readonly options: readonly SelectOption<Value>[];
+    /**
+     * Counts how often the input these options depend on moved away from a value (the user picked another make). A field clears
+     * a value the options lack only when options land for a newer generation: never on the first load (a saved value the list no
+     * longer offers stays), never on a `reload()` of the same input.
+     */
+    readonly generation: number;
+    /** Asks again for the current input (the "Try again" row of a failed load). */
+    reload(): void;
+}
+/** What a select takes as its options: a list, or one that loads. */
+export type OptionsSource<Value extends string | number> = readonly SelectOption<Value>[] | AsyncOptions<Value>;
+export interface OptionsContext {
+    /** Aborted when a newer ask replaced this one or the scope ended: pass it on to the request. */
+    readonly signal: AbortSignal;
+}
+/**
+ * Options loaded from the server, with the race rules built in: the latest input wins, an answer for an older input is dropped
+ * (and its request aborted), nothing lands after the scope ended. A select given these shows a spinner while it loads, a
+ * "Loading…" row when opened, a "Try again" row when it failed, and clears a value the new options do not contain.
+ *
+ *   const makes = useOptions({ load: (context) => api.makes(context) });
+ *   const models = useOptions({ for: () => form.values.make, load: (make, context) => api.models(make, context) });
+ *   <SelectField v-bind="form.bind('make')" :label="t('make')" :options="makes" />
+ *   <SelectField v-bind="form.bind('model')" :label="t('model')" :options="models" :disabled="!form.values.make" />
+ *
+ * `for` is a getter of the input the options depend on (reactive); `null` or `undefined` asks nothing (the list is empty, `idle`), anything
+ * else asks, again whenever it changes. Without `for` the options load once.
+ */
+export declare function useOptions<Input, Value extends string | number>(options: {
+    readonly for: () => Input | null | undefined;
+    readonly load: (input: Input, context: OptionsContext) => Promise<readonly SelectOption<Value>[]>;
+}): AsyncOptions<Value>;
+export declare function useOptions<Value extends string | number>(options: {
+    readonly load: (context: OptionsContext) => Promise<readonly SelectOption<Value>[]>;
+}): AsyncOptions<Value>;
+/**
+ * What a select makes of its `options` prop, a list or a loader: the options known (also the stale ones while loading, so the
+ * chosen label stays), the rows to list (none while loading or failed), the status for the control and the list, and `arrived`,
+ * called with the new options when a load lands for a different input than the one the value belongs to (the user picked
+ * another make, or emptied it), so the field can drop a value they do not contain. The first load and a reload of the same
+ * input never call it.
+ */
+export declare function useOptionSource<Value extends string | number>(source: () => OptionsSource<Value>, arrived: (options: readonly SelectOption<Value>[]) => void): {
+    known: import("vue").ComputedRef<readonly SelectOption<Value>[]>;
+    rows: import("vue").ComputedRef<readonly SelectOption<Value>[]>;
+    status: import("vue").ComputedRef<SuggestionStatus>;
+    loading: import("vue").ComputedRef<boolean>;
+    reload: () => void;
+};

package/dist/guards-Cd1V28oG.js

@@ -0,0 +1,51 @@
+import { effectScope as R, watch as g } from "vue";
+import { h as b } from "./platform-hunMqFdB.js";
+const i = "redirect";
+function q(r) {
+  const t = r.query[i], n = Array.isArray(t) ? t[0] : t;
+  return typeof n == "string" && n.startsWith("/") && !n.startsWith("//") && !n.includes("\\") ? n : null;
+}
+function m(r, t) {
+  return t === null ? r : typeof r == "string" ? { path: r, query: { [i]: t } } : { ...r, query: { ...r.query, [i]: t } };
+}
+function W(r) {
+  const { router: t, session: n, login: o, home: d } = r, f = /* @__PURE__ */ new WeakMap();
+  let s = !1;
+  const h = () => {
+    s || (s = !0, r.progress?.start());
+  }, c = () => {
+    s && (s = !1, r.progress?.done());
+  }, p = () => t.resolve(o).name, v = t.beforeEach(async (e) => {
+    if (h(), e.meta.public === !0) {
+      if (e.name !== void 0 && e.name === p() && (await n.restore()).status === "authenticated") return q(e) ?? d;
+    } else {
+      const a = await n.restore();
+      if (a.status === "failed")
+        return r.onError?.(a.error), !1;
+      if (a.status !== "authenticated") return m(o, e.fullPath);
+    }
+    return r.prepare && f.set(e, r.prepare(e)), !0;
+  }), y = t.beforeResolve(async (e) => {
+    await f.get(e);
+  }), E = t.afterEach((e, a, u) => {
+    c(), u || r.afterNavigation?.(e);
+  }), w = t.onError((e) => {
+    c(), r.onError?.(e);
+  }), l = R();
+  return l.run(
+    () => g(
+      () => n.state.value,
+      (e, a) => {
+        if (e.status !== "anonymous" || b(a) === null) return;
+        const u = t.currentRoute.value;
+        u.meta.public !== !0 && (e.reason === "expired" && r.holdExpired && e.previous || t.replace(m(o, e.reason === "expired" ? u.fullPath : null)).catch(r.onError));
+      }
+    )
+  ), () => {
+    v(), y(), E(), w(), l.stop(), c();
+  };
+}
+export {
+  W as i,
+  q as r
+};

package/dist/http-DGGSKWvU.js

@@ -0,0 +1,193 @@
+import { hasInjectionContext as z, inject as $, watch as _ } from "vue";
+import { g as O } from "./platform-hunMqFdB.js";
+const j = [5, 8, 10, 15, 25, 50, 100], E = 25;
+function U(e) {
+  const t = `defineCollection("${e.id}")`;
+  if (typeof e.id != "string" || e.id.trim() === "") throw new Error("defineCollection: `id` must be a non-empty string.");
+  if (!Number.isInteger(e.stateVersion) || e.stateVersion < 1) throw new Error(`${t}: \`stateVersion\` must be a positive integer.`);
+  if (typeof e.load != "function") throw new Error(`${t}: \`load\` must be a function.`);
+  if (typeof e.key != "function") throw new Error(`${t}: \`key\` must be a function.`);
+  const r = {
+    sorts: e.query?.sorts ? [...e.query.sorts] : null,
+    filters: e.query?.filters ? [...e.query.filters] : null,
+    views: e.query?.views ? [...e.query.views] : null,
+    sensitive: [...e.query?.sensitive ?? []],
+    pageSizes: [...e.query?.pageSizes ?? j]
+  };
+  if (r.pageSizes.length === 0 || r.pageSizes.some((c) => !Number.isInteger(c) || c < 1))
+    throw new Error(`${t}: \`query.pageSizes\` must list positive integers.`);
+  for (const c of r.sensitive)
+    if (r.filters && !r.filters.includes(c)) throw new Error(`${t}: sensitive filter "${c}" is not in \`query.filters\`.`);
+  const s = e.defaults ?? {}, n = s.pageSize ?? (r.pageSizes.includes(E) ? E : r.pageSizes[0]);
+  if (!r.pageSizes.includes(n)) throw new Error(`${t}: default page size ${n} is not one of ${r.pageSizes.join(", ")}.`);
+  const o = s.sort ?? null;
+  if (o !== null && r.sorts && !r.sorts.includes(o)) throw new Error(`${t}: default sort "${o}" is not in \`query.sorts\`.`);
+  const i = s.view ?? null;
+  if (i !== null && r.views && !r.views.includes(i)) throw new Error(`${t}: default view "${i}" is not in \`query.views\`.`);
+  const a = Object.fromEntries(Object.entries(s.filters ?? {}).filter(([, c]) => c !== void 0 && c !== ""));
+  for (const c of Object.keys(a))
+    if (r.filters && !r.filters.includes(c)) throw new Error(`${t}: default filter "${c}" is not in \`query.filters\`.`);
+  const l = s.page ?? 1;
+  if (!Number.isInteger(l) || l < 1) throw new Error(`${t}: default page must be a positive integer.`);
+  const f = s.direction ?? "asc";
+  if (f !== "asc" && f !== "desc") throw new Error(`${t}: default direction must be "asc" or "desc".`);
+  return Object.freeze({
+    id: e.id,
+    stateVersion: e.stateVersion,
+    load: e.load,
+    key: e.key,
+    defaults: Object.freeze({
+      page: l,
+      pageSize: n,
+      sort: o,
+      direction: f,
+      search: s.search ?? "",
+      view: i,
+      filters: Object.freeze(a)
+    }),
+    contract: Object.freeze(r),
+    migrate: e.migrate
+  });
+}
+const X = "from";
+function F(e, t) {
+  if (typeof e == "string") {
+    const r = new URLSearchParams(t).toString(), s = e.indexOf("#"), n = s === -1 ? e : e.slice(0, s);
+    return `${n}${n.includes("?") ? "&" : "?"}${r}${s === -1 ? "" : e.slice(s)}`;
+  }
+  return { ...e, query: { ...e.query, ...t } };
+}
+function G(e) {
+  if (!z()) return;
+  const t = $(O, null);
+  t && _(
+    () => {
+      const r = t.session.state.value;
+      return r.status === "authenticated" ? r.user.id : null;
+    },
+    e,
+    { flush: "sync" }
+  );
+}
+const I = 4096, k = 200, T = 32, N = 1e6, v = /^[A-Za-z0-9_.-]{1,64}$/;
+function C(e) {
+  let t = "";
+  for (const r of new TextEncoder().encode(e)) t += String.fromCharCode(r);
+  return btoa(t).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function M(e) {
+  const t = e.replace(/-/g, "+").replace(/_/g, "/"), r = atob(t.padEnd(Math.ceil(t.length / 4) * 4, "="));
+  return new TextDecoder("utf-8", { fatal: !0 }).decode(Uint8Array.from(r, (s) => s.charCodeAt(0)));
+}
+const S = (e) => typeof e == "object" && e !== null && !Array.isArray(e);
+function h(e, t = k) {
+  return typeof e == "string" && e.length <= t ? e : null;
+}
+function A(e, t) {
+  const { defaults: r, contract: s } = e, n = typeof t.p == "number" && Number.isInteger(t.p) && t.p >= 1 && t.p <= N ? t.p : r.page, o = typeof t.l == "number" && s.pageSizes.includes(t.l) ? t.l : r.pageSize;
+  let i = r.sort;
+  const a = h(t.c, 64);
+  a !== null && (s.sorts ? s.sorts.includes(a) : v.test(a)) && (i = a);
+  const l = t.d === "asc" || t.d === "desc" ? t.d : r.direction, f = h(t.s) ?? r.search;
+  let c = r.view;
+  const g = h(t.w, 64);
+  g !== null && (s.views ? s.views.includes(g) : v.test(g)) && (c = g);
+  const w = S(t.f) ? {} : { ...r.filters };
+  if (S(t.f)) {
+    let y = 0;
+    for (const [u, m] of Object.entries(t.f)) {
+      if (++y > T) break;
+      if (!(s.filters ? s.filters.includes(u) : v.test(u)) || s.sensitive.includes(u)) continue;
+      const b = typeof m == "number" || typeof m == "boolean" ? String(m) : h(m);
+      b !== null && b !== "" && (w[u] = b);
+    }
+  }
+  return { page: n, pageSize: o, sort: i, direction: l, search: f, view: c, filters: w };
+}
+function J(e, t) {
+  const r = { v: e.stateVersion, p: t.page, l: t.pageSize };
+  t.sort && (r.c = t.sort), r.d = t.direction, t.search && (r.s = t.search), t.view && (r.w = t.view);
+  const s = Object.fromEntries(
+    Object.entries(t.filters).filter(([n, o]) => o !== void 0 && o !== "" && !e.contract.sensitive.includes(n))
+  );
+  return (Object.keys(s).length > 0 || Object.keys(e.defaults.filters).length > 0) && (r.f = s), C(JSON.stringify(r));
+}
+function x(e, t) {
+  const r = t.v === void 0 ? e.stateVersion : t.v;
+  if (typeof r != "number" || !Number.isInteger(r)) return null;
+  if (r === e.stateVersion) return A(e, t);
+  const s = e.migrate?.(t, r);
+  return s ? A(e, s) : null;
+}
+function Z(e, t) {
+  if (typeof t != "string" || t === "" || t.length > I) return null;
+  let r;
+  try {
+    r = JSON.parse(M(t));
+  } catch {
+    return null;
+  }
+  return S(r) ? x(e, r) : null;
+}
+function B(e) {
+  return JSON.stringify([
+    e.page,
+    e.pageSize,
+    e.sort,
+    e.direction,
+    e.search,
+    e.view,
+    Object.entries(e.filters).sort(([t], [r]) => t.localeCompare(r))
+  ]);
+}
+const d = (e) => typeof e == "object" && e !== null && !Array.isArray(e), p = (...e) => {
+  for (const t of e) if (typeof t == "number" && Number.isFinite(t)) return t;
+  return null;
+};
+function L(e) {
+  return {
+    // Filters first: the reserved names below always win, a filter called "page" cannot break paging.
+    ...e.filters,
+    page: e.page,
+    per_page: e.pageSize,
+    order_col: e.sort,
+    order_dir: e.sort ? e.direction : null,
+    search: e.search,
+    view: e.view
+  };
+}
+function P(e, t) {
+  const r = e.data, s = d(r) && Array.isArray(r.data), n = Array.isArray(r) ? r : s ? r.data : [], o = s ? r : {}, i = d(e.meta) ? e.meta : d(o.meta) ? o.meta : {}, a = p(o.per_page, i.per_page) ?? t.pageSize, l = p(o.total, i.total) ?? n.length, f = p(o.current_page, i.page, i.current_page) ?? t.page, c = p(o.last_page, i.last_page) ?? (l === 0 ? 0 : Math.ceil(l / Math.max(1, a))), g = p(o.from, i.from) ?? (n.length === 0 ? 0 : (f - 1) * a + 1), w = p(o.to, i.to) ?? (n.length === 0 ? 0 : g + n.length - 1), y = Array.isArray(i.views) ? i.views : Array.isArray(o.views) ? o.views : void 0;
+  return {
+    rows: n,
+    total: l,
+    page: f,
+    pageSize: a,
+    lastPage: c,
+    from: g,
+    to: w,
+    views: y?.filter(d).flatMap((u) => typeof u.key == "string" ? [{ key: u.key, count: p(u.count) ?? void 0 }] : []),
+    meta: i,
+    requestId: e.requestId
+  };
+}
+function K(e, t, r = {}) {
+  return async (s, { signal: n }) => {
+    const o = await e.get(t, { query: r.params ? r.params(s) : L(s), signal: n });
+    return P(o, s);
+  };
+}
+export {
+  j as D,
+  X as L,
+  U as a,
+  x as b,
+  Z as d,
+  J as e,
+  K as h,
+  L as l,
+  G as o,
+  B as q,
+  P as r,
+  F as w
+};

package/dist/i18n/describeError.d.ts

@@ -0,0 +1,31 @@
+export interface DescribeErrorOptions {
+    /**
+     * What to say when nothing more specific is known: a server fault, an unreadable answer, an error that
+     * is not a failed request, a rejection without a reason of its own. Say what failed ("The changes could not be saved.").
+     */
+    readonly fallback?: string;
+}
+/** The sentence to show a person for a failure; see `useDescribeError`. */
+export type DescribeError = (error: unknown, options?: DescribeErrorOptions) => string;
+/** The part of a vue-i18n composer the sentences are read with. */
+interface Translator {
+    t(key: string, params?: Record<string, unknown>): string;
+    te(key: string): boolean;
+}
+/** `describeError` over a translator; exported for the composable and tests. */
+export declare function describeErrorWith({ t, te }: Translator): DescribeError;
+/**
+ * The sentence for a failed request, in the app's language, for toasts and inline messages.
+ * Call it in `setup` (it reads the composer), use the result anywhere later:
+ *
+ *   const describeError = useDescribeError();
+ *   try { await save(); } catch (error) { toast.error(describeError(error, { fallback: t("tickets.save_failed") })); }
+ *
+ * In order: a go-core `code` the app or the library has a text for (`errors.<code>`, then
+ * `core.errors.<code>`, with the error's `params`); the server's own text when it sent a code (it is
+ * already translated); then by kind: 401, 403, 404, 409, no answer, cancelled, 429, "check the marked
+ * fields" for a validation answer with fields; server faults and anything unreadable give `fallback`;
+ * any other 4xx gives `fallback` too, or the server's text.
+ */
+export declare function useDescribeError(): DescribeError;
+export {};