@wssto2/vue-core 0.12.1 → 0.13.1

package/dist/form/zodErrorMap.d.ts

@@ -0,0 +1,35 @@
+import type { Formatting } from "../format";
+/** What a Zod issue (`$ZodRawIssue`) is read for. Structural, so the library needs no Zod: the map is handed to `z.config({ customError })`. */
+export interface ZodIssueLike {
+    readonly code?: string;
+    readonly origin?: string;
+    readonly minimum?: number | bigint;
+    readonly maximum?: number | bigint;
+    readonly format?: string;
+    readonly params?: Record<string, unknown>;
+}
+/** The parts of an application the map reads: its vue-i18n instance (`createApplication`'s `application`) and its formatting. */
+export interface ZodErrorMapEnvironment {
+    readonly i18n: {
+        readonly global: {
+            t(key: string, params?: Record<string, unknown>): string;
+            te(key: string): boolean;
+        };
+    };
+    readonly format: Pick<Formatting, "number">;
+}
+/**
+ * A Zod error map onto the `validation_errors.*` texts, so a schema's own failures ("Required", "at least 3 characters", a bound,
+ * an e-mail address) read in the active language and the application's wording. Zod 4's `customError`; register it once:
+ *
+ *   z.config({ customError: zodErrorMap(application) });
+ *
+ * Each text is looked up as the application's `validation_errors.<key>` first, then the library's `core.validation_errors.<key>`
+ * (`required`, `min`, `max`, `min_value`, `max_value`, `email`, `url`, `date`, `datetime`), so an application overrides any of them
+ * by defining the key. A `refine` or `superRefine` names its own text with `params: { code: "deadline_before_opening" }`, which reads
+ * `validation_errors.deadline_before_opening` (`code: "required"` is the generated schemas' "zero is missing"). An issue it has no text
+ * for returns `undefined`, so Zod's own sentence stands, and a message a schema carries itself is never asked for.
+ */
+export declare function zodErrorMap({ i18n, format }: ZodErrorMapEnvironment): (issue: ZodIssueLike) => {
+    message: string;
+} | undefined;

package/dist/format/format.d.ts

@@ -3,8 +3,9 @@ import type { App } from "vue";
 export type DateInput = Date | string | number | null | undefined;
 /**
  * Normalizes a value to a `Date`, or null when there is nothing to show: no value, one that is not a
- * date, or an unset one (a go-core server sends Go's zero time, 0001-01-01, for a date that was never
- * set, and some systems send the epoch: neither is a date anybody meant).
+ * date, or an unset one (a string that starts with a zero date, `0000-00-00`, `0001-01-01` or `1970-01-01`, in any
+ * form; a Date or a number at or before the epoch): none of them is a date anybody meant.
+ * Reads `YYYY-MM-DD HH:mm[:ss]` (space-separated) as local time, and a civil `YYYY-MM-DD` as that day at local midnight.
  */
 export declare function toDate(value: DateInput): Date | null;
 /**
@@ -22,6 +23,19 @@ export interface Formatters {
     /** `now` is the moment to count from. */
     relative(value: Date, locale: string, now: Date): string;
 }
+/** The symbols an application writes numbers with. */
+export interface NumberSymbols {
+    /** Between the thousands: ".". */
+    group: string;
+    /** Before the fraction: ",". */
+    decimal: string;
+}
+export interface DayOptions {
+    /** The lower-case word for a day inside a sentence ("Otvoren jučer"); the date is unchanged. */
+    inSentence?: boolean;
+    /** The moment "today" is counted from (default: now). */
+    now?: Date;
+}
 export interface MoneyOptions {
     /** An ISO code ("EUR"): `Intl`'s currency style instead of the application's `currencySymbol`. */
     currency?: string;
@@ -55,17 +69,48 @@ export interface Formatting {
     readonly currencySymbol: string;
     /** "3 days ago", "in 2 hours", "now": the largest whole unit. */
     relative(value: DateInput, now?: Date): string;
+    /**
+     * "Today" and "Yesterday" (the `core.activity.today` / `yesterday` texts of the active language) for those two days, the `date` for any other:
+     * what people scan for in recent activity. Without a `translate` in the options it is always the `date`.
+     */
+    day(value: DateInput, options?: DayOptions): string;
+    /** `day` and the time, "Today · 12:57" / "13.09.2026. · 12:57". */
+    dayTime(value: DateInput, options?: DayOptions): string;
+    /** The BCP 47 tag the active locale is given to `Intl` as (the application's `intlLocale` map over the library's), for a caller that uses `Intl` itself. */
+    readonly intlLocale: string;
+}
+/** What the library's own formatters can be told; `createFormatting` passes its options through. */
+export interface FormatterSettings {
+    /** Language code → the BCP 47 tag `Intl` is given (`{ en: "en-GB", sl: "sl-SI" }`), over the library's own (`bs` → `sr-Latn-BA`: Chromium has no Bosnian data). Time and relative text use it too. */
+    intlLocale?: Readonly<Record<string, string>>;
+    /**
+     * Language code → the numeric date, written with `DD`, `MM`, `YYYY` ("DD.MM.YYYY." is `30.09.2026.`, "DD/MM/YYYY" is `30/09/2026`).
+     * The date-time is the same pattern, a space and the 24-hour time. A language not listed keeps `Intl`'s date.
+     */
+    datePattern?: Readonly<Record<string, string>>;
+    /**
+     * Writes every number with these symbols, in every language: grouped from four digits (`1.234`), the fraction digits rounded like
+     * `toFixed` (so `1.005` at two digits is `1,00`, not `Intl`'s `1,01`), and `useGrouping: false` honoured. A `style` other than decimal
+     * (`percent`, `unit`) stays `Intl`'s. Money in an ISO currency is then this number and the currency's symbol ("12,50 €").
+     */
+    numberSymbols?: NumberSymbols;
 }
-/** The `Intl`-backed defaults; instances are cached per locale and options because a table formats thousands of cells. */
-export declare function intlFormatters(): Formatters;
-export interface FormattingOptions {
+/** The library's formatters: `Intl`'s, unless the settings say otherwise. Instances are cached per locale and options because a table formats thousands of cells. */
+export declare function intlFormatters(settings?: FormatterSettings): Formatters;
+export interface FormattingOptions extends FormatterSettings {
     /** The active locale, read on every call (pass `() => i18n.global.locale.value` so it stays reactive). */
     locale: () => string;
-    /** Replaces any of the `Intl` defaults. */
+    /** Replaces any of the library's formatters. */
     formatters?: Partial<Formatters>;
     /** The symbol shown after an amount when no ISO currency is passed: "€", "KM". It is text, not a currency code. */
     currencySymbol?: string;
+    /** What `number` returns for a value with nothing to show (null, undefined, NaN): `"0"`. Default: the empty string, like the other functions. */
+    emptyNumber?: string;
+    /** A message in the active language, for the words of `day` ("core.activity.today"). Without it `day` is `date`. */
+    translate?: (key: string) => string;
 }
+/** The part of the options an application passes next to its formatters (`createApplication`'s `formatting`): the rest it already owns. */
+export type FormattingSettings = Omit<FormattingOptions, "locale" | "formatters" | "translate">;
 export declare function createFormatting(options: FormattingOptions): Formatting;
 /** The formatting of the app (or of a subtree): `installFormatting(app, createFormatting(...))` once, `useFormat()` below. */
 export declare const formattingKey: import("vue").InjectionKey<Formatting>, useFormat: () => Formatting;

package/dist/format/index.d.ts

@@ -1,3 +1,3 @@
 export { createFormatting, formattingKey, installFormatting, intlFormatters, toDate, useFormat } from "./format";
-export type { DateInput, Formatters, Formatting, FormattingOptions, MoneyOptions } from "./format";
+export type { DateInput, DayOptions, FormatterSettings, Formatters, Formatting, FormattingOptions, FormattingSettings, MoneyOptions, NumberSymbols } from "./format";
 export { slugify } from "./slug";

package/dist/format/index.js

@@ -1,4 +1,4 @@
-import { c as o, f as s, i, a as l, t as n, u as g } from "../format-D8KUBmbS.js";
+import { c as o, f as s, i, a as l, t as n, u as g } from "../format-DoKs29bZ.js";
 function e(a) {
   return a.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[đĐ]/g, "d").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }

package/dist/format-DoKs29bZ.js

@@ -0,0 +1,118 @@
+import { d as x } from "./context-Ch1r4fdN.js";
+const L = { bs: "sr-Latn-BA" }, M = (e, n = {}) => n[e] ?? L[e] ?? e, S = /^(\d{4})-(\d{2})-(\d{2})$/, I = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}/, Y = ["0000-00-00", "0001-01-01", "1970-01-01"];
+function D(e) {
+  if (e == null || e === "") return null;
+  let n;
+  if (e instanceof Date) n = e;
+  else if (typeof e == "number") n = new Date(e);
+  else {
+    if (Y.some((u) => e.startsWith(u))) return null;
+    const c = S.exec(e);
+    c ? n = new Date(Number(c[1]), Number(c[2]) - 1, Number(c[3])) : n = new Date(I.test(e) ? e.replace(" ", "T") : e);
+  }
+  return Number.isNaN(n.getTime()) || n.getTime() <= 0 ? null : n;
+}
+const h = { year: "numeric", month: "2-digit", day: "2-digit" }, T = { hour: "2-digit", minute: "2-digit" }, b = [
+  ["year", 31536e3],
+  ["month", 2592e3],
+  ["week", 604800],
+  ["day", 86400],
+  ["hour", 3600],
+  ["minute", 60],
+  ["second", 1]
+], F = (e, n = 2) => String(e).padStart(n, "0");
+function $(e, n, { group: c, decimal: u }) {
+  const g = n?.minimumFractionDigits ?? 0, l = Math.max(g, n?.maximumFractionDigits ?? 3), [d = "", i = ""] = e.toFixed(l).split(".");
+  let a = i;
+  for (; a.length > g && a.endsWith("0"); ) a = a.slice(0, -1);
+  const t = n?.useGrouping === !1 ? d : d.replace(/\B(?=(\d{3})+(?!\d))/g, c);
+  return a ? `${t}${u}${a}` : t;
+}
+function E(e = {}) {
+  const n = /* @__PURE__ */ new Map(), c = (t, r) => {
+    let m = n.get(t);
+    return m || (m = r(), n.set(t, m)), m;
+  }, u = (t) => M(t, e.intlLocale), g = (t, r) => c(`d|${t}|${JSON.stringify(r)}`, () => new Intl.DateTimeFormat(u(t), r)), l = (t, r) => c(`n|${t}|${JSON.stringify(r ?? {})}`, () => new Intl.NumberFormat(u(t), r)), { datePattern: d, numberSymbols: i } = e, a = (t, r) => r.replace(
+    /YYYY|MM|DD|HH|mm/g,
+    (m) => m === "YYYY" ? F(t.getFullYear(), 4) : F(m === "MM" ? t.getMonth() + 1 : m === "DD" ? t.getDate() : m === "HH" ? t.getHours() : t.getMinutes())
+  );
+  return {
+    date: (t, r) => d?.[r] ? a(t, d[r]) : g(r, h).format(t),
+    dateTime: (t, r) => d?.[r] ? a(t, `${d[r]} HH:mm`) : g(r, { ...h, ...T }).format(t),
+    time: (t, r) => g(r, T).format(t),
+    number: (t, r, m) => i && (m?.style ?? "decimal") === "decimal" ? $(t, m, i) : l(r, m).format(t),
+    money(t, r, m, s) {
+      const o = c(`m|${m}|${r}|${JSON.stringify(s ?? {})}`, () => new Intl.NumberFormat(u(m), { ...s, style: "currency", currency: r }));
+      if (!i) return o.format(t);
+      const y = o.formatToParts(t).find((w) => w.type === "currency")?.value ?? r, f = s?.maximumFractionDigits ?? o.resolvedOptions().maximumFractionDigits ?? 2;
+      return `${$(t, { minimumFractionDigits: f, maximumFractionDigits: f }, i)} ${y}`;
+    },
+    relative(t, r, m) {
+      const s = Math.trunc((t.getTime() - m.getTime()) / 1e3), [o, y] = b.find(([, f]) => Math.abs(s) >= f) ?? b[b.length - 1];
+      return c(`r|${r}`, () => new Intl.RelativeTimeFormat(u(r), { numeric: "auto" })).format(Math.trunc(s / y), o);
+    }
+  };
+}
+const N = (e, n) => e.getFullYear() === n.getFullYear() && e.getMonth() === n.getMonth() && e.getDate() === n.getDate();
+function C(e) {
+  const n = { ...E(e), ...e.formatters }, c = (i) => typeof i == "number" && Number.isFinite(i), u = () => M(e.locale(), e.intlLocale), g = (i) => {
+    const a = D(i);
+    return a ? n.time(a, e.locale()) : "";
+  }, l = (i) => {
+    const a = D(i);
+    return a ? n.date(a, e.locale()) : "";
+  }, d = (i, { inSentence: a = !1, now: t = /* @__PURE__ */ new Date() } = {}) => {
+    const r = D(i);
+    if (!r || !e.translate) return l(i);
+    const m = new Date(t.getFullYear(), t.getMonth(), t.getDate() - 1), s = N(r, t) ? "core.activity.today" : N(r, m) ? "core.activity.yesterday" : null;
+    if (!s) return l(i);
+    const o = e.translate(s);
+    return a ? o.toLocaleLowerCase(u()) : o.charAt(0).toLocaleUpperCase(u()) + o.slice(1);
+  };
+  return {
+    get locale() {
+      return e.locale();
+    },
+    get intlLocale() {
+      return u();
+    },
+    date: l,
+    dateTime: (i) => {
+      const a = D(i);
+      return a ? n.dateTime(a, e.locale()) : "";
+    },
+    time: g,
+    number: (i, a) => c(i) ? n.number(i, e.locale(), a) : e.emptyNumber ?? "",
+    get currencySymbol() {
+      return e.currencySymbol ?? "";
+    },
+    money: (i, { currency: a, decimals: t, whole: r, symbol: m = !0 } = {}) => {
+      if (!c(i)) return "";
+      const s = i, o = r && Number.isInteger(s) ? 0 : t, y = o === void 0 ? void 0 : { minimumFractionDigits: o, maximumFractionDigits: o };
+      if (a && m) return n.money(s, a, e.locale(), y);
+      const f = n.number(s, e.locale(), y ?? { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+      return m && !a && e.currencySymbol ? `${f} ${e.currencySymbol}` : f;
+    },
+    relative: (i, a = /* @__PURE__ */ new Date()) => {
+      const t = D(i);
+      return t ? n.relative(t, e.locale(), a) : "";
+    },
+    day: d,
+    dayTime: (i, a) => {
+      const t = d(i, a);
+      return t ? `${t} · ${g(i)}` : "";
+    }
+  };
+}
+const [A, O] = x("vue-core.formatting");
+function _(e, n) {
+  e.provide(A, n);
+}
+export {
+  E as a,
+  C as c,
+  A as f,
+  _ as i,
+  D as t,
+  O as u
+};

package/dist/{guards-Biv_SlGn.js → guards-DGcSfTEh.js}

@@ -1,5 +1,5 @@
 import { effectScope as R, watch as g } from "vue";
-import { h as b } from "./platform-BQOX_Ntw.js";
+import { h as b } from "./platform-DtISOEt7.js";
 const i = "redirect";
 function q(r) {
   const t = r.query[i], n = Array.isArray(t) ? t[0] : t;

package/dist/http-DOEfFCDA.js

@@ -0,0 +1,107 @@
+import { c as y } from "./current-B0lHKTWr.js";
+const E = [5, 8, 10, 15, 25, 50, 100], p = 25;
+function S(e) {
+  const r = `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(`${r}: \`stateVersion\` must be a positive integer.`);
+  if (typeof e.load != "function") throw new Error(`${r}: \`load\` must be a function.`);
+  if (typeof e.key != "function") throw new Error(`${r}: \`key\` must be a function.`);
+  const t = {
+    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 ?? E],
+    search: e.query?.search ?? !0
+  };
+  if (t.pageSizes.length === 0 || t.pageSizes.some((a) => !Number.isInteger(a) || a < 1))
+    throw new Error(`${r}: \`query.pageSizes\` must list positive integers.`);
+  for (const a of t.sensitive)
+    if (t.filters && !t.filters.includes(a)) throw new Error(`${r}: sensitive filter "${a}" is not in \`query.filters\`.`);
+  const s = e.defaults ?? {}, n = s.pageSize ?? (t.pageSizes.includes(p) ? p : t.pageSizes[0]);
+  if (!t.pageSizes.includes(n)) throw new Error(`${r}: default page size ${n} is not one of ${t.pageSizes.join(", ")}.`);
+  const o = s.sort ?? null;
+  if (o !== null && t.sorts && !t.sorts.includes(o)) throw new Error(`${r}: default sort "${o}" is not in \`query.sorts\`.`);
+  const i = s.view ?? null;
+  if (i !== null && t.views && !t.views.includes(i)) throw new Error(`${r}: default view "${i}" is not in \`query.views\`.`);
+  const f = Object.fromEntries(Object.entries(s.filters ?? {}).filter(([, a]) => a !== void 0 && a !== ""));
+  for (const a of Object.keys(f))
+    if (t.filters && !t.filters.includes(a)) throw new Error(`${r}: default filter "${a}" is not in \`query.filters\`.`);
+  const c = s.page ?? 1;
+  if (!Number.isInteger(c) || c < 1) throw new Error(`${r}: default page must be a positive integer.`);
+  const d = s.direction ?? "asc";
+  if (d !== "asc" && d !== "desc") throw new Error(`${r}: 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: c,
+      pageSize: n,
+      sort: o,
+      direction: d,
+      search: s.search ?? "",
+      view: i,
+      filters: Object.freeze(f)
+    }),
+    contract: Object.freeze(t),
+    migrate: e.migrate
+  });
+}
+const g = (e) => typeof e == "object" && e !== null && !Array.isArray(e), l = (...e) => {
+  for (const r of e) if (typeof r == "number" && Number.isFinite(r)) return r;
+  return null;
+};
+function m(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 h(e, r) {
+  const t = e.data, s = g(t) && Array.isArray(t.data), n = Array.isArray(t) ? t : s ? t.data : [], o = s ? t : {}, i = g(e.meta) ? e.meta : g(o.meta) ? o.meta : {}, f = l(o.per_page, i.per_page) ?? r.pageSize, c = l(o.total, i.total) ?? n.length, d = l(o.current_page, i.page, i.current_page) ?? r.page, a = l(o.last_page, i.last_page) ?? (c === 0 ? 0 : Math.ceil(c / Math.max(1, f))), w = l(o.from, i.from) ?? (n.length === 0 ? 0 : (d - 1) * f + 1), v = l(o.to, i.to) ?? (n.length === 0 ? 0 : w + n.length - 1), b = Array.isArray(i.views) ? i.views : Array.isArray(o.views) ? o.views : void 0;
+  return {
+    rows: n,
+    total: c,
+    page: d,
+    pageSize: f,
+    lastPage: a,
+    from: w,
+    to: v,
+    views: b?.filter(g).flatMap((u) => typeof u.key == "string" ? [{ key: u.key, count: l(u.count) ?? void 0 }] : []),
+    // Like `Row`, the shape of `meta` is the caller's word, not checked.
+    meta: i,
+    requestId: e.requestId
+  };
+}
+function z(e, r, t = {}) {
+  return async (s, { signal: n }) => {
+    const o = await e.get(r, { query: t.params ? t.params(s) : m(s), signal: n });
+    return h(o, s);
+  };
+}
+function A(e, r) {
+  return (t, s) => z(y().platform.http, e, r)(t, s);
+}
+function _(e, r = {}) {
+  return async (t, { signal: s }) => {
+    const n = { ...r, ...m(t) };
+    return h(await y().platform.http.request(e, n, { signal: s }), t);
+  };
+}
+export {
+  E as D,
+  m as a,
+  _ as b,
+  S as d,
+  z as h,
+  A as l,
+  h as r
+};