@saasicat/ui-vue 0.24.2 → 0.26.0

package/dist/{chunk-F7NRM6KI.js → chunk-BPF2BMCQ.js}

@@ -1,3 +1,284 @@
+// src/client/i18n/format.ts
+import { formatErrorMessage } from "@saasicat/types";
+function formatMessage(template, params) {
+  return formatErrorMessage(template, params);
+}
+
+// src/client/admin-error.ts
+var ADMIN_ERROR = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/AdminError");
+var PLATFORM_ERROR = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/PlatformError");
+function markPlatformError(error) {
+  Object.defineProperty(error, PLATFORM_ERROR, { value: true });
+}
+function isPlatformError(value) {
+  return typeof value === "object" && value !== null && PLATFORM_ERROR in value;
+}
+var EMPTY_RESPONSE = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/EmptyResponse");
+function markEmptyResponse(error) {
+  Object.defineProperty(error, EMPTY_RESPONSE, { value: true });
+  return error;
+}
+function isEmptyResponse(value) {
+  return typeof value === "object" && value !== null && EMPTY_RESPONSE in value;
+}
+var TRANSPORT_FAILURE = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/TransportFailure");
+function markTransportFailure(error) {
+  if (typeof error === "object" && error !== null) {
+    try {
+      Object.defineProperty(error, TRANSPORT_FAILURE, { value: true });
+    } catch {
+    }
+  }
+  return error;
+}
+function isTransportFailure(value) {
+  return typeof value === "object" && value !== null && TRANSPORT_FAILURE in value;
+}
+function describe(init) {
+  const status = init.status ?? 0;
+  const where = [init.method, init.url].filter(Boolean).join(" ");
+  const what = status > 0 ? `HTTP ${status}` : "request failed";
+  const head = where ? `${where} \u2192 ${what}` : what;
+  const code = init.code ? ` (${init.code})` : "";
+  return init.detail ? `${head}${code}: ${init.detail}` : `${head}${code}`;
+}
+var AdminError = class extends Error {
+  /** HTTP status. `0` means the request never produced one. */
+  status;
+  /** Machine-readable code from the response body, when it carried one. */
+  code;
+  /** Parsed response body, when there was one. */
+  body;
+  /** Requested URL, when known. */
+  url;
+  /** Request method, when known. */
+  method;
+  /**
+   * Text the failing side supplied — the only candidate for user-facing
+   * output. `undefined` when nothing was supplied.
+   */
+  detail;
+  /** The request completed but the answer was unusable. See `AdminErrorInit`. */
+  emptyResponse;
+  /** The request never reached the server. See `AdminErrorInit`. */
+  transportFailure;
+  constructor(init = {}) {
+    super(init.message ?? describe(init), { cause: init.cause });
+    this.name = "AdminError";
+    this.status = init.status ?? 0;
+    this.code = init.code;
+    this.body = init.body;
+    this.url = init.url;
+    this.method = init.method;
+    this.detail = init.detail;
+    this.emptyResponse = init.emptyResponse ?? false;
+    this.transportFailure = init.transportFailure ?? false;
+    Object.defineProperty(this, ADMIN_ERROR, { value: true });
+    markPlatformError(this);
+  }
+};
+function isAdminError(err) {
+  return typeof err === "object" && err !== null && ADMIN_ERROR in err;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function isAxiosNoResponseError(value) {
+  const record = asRecord(value);
+  if (!record) return false;
+  return record.isAxiosError === true && record.request != null && record.response == null;
+}
+function readErrorDetail(body) {
+  const record = asRecord(body);
+  if (!record) return asString(body);
+  const message = record.message;
+  if (Array.isArray(message)) {
+    const parts = message.filter((part) => typeof part === "string");
+    return parts.length > 0 ? parts.join(", ") : void 0;
+  }
+  return asString(message) ?? asString(record.error) ?? asString(record.reason);
+}
+function readErrorCode(body) {
+  return asString(asRecord(body)?.code);
+}
+function toAdminError(err) {
+  if (isAdminError(err)) return err;
+  const record = asRecord(err);
+  const response = asRecord(record?.response);
+  if (response && typeof response.status === "number") {
+    const config = asRecord(record?.config);
+    const body = response.data;
+    return new AdminError({
+      status: response.status,
+      code: readErrorCode(body),
+      body,
+      url: asString(config?.url),
+      method: asString(config?.method)?.toUpperCase(),
+      // Only what the response actually said. `err.message` here is
+      // axios's own generated line ("Request failed with status code
+      // 401") — English, untranslated, and about the transport rather
+      // than about what went wrong. Letting it through as `detail` would
+      // make `adminErrorMessage` return it in preference to the
+      // localized wording, which is the whole point of that wording.
+      detail: readErrorDetail(body),
+      cause: err
+    });
+  }
+  if (record && typeof record.status === "number") {
+    const ours = isPlatformError(err);
+    return new AdminError({
+      status: record.status,
+      code: readErrorCode(record.body) ?? asString(record.code),
+      body: record.body,
+      // Same reasoning as above: `BundlesApiError`'s message is
+      // "Bundles API responded with HTTP 403", a diagnostic. It stays on
+      // `message`, where logs read it.
+      detail: readErrorDetail(record.body) ?? (ours ? void 0 : asString(record.message)),
+      // Asked of the throw site, not of the class: only the site that
+      // read the response knows whether one arrived. `status === 0 &&
+      // ours` was the same question put to the wrong witness — the
+      // loaders raise branded errors from a status the client chose, so
+      // a client that resolves a transport failure as `0` turned a
+      // failed GET into "the change may have been applied".
+      emptyResponse: isEmptyResponse(err),
+      transportFailure: isTransportFailure(err),
+      message: asString(record.message),
+      cause: err
+    });
+  }
+  if (err instanceof Error) {
+    const transport = isTransportFailure(err) || isAxiosNoResponseError(err);
+    const saidSomethingReadable = !transport && !(err instanceof TypeError);
+    return new AdminError({
+      detail: saidSomethingReadable ? asString(err.message) : void 0,
+      transportFailure: transport,
+      message: err.message,
+      cause: err
+    });
+  }
+  const text = asString(err) ?? asString(record?.message);
+  return new AdminError({
+    code: asString(record?.code),
+    detail: text,
+    message: text,
+    cause: err
+  });
+}
+function statusKey(status) {
+  if (status === 400 || status === 422) return "validation";
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) return "notFound";
+  if (status === 409) return "conflict";
+  if (status === 429) return "rateLimited";
+  if (status >= 500) return "server";
+  return void 0;
+}
+function adminErrorMessage(err, msgs) {
+  const error = toAdminError(err);
+  if (error.detail) return error.detail;
+  if (error.emptyResponse) return msgs.emptyResponse;
+  if (error.transportFailure) return msgs.network;
+  if (error.status > 0) {
+    const key = statusKey(error.status);
+    return key ? msgs[key] : formatMessage(msgs.httpStatus, { status: error.status });
+  }
+  return msgs.unexpected;
+}
+
+// src/client/http-json.ts
+function serverAnswered(status) {
+  return status > 0;
+}
+function requireServerAnswer(status, method, url, raise) {
+  if (serverAnswered(status)) return;
+  throw markTransportFailure(
+    raise(`${method} ${url} produced no HTTP status \u2014 the request did not reach the server`)
+  );
+}
+var HttpJsonError = AdminError;
+async function readErrorBody(res) {
+  try {
+    return await res.json();
+  } catch {
+    return void 0;
+  }
+}
+async function failed(res, method, url) {
+  const body = await readErrorBody(res);
+  return new AdminError({
+    status: res.status,
+    // Read here rather than left to the status: `status: 0` reaches
+    // `adminErrorMessage` as "nothing is known about this failure", and
+    // this seam knows better — it held the response.
+    transportFailure: !serverAnswered(res.status),
+    code: readErrorCode(body),
+    body,
+    url,
+    method,
+    // Shared with `toAdminError` on purpose: a NestJS `ValidationPipe`
+    // rejection carries `message` as an array, and reading it here in a
+    // second, narrower way is how those constraints went missing.
+    detail: readErrorDetail(body)
+  });
+}
+function trimTrailingSlashes(url) {
+  let end = url.length;
+  while (end > 0 && url[end - 1] === "/") end--;
+  return url.slice(0, end);
+}
+async function getJson(http, url) {
+  const res = await http(url);
+  if (res.status < 200 || res.status >= 300) {
+    throw await failed(res, "GET", url);
+  }
+  return await res.json();
+}
+async function postJson(http, url, body) {
+  const res = await http(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (res.status < 200 || res.status >= 300) {
+    throw await failed(res, "POST", url);
+  }
+  return await res.json();
+}
+
+// src/client/http/fetch-http-client.ts
+var ABSOLUTE_URL = /^[a-z][a-z0-9+.-]*:|^\/\//i;
+function resolveUrl(url, baseUrl) {
+  if (!baseUrl || ABSOLUTE_URL.test(url)) return url;
+  return `${trimTrailingSlashes(baseUrl)}${url.startsWith("/") ? "" : "/"}${url}`;
+}
+function createFetchHttpClient(options = {}) {
+  return async (url, init) => {
+    const headers = new Headers(await options.headers?.());
+    if (!headers.has("Accept")) headers.set("Accept", "application/json");
+    for (const [name, value] of Object.entries(init?.headers ?? {})) {
+      headers.set(name, value);
+    }
+    if (init?.body !== void 0 && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    let response;
+    try {
+      response = await fetch(resolveUrl(url, options.baseUrl), {
+        method: init?.method ?? "GET",
+        headers,
+        body: init?.body
+      });
+    } catch (err) {
+      throw markTransportFailure(err);
+    }
+    return response;
+  };
+}
+
 // src/client/types.ts
 var NOOP_KV_STORE = {
   get: () => null,
@@ -39,8 +320,385 @@ function resolveLocalStorage() {
   }
 }
 function defaultHttpClient() {
-  return (url, init) => fetch(url, init);
+  return createFetchHttpClient();
+}
+
+// src/client/resources/define-resource.ts
+function defineResource(key, ops, options = {}) {
+  return { key, ops, projectScoped: options.projectScoped ?? false };
+}
+function requireProjectKey(def, ctx) {
+  if (!def.projectScoped) return;
+  if (typeof ctx.projectKey === "string" && ctx.projectKey.trim() !== "") return;
+  throw new Error(
+    `Resource "${def.key}" is project-scoped, but the context it is bound to names no project. Its requests would go out as \`?projectKey=\`, which the admin API answers for no project at all: the catalogue reads as empty and the first create fails validation instead. Name the project this admin administers \u2014 \`endpoints.projectKey\` for createSuperAdminApp(), \`context.projectKey\` for createResourceRegistry().`
+  );
+}
+function bindResource(def, http, ctx) {
+  const readContext = typeof ctx === "function" ? ctx : () => ctx;
+  if (def.projectScoped) requireProjectKey(def, readContext());
+  const bound = {};
+  for (const [name, op] of Object.entries(def.ops)) {
+    bound[name] = async (...args) => {
+      const context = readContext();
+      requireProjectKey(def, context);
+      return op(http, context, ...args);
+    };
+  }
+  return bound;
+}
+
+// src/client/resources/resource-request.ts
+async function requestJson(http, url, init = {}) {
+  const method = init.method ?? "GET";
+  const response = await http(url, {
+    method,
+    headers: { "content-type": "application/json", ...init.headers },
+    body: init.body === void 0 ? void 0 : JSON.stringify(init.body)
+  });
+  requireServerAnswer(
+    response.status,
+    method,
+    url,
+    (diagnostic) => new AdminError({ status: response.status, url, method, message: diagnostic })
+  );
+  if (response.status === 204) return null;
+  const body = await response.json().catch(() => null);
+  if (response.status >= 400) {
+    throw new AdminError({
+      status: response.status,
+      code: readErrorCode(body),
+      body,
+      // The third place this had to be read, and the second time it was
+      // read a narrower way: without `detail` a page migrating onto these
+      // resources loses "Plan already exists" and shows the generic
+      // status sentence instead. One decision, one function.
+      detail: readErrorDetail(body),
+      url,
+      method
+    });
+  }
+  return body;
+}
+async function requestJsonBody(http, url, what, init = {}) {
+  const body = await requestJson(http, url, init);
+  if (body === null || body === void 0) {
+    throw new AdminError({
+      status: 0,
+      url,
+      method: init.method ?? "GET",
+      // `what` is a diagnostic — "Create returned no body" — so it goes
+      // on `message`, not `detail`. As `detail` it out-ranked the
+      // localized wording and the operator read an English internal
+      // string instead of being told the change may already have landed.
+      message: what,
+      emptyResponse: true
+    });
+  }
+  return body;
+}
+
+// src/client/resources/list-resource.ts
+var LIST_FIRST_PAGE = 1;
+var LIST_PAGE_SIZE_DEFAULT = 50;
+var LIST_PAGE_SIZE_MAX = 200;
+var LIST_PAGINATION_PARAMS = ["page", "pageSize"];
+function isSentInQuery(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+function appendFilter(params, filter) {
+  for (const [key, value] of Object.entries(filter ?? {})) {
+    if (!isSentInQuery(value)) continue;
+    params.set(key, String(value));
+  }
+}
+function filterQueryString(filter) {
+  const params = new URLSearchParams();
+  appendFilter(params, filter);
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+function listUrl(endpoint, query = {}) {
+  const params = new URLSearchParams();
+  params.set("page", String(query.page ?? LIST_FIRST_PAGE));
+  params.set("pageSize", String(query.pageSize ?? LIST_PAGE_SIZE_DEFAULT));
+  appendFilter(params, query.filter);
+  return `${endpoint}${endpoint.includes("?") ? "&" : "?"}${params.toString()}`;
+}
+function readListPage(raw) {
+  if (Array.isArray(raw)) return { items: raw, total: raw.length };
+  if (raw === null || typeof raw !== "object") return { items: [], total: 0 };
+  const body = raw;
+  const page = {
+    items: Array.isArray(body.items) ? body.items : []
+  };
+  if (typeof body.total === "number") page.total = body.total;
+  if (typeof body.page === "number") page.page = body.page;
+  if (typeof body.pageSize === "number") page.pageSize = body.pageSize;
+  return page;
+}
+function clampListPage(page) {
+  return Math.max(LIST_FIRST_PAGE, Math.floor(page));
+}
+function clampListPageSize(size) {
+  return Math.min(LIST_PAGE_SIZE_MAX, Math.max(1, Math.floor(size)));
 }
+function defineListOp(endpoint) {
+  return async (http, ctx, query) => readListPage(await requestJson(http, listUrl(endpoint(ctx), query)));
+}
+
+// src/client/resources/plans.resource.ts
+function plansUrl(ctx) {
+  return `${ctx.apiBase}/catalog/plans`;
+}
+function versionsUrl(ctx) {
+  return `${ctx.apiBase}/catalog/plan-versions`;
+}
+function scoped(url, ctx) {
+  return `${url}?projectKey=${encodeURIComponent(ctx.projectKey)}`;
+}
+var plansResource = defineResource(
+  "plans",
+  {
+    list: async (http, ctx) => await requestJson(http, scoped(plansUrl(ctx), ctx)) ?? [],
+    tenantCounts: async (http, ctx) => await requestJson(
+      http,
+      scoped(`${plansUrl(ctx)}/tenant-counts`, ctx)
+    ) ?? {},
+    /**
+     * The project comes from the context, not from the caller.
+     *
+     * The endpoint takes it in the body, and the composable this replaces
+     * made that the caller's job — so a page had to keep hold of the
+     * project it was administering just to create in it, and `list()` and
+     * `create()` read two different sources for one value. A stale one
+     * creates a plan outside the project the list is showing.
+     */
+    create: (http, ctx, data) => requestJsonBody(http, plansUrl(ctx), "Create returned no body", {
+      method: "POST",
+      body: { ...data, projectKey: ctx.projectKey }
+    }),
+    update: (http, ctx, planId, data) => requestJsonBody(
+      http,
+      `${plansUrl(ctx)}/${planId}`,
+      "Update returned no body",
+      {
+        method: "PATCH",
+        body: data
+      }
+    ),
+    /** Marks the plan deleted. Fails while it still has versions. */
+    softDelete: async (http, ctx, planId) => {
+      await requestJson(http, `${plansUrl(ctx)}/${planId}`, { method: "DELETE" });
+    },
+    /** Removes the plan for good. 422 `PLAN_HAS_VERSIONS` when it cannot. */
+    hardDelete: async (http, ctx, planId) => {
+      await requestJson(http, `${plansUrl(ctx)}/${planId}/purge`, { method: "DELETE" });
+    }
+  },
+  { projectScoped: true }
+);
+var planVersionsResource = defineResource("planVersions", {
+  listForPlan: async (http, ctx, planId) => await requestJson(http, `${plansUrl(ctx)}/${planId}/versions`) ?? [],
+  createDraft: (http, ctx, planId, data) => requestJsonBody(
+    http,
+    `${plansUrl(ctx)}/${planId}/versions`,
+    "CreateDraft returned no body",
+    { method: "POST", body: data }
+  ),
+  updateDraft: (http, ctx, versionId, data) => requestJsonBody(
+    http,
+    `${versionsUrl(ctx)}/${versionId}`,
+    "UpdateDraft returned no body",
+    { method: "PATCH", body: data }
+  ),
+  publish: (http, ctx, versionId, options = {}) => requestJsonBody(
+    http,
+    `${versionsUrl(ctx)}/${versionId}/publish`,
+    "Publish returned no body",
+    { method: "POST", body: options }
+  ),
+  discardDraft: async (http, ctx, versionId) => {
+    await requestJson(http, `${versionsUrl(ctx)}/${versionId}`, { method: "DELETE" });
+  },
+  /**
+   * Ends a live version on `endsAt`, with no successor. Idempotent — a
+   * second call with another date overwrites the first.
+   *
+   * `endsAt` is the date itself, not a payload: the endpoint's body is
+   * `{ endsAt }` and wrapping it is this operation's job, not the caller's.
+   */
+  terminate: (http, ctx, versionId, endsAt) => requestJsonBody(
+    http,
+    `${versionsUrl(ctx)}/${versionId}/terminate`,
+    "Terminate returned no body",
+    { method: "POST", body: { endsAt } }
+  )
+});
+
+// src/client/resources/tenants.resource.ts
+var tenantsResource = defineResource("tenants", {
+  list: defineListOp((ctx) => `${ctx.apiBase}/tenants`)
+});
+
+// src/client/resources/audit.resource.ts
+var auditResource = defineResource("audit", {
+  list: defineListOp((ctx) => `${ctx.apiBase}/audit`)
+});
+
+// src/client/resources/index.ts
+var platformResources = {
+  plans: plansResource,
+  planVersions: planVersionsResource,
+  tenants: tenantsResource,
+  audit: auditResource
+};
+
+// src/client/boot-loader.ts
+var BootLoadError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "BootLoadError";
+    markPlatformError(this);
+  }
+  status;
+};
+var BootLoader = class {
+  endpoint;
+  http;
+  constructor(options) {
+    if (!options?.endpoint) {
+      throw new Error(
+        'BootLoader: `endpoint` is required (e.g. "/api/admin/boot" or "/api/v1/admin/boot"). The platform has no default because apps use different globalPrefix conventions.'
+      );
+    }
+    this.endpoint = options.endpoint;
+    this.http = options.http ?? defaultHttpClient();
+  }
+  async load() {
+    const res = await this.http(this.endpoint);
+    requireServerAnswer(
+      res.status,
+      "GET",
+      this.endpoint,
+      (diagnostic) => new BootLoadError(res.status, diagnostic)
+    );
+    if (res.status !== 200) {
+      throw new BootLoadError(res.status, `Boot endpoint responded with HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+};
+
+// src/client/manifest-loader.ts
+var NOT_MODIFIED = 304;
+var ManifestLoadError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ManifestLoadError";
+    markPlatformError(this);
+  }
+  status;
+};
+var ManifestLoader = class {
+  endpoint;
+  http;
+  storage;
+  bodyKey;
+  etagKey;
+  getAuthToken;
+  constructor(options) {
+    if (!options?.endpoint) {
+      throw new Error(
+        'ManifestLoader: `endpoint` is required (e.g. "/api/admin/manifest" or "/api/v1/admin/manifest"). The platform has no default because apps use different globalPrefix conventions.'
+      );
+    }
+    this.endpoint = options.endpoint;
+    this.http = options.http ?? defaultHttpClient();
+    this.storage = options.storage ?? defaultKvStore();
+    const prefix = options.storageKeyPrefix ?? "";
+    this.bodyKey = `${prefix}manifest:body`;
+    this.etagKey = `${prefix}manifest:etag`;
+    this.getAuthToken = options.getAuthToken;
+  }
+  /**
+   * Loads the current manifest. On a cache hit (304) the cached
+   * body is returned — otherwise the fresh server body.
+   *
+   * A 304 with no usable cached body is not a failure to report but one to
+   * undo: the request only carried `If-None-Match` because this loader put
+   * the ETag there, and the cache it validated against is this loader's own.
+   * So it drops the pair and asks once more without the header, which is the
+   * same recovery a person would have had to trigger by hand — except that
+   * the person reading an admin screen has neither this loader nor a
+   * console. Exactly one retry: a 304 to a request that asked nothing
+   * conditional is a server fault, and no repetition fixes it.
+   */
+  async load() {
+    const cachedEtag = this.storage.get(this.etagKey);
+    const res = await this.request(cachedEtag);
+    if (res.status !== NOT_MODIFIED) return this.acceptFresh(res);
+    const cached = this.readCachedBody();
+    if (cached) return cached.body;
+    if (cachedEtag) {
+      this.clearCache();
+      const fresh = await this.request(null);
+      if (fresh.status !== NOT_MODIFIED) return this.acceptFresh(fresh);
+    }
+    throw new ManifestLoadError(
+      NOT_MODIFIED,
+      "Manifest endpoint answered HTTP 304 to a request without If-None-Match"
+    );
+  }
+  /** Sends the manifest GET, conditional when an ETag is supplied. */
+  request(etag) {
+    const headers = {};
+    const token = this.getAuthToken?.();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    if (etag) headers["If-None-Match"] = etag;
+    return this.http(this.endpoint, { method: "GET", headers });
+  }
+  /** Takes a non-304 response as the current manifest and caches it. */
+  async acceptFresh(res) {
+    requireServerAnswer(
+      res.status,
+      "GET",
+      this.endpoint,
+      (diagnostic) => new ManifestLoadError(res.status, diagnostic)
+    );
+    if (res.status !== 200) {
+      throw new ManifestLoadError(
+        res.status,
+        `Manifest endpoint responded with HTTP ${res.status}`
+      );
+    }
+    const body = await res.json();
+    const etag = res.headers.get("ETag") ?? res.headers.get("etag");
+    if (etag) {
+      this.storage.set(this.etagKey, etag);
+      this.storage.set(this.bodyKey, JSON.stringify(body));
+    }
+    return body;
+  }
+  /** Reads the cached manifest body from storage; null if absent. */
+  readCachedBody() {
+    const etag = this.storage.get(this.etagKey);
+    const bodyStr = this.storage.get(this.bodyKey);
+    if (!etag || !bodyStr) return null;
+    try {
+      return { etag, body: JSON.parse(bodyStr) };
+    } catch {
+      return null;
+    }
+  }
+  /** Clears the cache — e.g. on logout or after `manifest reload`. */
+  clearCache() {
+    this.storage.remove(this.etagKey);
+    this.storage.remove(this.bodyKey);
+  }
+};
 
 // src/client/i18n/locale.ts
 var SA_LOCALES = ["de", "en"];
@@ -78,12 +736,6 @@ function mergeMessages(base, overrides) {
   return result;
 }
 
-// src/client/i18n/format.ts
-import { formatErrorMessage } from "@saasicat/types";
-function formatMessage(template, params) {
-  return formatErrorMessage(template, params);
-}
-
 // src/client/i18n/currency.ts
 var DEFAULT_CURRENCY = "EUR";
 var formatters = /* @__PURE__ */ new Map();
@@ -781,9 +1433,6 @@ var discoveryMessages = defineMessages(
     replacedBy: "ersetzt durch {key}",
     replaces: "ersetzt: {keys}",
     reapproveEmphasis: "erneut freigeben",
-    errorDiscoveryHttp: "Discovery-Endpoint antwortete mit HTTP {status}",
-    errorRescanHttp: "Discovery-Rescan antwortete mit HTTP {status}",
-    errorCatalogHttp: "Catalog-Entries-API antwortete mit HTTP {status}",
     capList: {
       orphanFeature: "Feature im Katalog ohne implementierende Capability \u2014 blockiert im blocking-Strict-Mode das Plan-Publish.",
       removedFromCode: "aus Code entfernt"
@@ -885,9 +1534,6 @@ var discoveryMessages = defineMessages(
     replacedBy: "replaced by {key}",
     replaces: "replaces: {keys}",
     reapproveEmphasis: "approve again",
-    errorDiscoveryHttp: "Discovery endpoint responded with HTTP {status}",
-    errorRescanHttp: "Discovery rescan responded with HTTP {status}",
-    errorCatalogHttp: "Catalog entries API responded with HTTP {status}",
     capList: {
       orphanFeature: "Feature in the catalog without an implementing capability \u2014 blocks plan publishing in blocking strict mode.",
       removedFromCode: "removed from code"
@@ -1092,6 +1738,36 @@ var emailMessages = defineMessages(
   }
 );
 
+// src/client/i18n/messages/errors.ts
+var errorsMessages = defineMessages(
+  {
+    network: "Die Anfrage konnte nicht abgeschlossen werden. Bitte Verbindung pr\xFCfen.",
+    emptyResponse: "Der Server hat nichts zur\xFCckgegeben. Bitte pr\xFCfen, ob die \xC4nderung angekommen ist.",
+    unauthorized: "Die Sitzung ist abgelaufen. Bitte erneut anmelden.",
+    forbidden: "F\xFCr diese Aktion fehlt die Berechtigung.",
+    notFound: "Der angeforderte Eintrag existiert nicht mehr.",
+    conflict: "Der Eintrag wurde zwischenzeitlich ge\xE4ndert. Bitte neu laden.",
+    validation: "Die Eingaben wurden nicht akzeptiert.",
+    rateLimited: "Zu viele Anfragen. Bitte kurz warten und erneut versuchen.",
+    server: "Der Server konnte die Anfrage nicht verarbeiten.",
+    httpStatus: "Die Anfrage ist fehlgeschlagen (HTTP {status}).",
+    unexpected: "Es ist ein unerwarteter Fehler aufgetreten. Bitte erneut versuchen."
+  },
+  {
+    network: "The request could not be completed. Please check your connection.",
+    emptyResponse: "The server returned nothing. Please check whether the change was applied.",
+    unauthorized: "Your session has expired. Please sign in again.",
+    forbidden: "You do not have permission for this action.",
+    notFound: "The requested entry no longer exists.",
+    conflict: "The entry changed in the meantime. Please reload.",
+    validation: "The input was not accepted.",
+    rateLimited: "Too many requests. Please wait a moment and try again.",
+    server: "The server could not process the request.",
+    httpStatus: "The request failed (HTTP {status}).",
+    unexpected: "Something went wrong. Please try again."
+  }
+);
+
 // src/client/i18n/messages/marketing.ts
 var marketingMessages = defineMessages(
   {
@@ -1216,9 +1892,6 @@ var marketingMessages = defineMessages(
       colorLabel: "Farbe",
       delete: "Aktion l\xF6schen",
       deleteConfirm: "Aktion \u201E{label}\u201C wirklich l\xF6schen?"
-    },
-    errors: {
-      projectionsApi: "MarketingProjections-API antwortete mit HTTP {status}"
     }
   },
   {
@@ -1343,9 +2016,6 @@ var marketingMessages = defineMessages(
       colorLabel: "Color",
       delete: "Delete promotion",
       deleteConfirm: 'Really delete promotion "{label}"?'
-    },
-    errors: {
-      projectionsApi: "MarketingProjections API responded with HTTP {status}"
     }
   }
 );
@@ -2589,7 +3259,6 @@ var promosMessages = defineMessages(
   {
     title: "Promo-Codes",
     createAction: "Promo-Code anlegen",
-    apiErrorHttpStatus: "Promotions-API antwortete mit HTTP {status}",
     list: {
       searchLabel: "Suche (Code)",
       tileScheduled: "Geplant",
@@ -2687,7 +3356,6 @@ var promosMessages = defineMessages(
   {
     title: "Promo codes",
     createAction: "Create promo code",
-    apiErrorHttpStatus: "Promotions API responded with HTTP {status}",
     list: {
       searchLabel: "Search (code)",
       tileScheduled: "Scheduled",
@@ -2795,7 +3463,13 @@ var shellMessages = defineMessages(
       subtitle: "SuperAdmin \xB7 Plattform-Verwaltung",
       roleBadge: "SUPER ADMIN",
       logout: "Abmelden",
-      language: "Sprache"
+      language: "Sprache",
+      theme: {
+        label: "Darstellung",
+        light: "Hell",
+        dark: "Dunkel",
+        system: "System"
+      }
     },
     drawer: {
       docs: "Doku \xF6ffnen"
@@ -2864,7 +3538,13 @@ var shellMessages = defineMessages(
       subtitle: "SuperAdmin \xB7 Platform administration",
       roleBadge: "SUPER ADMIN",
       logout: "Sign out",
-      language: "Language"
+      language: "Language",
+      theme: {
+        label: "Appearance",
+        light: "Light",
+        dark: "Dark",
+        system: "System"
+      }
     },
     drawer: {
       docs: "Open documentation"
@@ -3108,6 +3788,7 @@ var usersMessages = defineMessages(
 function catalogFor(locale) {
   return {
     common: commonMessages[locale],
+    errors: errorsMessages[locale],
     nav: navMessages[locale],
     shell: shellMessages[locale],
     dashboard: dashboardMessages[locale],
@@ -3167,8 +3848,52 @@ function createSaCatalog(options = {}) {
 }
 
 export {
+  formatMessage,
+  markPlatformError,
+  isPlatformError,
+  markEmptyResponse,
+  isEmptyResponse,
+  markTransportFailure,
+  isTransportFailure,
+  AdminError,
+  isAdminError,
+  isAxiosNoResponseError,
+  readErrorDetail,
+  readErrorCode,
+  toAdminError,
+  adminErrorMessage,
+  requireServerAnswer,
+  HttpJsonError,
+  trimTrailingSlashes,
+  getJson,
+  postJson,
+  createFetchHttpClient,
   defaultKvStore,
   defaultHttpClient,
+  defineResource,
+  bindResource,
+  requestJson,
+  requestJsonBody,
+  LIST_FIRST_PAGE,
+  LIST_PAGE_SIZE_DEFAULT,
+  LIST_PAGE_SIZE_MAX,
+  LIST_PAGINATION_PARAMS,
+  isSentInQuery,
+  filterQueryString,
+  listUrl,
+  readListPage,
+  clampListPage,
+  clampListPageSize,
+  defineListOp,
+  plansResource,
+  planVersionsResource,
+  tenantsResource,
+  auditResource,
+  platformResources,
+  BootLoadError,
+  BootLoader,
+  ManifestLoadError,
+  ManifestLoader,
   SA_LOCALES,
   DEFAULT_SA_LOCALE,
   SA_INTL_LOCALES,
@@ -3177,7 +3902,6 @@ export {
   defineMessages,
   mergeMessages,
   navMessages,
-  formatMessage,
   formatCurrency,
   SA_MESSAGES,
   resolveMessages,