@saasicat/ui-vue 0.4.0 → 0.6.0

package/dist/chunk-A3W2N26K.js

@@ -0,0 +1,714 @@
+import {
+  DEFAULT_SA_LOCALE,
+  SA_INTL_LOCALES,
+  defaultHttpClient,
+  defaultKvStore,
+  formatMessage,
+  navMessages,
+  planVersionsMessages
+} from "./chunk-X5SQ5HMB.js";
+
+// src/client/version.ts
+var ADMIN_UI_VERSION = "1.2.0";
+
+// src/client/http-json.ts
+var HttpJsonError = class extends Error {
+  constructor(status, code) {
+    super(code ?? `HTTP ${status}`);
+    this.status = status;
+    this.code = code;
+    this.name = "HttpJsonError";
+  }
+  status;
+  code;
+};
+async function extractCode(res) {
+  try {
+    const body = await res.json();
+    return typeof body?.code === "string" ? body.code : void 0;
+  } catch {
+    return void 0;
+  }
+}
+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 new HttpJsonError(res.status, await extractCode(res));
+  }
+  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 new HttpJsonError(res.status, await extractCode(res));
+  }
+  return await res.json();
+}
+
+// src/client/boot-loader.ts
+var BootLoadError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "BootLoadError";
+  }
+  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);
+    if (res.status !== 200) {
+      throw new BootLoadError(res.status, `Boot-Endpunkt antwortete HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+};
+
+// src/client/manifest-loader.ts
+var ManifestLoadError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ManifestLoadError";
+  }
+  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.
+   */
+  async load() {
+    const cachedEtag = this.storage.get(this.etagKey);
+    const headers = {};
+    const token = this.getAuthToken?.();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    if (cachedEtag) headers["If-None-Match"] = cachedEtag;
+    const res = await this.http(this.endpoint, { method: "GET", headers });
+    if (res.status === 304) {
+      const cachedBody = this.readCachedBody();
+      if (!cachedBody) {
+        throw new ManifestLoadError(
+          304,
+          "Server returned 304 but the cache body is missing \u2014 call clearCache() and reload"
+        );
+      }
+      return cachedBody.body;
+    }
+    if (res.status !== 200) {
+      throw new ManifestLoadError(
+        res.status,
+        `Manifest-Endpunkt antwortete 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/nav-builder.ts
+var DEFAULT_STANDARD_PAGE_ROUTES = {
+  dashboard: "/admin/dashboard",
+  tenants: "/admin/tenants",
+  subscriptions: "/admin/subscriptions",
+  promoCodes: "/admin/promo-codes",
+  plans: "/admin/plans",
+  planVersions: "/admin/plan-versions",
+  audit: "/admin/audit",
+  users: "/admin/users",
+  pilots: "/admin/pilots",
+  discovery: "/admin/discovery",
+  bundles: "/admin/bundles",
+  marketingCatalog: "/admin/marketing-catalog",
+  platformEmail: "/admin/platform-email",
+  platformEmailHistory: "/admin/platform-email-history"
+};
+var DEFAULT_ICONS = {
+  dashboard: "dashboard",
+  tenants: "business",
+  subscriptions: "card_membership",
+  promoCodes: "local_activity",
+  plans: "workspace_premium",
+  planVersions: "history_edu",
+  audit: "history",
+  users: "people",
+  pilots: "flight_takeoff",
+  discovery: "travel_explore",
+  bundles: "inventory_2",
+  marketingCatalog: "campaign",
+  platformEmail: "mail",
+  platformEmailHistory: "mark_email_read"
+};
+var PAGE_SECTIONS = {
+  dashboard: "overview",
+  discovery: "catalog",
+  bundles: "catalog",
+  plans: "catalog",
+  planVersions: "catalog",
+  marketingCatalog: "catalog",
+  promoCodes: "catalog",
+  tenants: "customers",
+  subscriptions: "customers",
+  users: "customers",
+  pilots: "customers",
+  audit: "system",
+  platformEmail: "system",
+  platformEmailHistory: "system"
+};
+function defaultSectionOrder(locale = DEFAULT_SA_LOCALE) {
+  const sections = navMessages[locale].sections;
+  return [sections.overview, sections.catalog, sections.customers, sections.system];
+}
+function buildRoutes(manifest, options = {}) {
+  const routes = [];
+  const capabilities = manifest.capabilities ?? {};
+  const standard = manifest.navigation?.standardPages ?? {};
+  const nav = navMessages[options.locale ?? DEFAULT_SA_LOCALE];
+  const defaultNavSections = Object.fromEntries(
+    Object.entries(PAGE_SECTIONS).map(([page, section]) => [page, nav.sections[section]])
+  );
+  const overrideRoutes = { ...DEFAULT_STANDARD_PAGE_ROUTES, ...options.standardPageRoutes };
+  const overrideLabels = { ...nav.pages, ...options.standardPageLabels };
+  const overrideIcons = { ...DEFAULT_ICONS, ...options.standardPageIcons };
+  const overrideNavSection = { ...defaultNavSections, ...options.standardPageNavSection };
+  for (const key of Object.keys(standard)) {
+    const def = standard[key];
+    if (!def?.enabled) continue;
+    const cap = def.requiredCapability ?? null;
+    if (cap && capabilities[cap] !== true) continue;
+    routes.push({
+      id: key,
+      path: overrideRoutes[key],
+      label: overrideLabels[key],
+      icon: overrideIcons[key],
+      navSection: overrideNavSection[key],
+      componentKey: `platform-${key}`,
+      requiredCapability: cap,
+      isStandard: true
+    });
+  }
+  const projectPages = manifest.navigation?.projectPages ?? [];
+  const exts = options.availableExtensions;
+  for (const p of projectPages) {
+    const cap = p.requiredCapability ?? null;
+    if (cap && capabilities[cap] !== true) continue;
+    if (exts && !exts.has(p.componentKey)) continue;
+    routes.push({
+      id: p.id,
+      path: p.route,
+      label: p.label,
+      icon: p.icon,
+      navSection: p.navSection,
+      componentKey: p.componentKey,
+      requiredCapability: cap,
+      isStandard: false,
+      prefetchOnIdle: p.prefetchOnIdle
+    });
+  }
+  return routes;
+}
+function buildSidebar(routes, sectionOrder = defaultSectionOrder()) {
+  const bySection = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    const section = r.navSection ?? null;
+    const list = bySection.get(section) ?? [];
+    list.push({ id: r.id, path: r.path, label: r.label, icon: r.icon });
+    bySection.set(section, list);
+  }
+  const sections = [];
+  if (bySection.has(null)) {
+    sections.push({ section: null, items: bySection.get(null) });
+  }
+  const ordered = /* @__PURE__ */ new Set();
+  for (const name of sectionOrder) {
+    if (bySection.has(name)) {
+      sections.push({ section: name, items: bySection.get(name) });
+      ordered.add(name);
+    }
+  }
+  const remaining = [...bySection.entries()].filter(([s]) => s !== null && !ordered.has(s)).sort((a, b) => a[0].localeCompare(b[0]));
+  for (const [section, items] of remaining) {
+    sections.push({ section, items });
+  }
+  return sections;
+}
+function resolveExtension(componentKey, extensions) {
+  return extensions[componentKey] ?? null;
+}
+
+// src/client/action-registry.ts
+var MissingHandlerError = class extends Error {
+  constructor(actionKey) {
+    super(
+      `No handler registered for actionKey "${actionKey}". The consumer shell must provide \`actions["${actionKey}"]\`.`
+    );
+    this.name = "MissingHandlerError";
+  }
+};
+var ActionDefNotInManifestError = class extends Error {
+  constructor(actionKey) {
+    super(
+      `actionKey "${actionKey}" is not declared in the manifest. Register it as a TenantAction in a ManifestContribution.`
+    );
+    this.name = "ActionDefNotInManifestError";
+  }
+};
+var ActionRegistry = class {
+  defs = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  constructor(manifest, handlers = {}) {
+    for (const def of manifest.tenants?.actions ?? []) {
+      this.defs.set(def.actionKey, def);
+    }
+    for (const [key, handler] of Object.entries(handlers)) {
+      this.handlers.set(key, handler);
+    }
+  }
+  /**
+   * Registers a handler after the fact (e.g. when consumer code loads
+   * lazily). Throws `ActionDefNotInManifestError` if the `actionKey` is not
+   * declared in the manifest — prevents dead registrations.
+   */
+  register(actionKey, handler) {
+    if (!this.defs.has(actionKey)) {
+      throw new ActionDefNotInManifestError(actionKey);
+    }
+    this.handlers.set(actionKey, handler);
+  }
+  /**
+   * Returns the `{def, handler}` pair. Throws if the key is missing from
+   * the manifest or no handler is registered. The shell's UI layer calls
+   * the method, checks `def.requiresMfa` / `def.confirmType` for the
+   * pre-flow, and then calls `handler(input)`.
+   */
+  get(actionKey) {
+    const def = this.defs.get(actionKey);
+    if (!def) throw new ActionDefNotInManifestError(actionKey);
+    const handler = this.handlers.get(actionKey);
+    if (!handler) throw new MissingHandlerError(actionKey);
+    return { def, handler };
+  }
+  /**
+   * Convenience: `get(key).handler(input)`. UI convenience for actions
+   * that need neither MFA nor confirm.
+   */
+  async dispatch(actionKey, input) {
+    return this.get(actionKey).handler(input);
+  }
+  /**
+   * List of actionKeys that are declared in the manifest but have no
+   * handler. Consumers use this in a doctor check to detect drift between
+   * the manifest and the shell build.
+   */
+  listOrphanedDefs() {
+    return [...this.defs.keys()].filter((k) => !this.handlers.has(k));
+  }
+  /**
+   * List of registered handlers that are missing from the manifest. Drift
+   * in the other direction.
+   */
+  listOrphanedHandlers() {
+    return [...this.handlers.keys()].filter((k) => !this.defs.has(k));
+  }
+};
+
+// src/client/batch-column-fetcher.ts
+var BatchColumnDriftError = class extends Error {
+  constructor(column, reason) {
+    super(`Spalte "${column.key}": ${reason}`);
+    this.column = column;
+    this.name = "BatchColumnDriftError";
+  }
+  column;
+};
+var BatchColumnFetcher = class {
+  http;
+  paramStyle;
+  getAuthToken;
+  constructor(options = {}) {
+    this.http = options.http ?? defaultHttpClient();
+    this.paramStyle = options.paramStyle ?? "comma";
+    this.getAuthToken = options.getAuthToken;
+  }
+  /**
+   * Loads the data for all columns declared in the manifest in parallel
+   * (one request per column, all `tenantIds` in the batch). Columns without
+   * a satisfied capability are ignored.
+   */
+  async fetchAll(manifest, tenantIds) {
+    if (tenantIds.length === 0) return {};
+    const cols = this.eligibleColumns(manifest);
+    const results = await Promise.all(
+      cols.map(
+        (col) => this.fetchOne(col, tenantIds).then((data) => [col.key, data])
+      )
+    );
+    const out = {};
+    for (const [key, data] of results) out[key] = data;
+    return out;
+  }
+  /** Fetch a single column (consumers may also use this directly). */
+  async fetchOne(column, tenantIds) {
+    this.validateBatchEndpoint(column);
+    if (tenantIds.length === 0) return {};
+    const url = this.buildUrl(column.endpoint, tenantIds);
+    const headers = {};
+    const token = this.getAuthToken?.();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const res = await this.http(url, { method: "GET", headers });
+    if (res.status !== 200) {
+      throw new Error(
+        `Spalte "${column.key}" \u2014 Endpoint ${column.endpoint} antwortete HTTP ${res.status}`
+      );
+    }
+    const body = await res.json();
+    return body;
+  }
+  /**
+   * Column drift against the manifest. Consumers use this for CI smoke
+   * tests of the manifest-vs-shell build.
+   */
+  listDriftIssues(manifest) {
+    const issues = [];
+    for (const col of manifest.tenants?.columns ?? []) {
+      try {
+        this.validateBatchEndpoint(col);
+      } catch (err) {
+        if (err instanceof BatchColumnDriftError) issues.push(err);
+      }
+    }
+    return issues;
+  }
+  /**
+   * Which columns have a satisfied `requiredCapability`? Manifest =
+   * discovery, so a local check is enough.
+   */
+  eligibleColumns(manifest) {
+    const caps = manifest.capabilities ?? {};
+    return (manifest.tenants?.columns ?? []).filter((col) => {
+      if (!col.requiredCapability) return true;
+      return caps[col.requiredCapability] === true;
+    });
+  }
+  validateBatchEndpoint(col) {
+    if (!col.endpoint || col.endpoint.trim().length === 0) {
+      throw new BatchColumnDriftError(col, "endpoint is empty");
+    }
+    if (col.endpoint.includes("{slug}") || col.endpoint.includes("{tenantId}")) {
+      throw new BatchColumnDriftError(
+        col,
+        "endpoint contains per-tenant placeholders ({slug}/{tenantId}). Column endpoints must be batchable \u2014 switch the backend to a `?tenantIds=...` parameter."
+      );
+    }
+  }
+  buildUrl(endpoint, tenantIds) {
+    const sep = endpoint.includes("?") ? "&" : "?";
+    if (this.paramStyle === "comma") {
+      const enc = tenantIds.map(encodeURIComponent).join(",");
+      return `${endpoint}${sep}tenantIds=${enc}`;
+    }
+    const params = tenantIds.map((id) => `tenantIds=${encodeURIComponent(id)}`).join("&");
+    return `${endpoint}${sep}${params}`;
+  }
+};
+
+// src/client/plan-versions-catalog.ts
+var dec = (s) => Number(s);
+function extractQuotas(p) {
+  if (p.quotas && Object.keys(p.quotas).length > 0) {
+    return { ...p.quotas };
+  }
+  const out = {};
+  if (typeof p.maxUsers === "number") out.users = p.maxUsers;
+  if (typeof p.maxVehicles === "number") out.vehicles = p.maxVehicles;
+  if (typeof p.maxStorageGb === "number") out.storageGb = p.maxStorageGb;
+  return out;
+}
+var sortByPublishedDesc = (rows) => [...rows].sort((a, b) => {
+  const at = a.publishedAt ? Date.parse(a.publishedAt) : Number.POSITIVE_INFINITY;
+  const bt = b.publishedAt ? Date.parse(b.publishedAt) : Number.POSITIVE_INFINITY;
+  if (at !== bt) return bt - at;
+  return b.version - a.version;
+});
+function findLiveAt(rows, asOfMs) {
+  const candidates = rows.filter((r) => {
+    if (r.publishedAt === null) return false;
+    if (Date.parse(r.publishedAt) > asOfMs) return false;
+    if (r.supersededAt !== null && Date.parse(r.supersededAt) <= asOfMs) return false;
+    return true;
+  });
+  if (candidates.length === 0) return null;
+  return [...candidates].sort((a, b) => b.version - a.version)[0] ?? null;
+}
+function findCurrentLive(rows) {
+  return rows.find((r) => r.publishedAt !== null && r.supersededAt === null) ?? null;
+}
+function findDraft(rows) {
+  return rows.find((r) => r.publishedAt === null) ?? null;
+}
+function groupBy(rows, keyOf) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const k = keyOf(r);
+    const list = out.get(k) ?? [];
+    list.push(r);
+    out.set(k, list);
+  }
+  return out;
+}
+function resolvePlan(source, liveBase) {
+  const quotas = extractQuotas(source);
+  return {
+    source,
+    liveBase,
+    isDraft: source.publishedAt === null,
+    planId: source.planId,
+    features: source.features,
+    quotas,
+    monthlyNet: dec(source.monthlyNet),
+    yearlyNet: dec(source.yearlyNet),
+    marketed: source.marketed,
+    version: source.version,
+    maxUsers: quotas.users,
+    maxVehicles: quotas.vehicles,
+    maxStorageGb: quotas.storageGb
+  };
+}
+function draftsTitle(draftCount, msg) {
+  if (draftCount === 0) return msg.draftsTitleEmpty;
+  const template = draftCount === 1 ? msg.draftsTitleOne : msg.draftsTitleMany;
+  return formatMessage(template, { count: draftCount });
+}
+function dateLabel(iso, locale) {
+  return new Date(iso).toLocaleDateString(SA_INTL_LOCALES[locale], {
+    day: "2-digit",
+    month: "short",
+    year: "numeric"
+  });
+}
+function buildDraftsSnapshot(data, sortPlansFn, locale) {
+  const msg = planVersionsMessages[locale].catalog;
+  const planByKey = groupBy(data.planVersions, (r) => r.planId);
+  const plans = [];
+  for (const [, rows] of planByKey) {
+    const draft = findDraft(rows);
+    const live = findCurrentLive(rows);
+    if (draft) plans.push(resolvePlan(draft, live));
+    else if (live) plans.push(resolvePlan(live, null));
+  }
+  const draftCount = plans.filter((p) => p.isDraft).length;
+  return {
+    id: "drafts",
+    kind: "drafts",
+    status: "DRAFT",
+    label: msg.draftsLabel,
+    title: draftsTitle(draftCount, msg),
+    description: draftCount === 0 ? msg.draftsDescriptionEmpty : msg.draftsDescription,
+    asOf: null,
+    createdAt: null,
+    publishedAt: null,
+    authorEmail: null,
+    plans: sortPlansFn(plans),
+    draftCount,
+    regressionCount: 0
+  };
+}
+function buildActiveSnapshot(data, sortPlansFn, locale) {
+  const msg = planVersionsMessages[locale].catalog;
+  const planByKey = groupBy(data.planVersions, (r) => r.planId);
+  const plans = [];
+  for (const [, rows] of planByKey) {
+    const live = findCurrentLive(rows);
+    if (live) plans.push(resolvePlan(live, null));
+  }
+  if (plans.length === 0) return null;
+  const publishedDates = plans.map((p) => p.source.publishedAt).filter((t) => t !== null).sort();
+  const latestPublished = publishedDates[publishedDates.length - 1];
+  return {
+    id: "active",
+    kind: "active",
+    status: "ACTIVE",
+    label: msg.activeLabel,
+    title: msg.activeTitle,
+    description: msg.activeDescription,
+    asOf: latestPublished ?? null,
+    createdAt: null,
+    publishedAt: latestPublished ?? null,
+    authorEmail: null,
+    plans: sortPlansFn(plans),
+    draftCount: 0,
+    regressionCount: 0
+  };
+}
+function buildHistoricalSnapshots(data, sortPlansFn, locale) {
+  const msg = planVersionsMessages[locale].catalog;
+  const allPublishedAt = /* @__PURE__ */ new Set();
+  for (const r of data.planVersions) if (r.publishedAt) allPublishedAt.add(r.publishedAt);
+  if (allPublishedAt.size === 0) return [];
+  const planByKey = groupBy(data.planVersions, (r) => r.planId);
+  const liveTimestamps = /* @__PURE__ */ new Set();
+  for (const rows of planByKey.values()) {
+    const live = findCurrentLive(rows);
+    if (live?.publishedAt) liveTimestamps.add(live.publishedAt);
+  }
+  const liveSorted = [...liveTimestamps].sort();
+  const latestLive = liveSorted[liveSorted.length - 1];
+  const sortedDesc = [...allPublishedAt].sort((a, b) => Date.parse(b) - Date.parse(a));
+  const out = [];
+  for (const ts of sortedDesc) {
+    if (latestLive && Date.parse(ts) >= Date.parse(latestLive)) continue;
+    const tMs = Date.parse(ts) + 1;
+    const plans = [];
+    for (const [, rows] of planByKey) {
+      const live = findLiveAt(rows, tMs);
+      if (live) plans.push(resolvePlan(live, null));
+    }
+    if (plans.length === 0) continue;
+    const publishedAtThisEvent = data.planVersions.filter((r) => r.publishedAt === ts);
+    const regressionCount = publishedAtThisEvent.filter((r) => !r.nonRegressive).length;
+    const author = publishedAtThisEvent[0]?.publishedByUserId ?? null;
+    out.push({
+      id: `hist-${ts}`,
+      kind: "historical",
+      status: "ARCHIVED",
+      label: dateLabel(ts, locale),
+      title: summarizeEvent(publishedAtThisEvent, msg),
+      description: detailEvent(publishedAtThisEvent, msg),
+      asOf: ts,
+      createdAt: ts,
+      publishedAt: ts,
+      authorEmail: author,
+      plans: sortPlansFn(plans),
+      draftCount: 0,
+      regressionCount
+    });
+  }
+  return out;
+}
+function summarizeEvent(rows, msg) {
+  if (rows.length === 0) return msg.publishEvent;
+  if (rows.length === 1) {
+    const r = rows[0];
+    return formatMessage(msg.publishEventSingle, { planId: r.planId, version: r.version });
+  }
+  return formatMessage(msg.publishEventMultiple, { count: rows.length });
+}
+function detailEvent(rows, msg) {
+  if (rows.length === 0) return "";
+  const note = rows[0]?.changeNote ?? "";
+  return note.length > 0 ? note : msg.reconstructedSnapshot;
+}
+function sortPlansBy(order) {
+  if (!order || order.length === 0) {
+    return (rows) => [...rows].sort((a, b) => a.planId.localeCompare(b.planId));
+  }
+  const idx = {};
+  for (let i = 0; i < order.length; i++) idx[order[i]] = i;
+  return (rows) => [...rows].sort((a, b) => {
+    const ai = idx[a.planId] ?? Number.POSITIVE_INFINITY;
+    const bi = idx[b.planId] ?? Number.POSITIVE_INFINITY;
+    if (ai !== bi) return ai - bi;
+    return a.planId.localeCompare(b.planId);
+  });
+}
+function buildSnapshots(data, options = {}) {
+  const locale = options.locale ?? DEFAULT_SA_LOCALE;
+  const sortPlansFn = sortPlansBy(options.planSortOrder);
+  const drafts = buildDraftsSnapshot(data, sortPlansFn, locale);
+  const active = buildActiveSnapshot(data, sortPlansFn, locale);
+  const historical = buildHistoricalSnapshots(data, sortPlansFn, locale);
+  const out = [drafts];
+  if (active) out.push(active);
+  out.push(...historical);
+  return out;
+}
+function listOpenDrafts(data) {
+  return {
+    plans: sortByPublishedDesc(data.planVersions).filter((r) => r.publishedAt === null)
+  };
+}
+
+export {
+  ADMIN_UI_VERSION,
+  HttpJsonError,
+  trimTrailingSlashes,
+  getJson,
+  postJson,
+  BootLoadError,
+  BootLoader,
+  ManifestLoadError,
+  ManifestLoader,
+  DEFAULT_STANDARD_PAGE_ROUTES,
+  defaultSectionOrder,
+  buildRoutes,
+  buildSidebar,
+  resolveExtension,
+  MissingHandlerError,
+  ActionDefNotInManifestError,
+  ActionRegistry,
+  BatchColumnDriftError,
+  BatchColumnFetcher,
+  buildSnapshots,
+  listOpenDrafts
+};