@alxia/react-router 0.10.0 → 0.11.0

package/dist/errors/describe-refusal.d.ts

@@ -0,0 +1,6 @@
+import type { ApiErrors } from './api-errors';
+/** The API's refusal of `error`, or `undefined` when it is not one. */
+export declare function refusalOf<L extends string>(errors: Pick<ApiErrors<L>, 'apiErrorMessage' | 'unavailableMessage'>, error: unknown, language: L): ReturnType<ApiErrors<L>['apiRefusal']>;
+/** The worded message of each field an API error names, by field path. */
+export declare function fieldErrorsOf<L extends string>(errors: Pick<ApiErrors<L>, 'apiErrorMessage' | 'translateCode'>, error: Parameters<ApiErrors<L>['fieldErrors']>[0], language: L): ReturnType<ApiErrors<L>['fieldErrors']>;
+//# sourceMappingURL=describe-refusal.d.ts.map

package/dist/errors/describe-refusal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-refusal.d.ts","sourceRoot":"","sources":["../../src/errors/describe-refusal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EACzC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,EACpE,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,CAAC,GACT,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAWxC;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC7C,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,iBAAiB,GAAG,eAAe,CAAC,EAC/D,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EACjD,QAAQ,EAAE,CAAC,GACT,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAYzC"}

package/dist/errors/describe.d.ts

@@ -0,0 +1,3 @@
+import type { ApiErrors, ApiErrorsOptions } from './api-errors';
+export declare function describeApiErrors<L extends string>({ messages, unavailable, refused, byCode, isApiCode, }: ApiErrorsOptions<L>): ApiErrors<L>;
+//# sourceMappingURL=describe.d.ts.map

package/dist/errors/describe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe.d.ts","sourceRoot":"","sources":["../../src/errors/describe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMhE,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,EACnD,QAAQ,EACR,WAAW,EACX,OAAO,EACP,MAAW,EACX,SAAyC,GACzC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAkDpC"}

package/dist/errors/fetcher-result.d.ts

@@ -0,0 +1,21 @@
+import type { ApiErrors, ApiRefusal } from './api-errors';
+import { type RouteErrorOptions } from './route-error';
+/**
+ * A fetcher's refusal: the API's (`apiRefusal`), an unreachable API's too,
+ * so the page stays where it was. A 401 (the session caller redirects
+ * first) or any other failure is thrown, for the error page.
+ */
+export declare function fetcherRefusal<L extends string>(errors: Pick<ApiErrors<L>, 'apiRefusal'>, error: unknown, language: L, route?: RouteErrorOptions): ApiRefusal;
+/**
+ * Runs the mutation of an action a fetcher posted to: `{ ok: true }` with
+ * `about` and the mutation's value, or the refusal (`fetcherRefusal`) as a
+ * worded `error`, with its HTTP status, for a toast or a form message.
+ */
+export declare function fetcherResult<L extends string, About extends object, Value extends object = Record<never, never>>(errors: Pick<ApiErrors<L>, 'apiRefusal'>, language: L, about: About, run: () => Promise<Value>, route?: RouteErrorOptions): Promise<import("react-router").UNSAFE_DataWithResponseInit<{
+    ok: false;
+} & About & {
+    error: string;
+}> | ({
+    ok: true;
+} & About & Awaited<Value>)>;
+//# sourceMappingURL=fetcher-result.d.ts.map

package/dist/errors/fetcher-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher-result.d.ts","sourceRoot":"","sources":["../../src/errors/fetcher-result.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,eAAe,CAAC;AAEnE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC9C,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EACxC,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,CAAC,EACX,KAAK,CAAC,EAAE,iBAAiB,GACvB,UAAU,CAOZ;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAClC,CAAC,SAAS,MAAM,EAChB,KAAK,SAAS,MAAM,EACpB,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAE3C,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EACxC,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,EACzB,KAAK,CAAC,EAAE,iBAAiB;;;;;;6BAQzB"}

package/dist/errors/form-errors.d.ts

@@ -0,0 +1,8 @@
+/** What a form action answers when the API refused the input. */
+export type FormErrors = {
+    /** Messages by form field, already translated. */
+    fieldErrors?: Record<string, string>;
+    /** A message for the form as a whole, already translated. */
+    formError?: string | undefined;
+};
+//# sourceMappingURL=form-errors.d.ts.map

package/dist/errors/form-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-errors.d.ts","sourceRoot":"","sources":["../../src/errors/form-errors.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,MAAM,UAAU,GAAG;IACxB,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,CAAC"}

package/dist/errors/index.d.ts

@@ -0,0 +1,15 @@
+export { type ApiErrorEntryLike, type ApiErrorExtensionsLike, type ApiErrorLike, type ApiErrorParamsLike, type ApiFieldErrorLike, isApiErrorLike, waitMinutes, } from './api-error';
+export { type ApiErrors, type ApiErrorsOptions, type ApiRefusal, createApiErrors, } from './api-errors';
+export { apiCallFailure, type CallFailureOptions, type DocumentLike, operationName, } from './call-failure';
+export { type CatalogueReply, createErrorCatalogue, type ErrorCatalogue, type ErrorCatalogueOptions, } from './catalogue';
+export { type ApiCodeResolver, type ApiCodeResolverOptions, apiCodeResolver, type CodeIssueLike, } from './code-resolver';
+export type { FormErrors } from './form-errors';
+export { type JsonActions, type JsonActionsOptions, jsonActions, } from './json-actions';
+export { type ApiMessages, type ApiMessagesOptions, type CatalogueMessage, type CatalogueMessages, createApiMessages, type MessageFormat, type MessageValues, type ParamKind, } from './messages';
+export { nextOf } from './page-path';
+export { ApiMessagesProvider, type ApiMessagesProviderProps, } from './provider';
+export { REQUEST_ID_HEADER, requestIdOf } from './request-id';
+export { errorRequestId, type RouteErrorData, type RouteErrorOptions, routeError, } from './route-error';
+export type { StandardSchemaV1 } from './standard-schema';
+export { type JsonBody, useJsonFetcher } from './use-json-fetcher';
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,cAAc,EACd,WAAW,GACX,MAAM,aAAa,CAAC;AACrB,OAAO,EACN,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,eAAe,GACf,MAAM,cAAc,CAAC;AACtB,OAAO,EACN,cAAc,EACd,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,aAAa,GACb,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACN,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,qBAAqB,GAC1B,MAAM,aAAa,CAAC;AACrB,OAAO,EACN,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,eAAe,EACf,KAAK,aAAa,GAClB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,WAAW,GACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,SAAS,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EACN,mBAAmB,EACnB,KAAK,wBAAwB,GAC7B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EACN,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,UAAU,GACV,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/errors/index.js

@@ -0,0 +1,602 @@
+// src/errors/api-error.ts
+var isNamed = (error, name) => error instanceof Error && error.name === name;
+function isApiErrorLike(error) {
+  return isNamed(error, "ApiError") && Array.isArray(error.errors) && typeof error.status === "number";
+}
+function waitMinutes(extensions) {
+  const minutes = extensions?.params?.minutes ?? extensions?.minutes;
+  if (minutes !== undefined)
+    return Math.max(1, Number(minutes) || 1);
+  const seconds = extensions?.params?.retryAfter ?? extensions?.retryAfter;
+  return Math.max(1, Math.ceil(Number(seconds) / 60) || 1);
+}
+function valuesOf(extensions) {
+  if (!extensions)
+    return;
+  return extensions.params ? { ...extensions, ...extensions.params } : extensions;
+}
+var isStatusError = (error) => isNamed(error, "ApiStatusError") && typeof error.status === "number";
+var isUnavailableError = (error) => isNamed(error, "ApiUnavailableError") && typeof error.reason === "string";
+// src/errors/code-resolver.ts
+var API_CODE = /^[a-z-]+\.errors\.[a-z0-9-]+$/;
+function paramsCode(issue) {
+  const code = issue.params?.code;
+  return typeof code === "string" ? code : undefined;
+}
+function apiCodeResolver(messages, options) {
+  const isApiCode = (key) => options.isApiCode ? options.isApiCode(key) : API_CODE.test(key);
+  return {
+    translate(key, context, provideLanguage) {
+      if (!isApiCode(key))
+        return options.translate(key, context, provideLanguage);
+      const language = typeof provideLanguage === "function" ? provideLanguage() : provideLanguage ?? options.language();
+      return messages.apiMessage(key, context, language) ?? key;
+    },
+    codeOf(issue) {
+      return options.codeOf ? options.codeOf(issue) : paramsCode(issue);
+    }
+  };
+}
+
+// src/errors/describe-refusal.ts
+function refusalOf(errors, error, language) {
+  if (isApiErrorLike(error)) {
+    return {
+      message: errors.apiErrorMessage(error, language),
+      status: error.status
+    };
+  }
+  if (error instanceof Response && error.status === 503) {
+    return { message: errors.unavailableMessage(language), status: 503 };
+  }
+  return;
+}
+function fieldErrorsOf(errors, error, language) {
+  const extensions = error.errors[0]?.extensions;
+  const fields = Array.isArray(extensions?.fields) ? extensions.fields : [];
+  if (!fields.length && extensions?.field) {
+    return { [extensions.field]: errors.apiErrorMessage(error, language) };
+  }
+  return Object.fromEntries(fields.map(({ path, code, message, params }) => [
+    path,
+    errors.translateCode(code, message, language, params)
+  ]));
+}
+
+// src/errors/fetcher-result.ts
+import { data as data2 } from "react-router";
+
+// src/errors/route-error.ts
+import { data } from "react-router";
+
+// src/errors/request-id.ts
+var REQUEST_ID_HEADER = "x-request-id";
+function requestIdOf(response) {
+  return response.headers.get(REQUEST_ID_HEADER) || undefined;
+}
+
+// src/errors/route-error.ts
+var ROUTED = new Set([401, 403, 404, 503]);
+function routeError(error, { statuses = ROUTED } = {}) {
+  if (isApiErrorLike(error)) {
+    const { requestId } = error;
+    if (statuses.has(error.status)) {
+      return data({ code: error.code, message: error.message, requestId }, { status: error.status });
+    }
+    return requestId ? data({ requestId }, { status: 500 }) : error;
+  }
+  if (error instanceof Response && statuses.has(error.status)) {
+    const requestId = requestIdOf(error);
+    if (requestId) {
+      return data({ requestId }, { status: error.status });
+    }
+  }
+  return error;
+}
+function errorRequestId(error) {
+  if (typeof error !== "object" || error === null)
+    return;
+  const { data: body } = error;
+  if (typeof body !== "object" || body === null)
+    return;
+  const { requestId } = body;
+  return typeof requestId === "string" && requestId ? requestId : undefined;
+}
+
+// src/errors/fetcher-result.ts
+function fetcherRefusal(errors, error, language, route) {
+  const refusal = isApiErrorLike(error) && error.status === 401 ? undefined : errors.apiRefusal(error, language);
+  if (!refusal)
+    throw routeError(error, route);
+  return refusal;
+}
+async function fetcherResult(errors, language, about, run, route) {
+  try {
+    return { ok: true, ...about, ...await run() };
+  } catch (error) {
+    const { message, status } = fetcherRefusal(errors, error, language, route);
+    return data2({ ok: false, ...about, error: message }, { status });
+  }
+}
+
+// src/errors/submit-form.ts
+import { data as data3 } from "react-router";
+async function submitForm(errors, language, run, fieldOf, route) {
+  try {
+    return { ok: true, value: await run() };
+  } catch (error) {
+    if (!isApiErrorLike(error) || error.status === 401) {
+      throw routeError(error, route);
+    }
+    const field = error.errors[0]?.extensions?.field;
+    if (error.status === 404 && !(field && fieldOf(field))) {
+      throw routeError(error, route);
+    }
+    const byField = {};
+    const unplaced = [];
+    for (const [path, message] of Object.entries(errors.fieldErrors(error, language))) {
+      const field = fieldOf(path);
+      if (field)
+        byField[field] = message;
+      else
+        unplaced.push(message);
+    }
+    const formError = Object.keys(byField).length && !unplaced.length ? undefined : [errors.apiErrorMessage(error, language), ...unplaced].join(" ");
+    return data3({ fieldErrors: byField, formError }, { status: error.status });
+  }
+}
+
+// src/errors/describe.ts
+function describeApiErrors({
+  messages,
+  unavailable,
+  refused,
+  byCode = {},
+  isApiCode = (code) => API_CODE.test(code)
+}) {
+  const translateCode = (code, fallback, language, values) => {
+    if (!code)
+      return fallback;
+    return messages.apiMessage(code, values, language) ?? fallback;
+  };
+  const apiErrorMessage = (error, language) => {
+    const code = error.code;
+    if (refused && (!code || !isApiCode(code)))
+      return refused(language);
+    const own = code && Object.hasOwn(byCode, code) ? byCode[code] : undefined;
+    if (own)
+      return own(error, language);
+    return translateCode(code, error.message, language, valuesOf(error.errors[0]?.extensions));
+  };
+  const unavailableMessage = (language) => unavailable(language);
+  const apiRefusal = (error, language) => refusalOf({ apiErrorMessage, unavailableMessage }, error, language);
+  const fieldErrors = (error, language) => fieldErrorsOf({ apiErrorMessage, translateCode }, error, language);
+  const parts = { apiRefusal, apiErrorMessage, fieldErrors };
+  return {
+    translateCode,
+    apiErrorMessage,
+    unavailableMessage,
+    fieldErrors,
+    apiRefusal,
+    fetcherRefusal: (error, language, route) => fetcherRefusal(parts, error, language, route),
+    fetcherResult: (language, about, run, route) => fetcherResult(parts, language, about, run, route),
+    submitForm: (language, run, fieldOf, route) => submitForm(parts, language, run, fieldOf, route)
+  };
+}
+
+// src/errors/api-errors.ts
+function createApiErrors(options) {
+  return describeApiErrors(options);
+}
+// src/errors/log.ts
+function quietLog(log, methods) {
+  const quiet = {};
+  for (const method of methods) {
+    quiet[method] = (...args) => {
+      try {
+        log[method](...args);
+      } catch {}
+    };
+  }
+  return quiet;
+}
+
+// src/errors/call-failure.ts
+var PASSED_THROUGH = new Set([401, 403, 404]);
+var NO_BODY = new Set([101, 204, 205, 304]);
+function apiCallFailure(error, {
+  api,
+  operation = "operation",
+  requestId,
+  signal,
+  passedThrough = PASSED_THROUGH,
+  log: appLog = console
+}) {
+  const log = quietLog(appLog, ["warn", "error"]);
+  const call = `${api}: ${operation}${requestId ? ` (request ${requestId})` : ""}`;
+  const headers = requestId ? { [REQUEST_ID_HEADER]: requestId } : {};
+  const unavailable = (reason, cause) => {
+    log.error(`${call} ${reason}`, cause ?? "");
+    return new Response(null, { status: 503, headers });
+  };
+  if (isApiErrorLike(error)) {
+    if (requestId)
+      error.requestId = requestId;
+    const line = `${call} answered ${error.status}${error.code ? ` ${error.code}` : ""}`;
+    if (error.status >= 500)
+      log.error(line);
+    else
+      log.warn(line);
+    return error;
+  }
+  if (isStatusError(error)) {
+    if (passedThrough.has(error.status)) {
+      log.warn(`${call} answered ${error.status}`);
+      const statusText = typeof error.statusText === "string" ? error.statusText : "";
+      if (NO_BODY.has(error.status)) {
+        return new Response(null, {
+          status: error.status,
+          statusText,
+          headers
+        });
+      }
+      return new Response(statusText, {
+        status: error.status,
+        statusText,
+        headers
+      });
+    }
+    return unavailable(`answered ${error.status} without GraphQL`, error.body);
+  }
+  if (isUnavailableError(error))
+    return unavailable(error.reason, error.cause);
+  if (signal?.aborted)
+    return unavailable("aborted", error);
+  return error;
+}
+function operationName(document) {
+  for (const definition of document.definitions) {
+    if (definition.kind === "OperationDefinition") {
+      return definition.name?.value ?? definition.operation ?? "operation";
+    }
+  }
+  return "operation";
+}
+// src/errors/catalogue-check.ts
+async function checkVersions({ reader, versions, ttl, retryMs, log }, now) {
+  try {
+    const latest = await versions();
+    for (const [language, entry] of [...reader.held]) {
+      if (latest[language] !== entry.version) {
+        await reader.load(language, now);
+      } else {
+        entry.checkedAt = now;
+      }
+    }
+  } catch (error) {
+    log.error("alxia-react-router: the error catalogue was not checked, keeping what is held", error);
+    for (const entry of reader.held.values()) {
+      entry.checkedAt = now - ttl() + retryMs;
+    }
+  }
+}
+function safeTtl(ttlMs, fallback, log) {
+  return () => {
+    try {
+      const ttl = typeof ttlMs === "function" ? ttlMs() : ttlMs;
+      if (typeof ttl === "number" && Number.isFinite(ttl) && ttl >= 0) {
+        return ttl;
+      }
+      log.error("alxia-react-router: ttlMs is not a duration, using retryMs");
+    } catch (error) {
+      log.error("alxia-react-router: ttlMs threw, using retryMs", error);
+    }
+    return fallback;
+  };
+}
+
+// src/errors/catalogue-read.ts
+async function boundedWait(pending, firstReadWaitMs) {
+  const left = firstReadWaitMs - (performance.now() - pending.started);
+  if (left <= 0)
+    return;
+  let timer;
+  const limit = new Promise((resolve) => {
+    timer = setTimeout(resolve, left);
+  });
+  await Promise.race([pending.read, limit]);
+  clearTimeout(timer);
+}
+function createCatalogueReader({
+  messages,
+  read,
+  retryMs,
+  firstReadWaitMs,
+  log
+}) {
+  const held = new Map;
+  const loading = new Map;
+  const failedAt = new Map;
+  async function load(language, now) {
+    const reply = await read(language);
+    const entries = Object.create(null);
+    for (const { code, message, params } of reply.messages) {
+      entries[code] = { message, params };
+    }
+    messages.set(language, entries);
+    held.set(language, { version: reply.version, checkedAt: now });
+  }
+  function loadOnce(language, now) {
+    let pending = loading.get(language);
+    if (!pending) {
+      const started = performance.now();
+      const reading = load(language, now).then(() => {
+        failedAt.delete(language);
+      }).catch((error) => {
+        failedAt.set(language, now + (performance.now() - started));
+        log.error(`alxia-react-router: the error catalogue (${language}) was not read`, error);
+      }).finally(() => {
+        loading.delete(language);
+      });
+      pending = { read: reading, started };
+      loading.set(language, pending);
+    }
+    return pending;
+  }
+  return {
+    held,
+    load,
+    async first(language, now) {
+      const failed = failedAt.get(language);
+      if (failed === undefined || now - failed >= retryMs) {
+        await boundedWait(loadOnce(language, now), firstReadWaitMs);
+      }
+    },
+    reset() {
+      held.clear();
+      loading.clear();
+      failedAt.clear();
+    }
+  };
+}
+
+// src/errors/catalogue.ts
+function clientMessages(messages, languages, clientCodes) {
+  const byLanguage = {};
+  for (const language of languages) {
+    const entries = Object.create(null);
+    for (const code of clientCodes) {
+      const entry = messages.messageOf(language, code);
+      if (entry)
+        entries[code] = entry;
+    }
+    byLanguage[language] = entries;
+  }
+  return byLanguage;
+}
+function createErrorCatalogue({
+  messages,
+  languages,
+  read,
+  versions,
+  ttlMs,
+  retryMs = 5000,
+  firstReadWaitMs = 1500,
+  clientCodes,
+  log: appLog = console
+}) {
+  if (languages.length === 0) {
+    throw new TypeError("createErrorCatalogue(): needs at least one language.");
+  }
+  const log = quietLog(appLog, ["error"]);
+  const ttl = safeTtl(ttlMs, retryMs, log);
+  const reader = createCatalogueReader({
+    messages,
+    read,
+    retryMs,
+    firstReadWaitMs,
+    log
+  });
+  const context = { reader, versions, ttl, retryMs, log };
+  let checking;
+  async function fresh(language, now = Date.now()) {
+    const entry = reader.held.get(language);
+    if (!entry)
+      return reader.first(language, now);
+    if (now - entry.checkedAt >= ttl() && !checking) {
+      checking = checkVersions(context, now).finally(() => {
+        checking = undefined;
+      }).catch(() => {});
+    }
+  }
+  const freshAll = async (now = Date.now()) => {
+    await Promise.all(languages.map((language) => fresh(language, now)));
+  };
+  return {
+    fresh,
+    freshAll,
+    warm() {
+      freshAll().catch((error) => {
+        log.error("alxia-react-router: the error catalogue was not warmed", error);
+      });
+    },
+    clientMessages: () => clientMessages(messages, languages, clientCodes),
+    reset() {
+      reader.reset();
+      checking = undefined;
+      messages.clear();
+    },
+    heldVersion: (language) => reader.held.get(language)?.version,
+    settled: () => checking ?? Promise.resolve()
+  };
+}
+// src/errors/json-actions.ts
+import { data as data4, redirect } from "react-router";
+
+// src/errors/page-path.ts
+function nextOf(url) {
+  const { pathname, searchParams } = new URL(url);
+  const trimmed = pathname.endsWith("/_.data") ? pathname.slice(0, -"_.data".length) : pathname.replace(/\.data$/, "");
+  const path = trimmed.replace(/^\/{2,}/, "/");
+  const params = new URLSearchParams(searchParams);
+  params.delete("_routes");
+  for (const value of params.getAll("index")) {
+    if (!value)
+      params.delete("index", value);
+  }
+  const search = params.toString();
+  return search ? `${path}?${search}` : path;
+}
+
+// src/errors/json-actions.ts
+function jsonActions(options = {}) {
+  const ownOrigin = (request) => {
+    const { origin } = options;
+    const set = typeof origin === "function" ? origin() : origin;
+    return set ?? new URL(request.url).origin;
+  };
+  const isJson = (request) => request.headers.get("content-type")?.startsWith("application/json");
+  async function readJson(request) {
+    const origin = request.headers.get("origin");
+    const site = request.headers.get("sec-fetch-site");
+    if (origin && origin !== ownOrigin(request) || site && site !== "same-origin" && site !== "none") {
+      throw data4("Cross-site request refused", { status: 403 });
+    }
+    if (!isJson(request)) {
+      throw data4("Expected a JSON body", { status: 415 });
+    }
+    return request.json().catch(() => {
+      throw data4("Malformed JSON body", { status: 400 });
+    });
+  }
+  return {
+    readJson,
+    requireJsonPost(request) {
+      if (!isJson(request))
+        throw redirect(nextOf(request.url));
+    },
+    async readInput(request, schema) {
+      const body = await readJson(request);
+      const result = await schema["~standard"].validate(body?.input);
+      if (result.issues) {
+        throw data4("The form sent an input the API would refuse", {
+          status: 400
+        });
+      }
+      return result.value;
+    }
+  };
+}
+// src/errors/message-values.ts
+var DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+function dayOf(value) {
+  const parts = DAY.exec(value);
+  if (!parts)
+    return;
+  return new Date(Number(parts[1]), Number(parts[2]) - 1, Number(parts[3]));
+}
+function valuesFor(params, values) {
+  const worded = { ...values };
+  for (const { name, kind } of params) {
+    const value = values[name];
+    if (typeof value !== "string")
+      continue;
+    if (kind === "DATE") {
+      const day = dayOf(value);
+      if (day)
+        worded[name] = day;
+    } else if ((kind === "NUMBER" || kind === "PLURAL") && value.trim() !== "" && !Number.isNaN(Number(value))) {
+      worded[name] = Number(value);
+    }
+  }
+  return worded;
+}
+
+// src/errors/messages.ts
+function createApiMessages({
+  format
+}) {
+  const catalogues = new Map;
+  const messageOf = (language, code) => catalogues.get(language)?.get(code);
+  function formatEntry(entry, values, language) {
+    const worded = valuesFor(entry.params, values ?? {});
+    let failed = false;
+    try {
+      const text = format(entry.message, language, worded, {
+        onError: () => {
+          failed = true;
+        }
+      });
+      return failed ? undefined : text;
+    } catch {
+      return;
+    }
+  }
+  return {
+    set(language, messages) {
+      catalogues.set(language, new Map(Object.entries(messages)));
+    },
+    add(language, messages) {
+      const held = catalogues.get(language) ?? new Map;
+      for (const [code, message] of Object.entries(messages)) {
+        held.set(code, message);
+      }
+      catalogues.set(language, held);
+    },
+    clear() {
+      catalogues.clear();
+    },
+    messageOf,
+    format: formatEntry,
+    apiMessage(code, values, language) {
+      const entry = messageOf(language, code);
+      return entry ? formatEntry(entry, values, language) : undefined;
+    }
+  };
+}
+// src/errors/provider.ts
+function ApiMessagesProvider({
+  messages,
+  value,
+  children
+}) {
+  const inBrowser = typeof globalThis.document !== "undefined";
+  if (value && inBrowser) {
+    for (const [language, held] of Object.entries(value)) {
+      messages.add(language, held);
+    }
+  }
+  return children;
+}
+// src/errors/use-json-fetcher.ts
+import { useFetcher } from "react-router";
+function useJsonFetcher(key, action) {
+  const fetcher = useFetcher(key ? { key } : undefined);
+  const post = (body, to = action) => fetcher.submit(body, {
+    method: "post",
+    encType: "application/json",
+    ...to ? { action: to } : {}
+  });
+  return { fetcher, post, busy: fetcher.state !== "idle" };
+}
+export {
+  ApiMessagesProvider,
+  REQUEST_ID_HEADER,
+  apiCallFailure,
+  apiCodeResolver,
+  createApiErrors,
+  createApiMessages,
+  createErrorCatalogue,
+  errorRequestId,
+  isApiErrorLike,
+  jsonActions,
+  nextOf,
+  operationName,
+  requestIdOf,
+  routeError,
+  useJsonFetcher,
+  waitMinutes
+};
+
+//# debugId=0AF5BB2424365EAA64756E2164756E21
+//# sourceMappingURL=index.js.map