@revenexx/studio-shared 0.3.3 → 0.4.1

package/dist/runtime/lib/formLayoutContext.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What `FormLayout` shares with the parts inside it (PE-976).
+ *
+ * `FormSection` registers itself so the navigation is built from the sections
+ * actually on the page — their ids and titles, in document order — instead of a
+ * second list the page has to keep in step. `SaveBar` reads the grid tracks so
+ * its buttons line up under the form column rather than under the nav.
+ *
+ * Kept out of `components/` so the module's component scan never mistakes it
+ * for a component.
+ */
+import type { ComputedRef, InjectionKey } from 'vue';
+export interface FormSectionEntry {
+    id: string;
+    title: string;
+    el: () => HTMLElement | null;
+}
+export interface FormLayoutContext {
+    register: (entry: FormSectionEntry) => void;
+    unregister: (id: string) => void;
+    /** Grid classes of the layout row, reused by the save bar. */
+    gridClass: ComputedRef<string>;
+    navVisible: ComputedRef<boolean>;
+    contextVisible: ComputedRef<boolean>;
+}
+export declare const FORM_LAYOUT_KEY: InjectionKey<FormLayoutContext>;

package/dist/runtime/lib/formLayoutContext.js

@@ -0,0 +1 @@
+export const FORM_LAYOUT_KEY = Symbol("studio-shared.form-layout");

package/dist/runtime/lib/gridTracks.d.ts

@@ -26,6 +26,19 @@
  * more. Below this a column stops being a column and becomes a smear.
  */
 export declare const FLEX_TRACK_FLOOR = "120px";
+/**
+ * A flexible column's floor that keeps its one-line heading inside the track.
+ *
+ * A heading stays on one line up to a length (`whitespace-nowrap`); squeezed
+ * to the 120px floor, „Was es bedeutet“ with its (?) and sort arrow ran into
+ * „Aktiv“ beside it (e2e 18.10.). An estimate, not a measurement: about 7.5px
+ * per character at the header's text size, plus room for the icons beside it.
+ * `undefined` when the plain floor is enough.
+ */
+export declare function headerFloor(label: string | undefined | null, opts?: {
+    icons?: number;
+    maxChars?: number;
+}): string | undefined;
 /**
  * One column's declared width, resolved to a track with a floor under it.
  *
@@ -52,4 +65,4 @@ export declare function trackFor(width: string | undefined | null, floor?: strin
  * where the manifest put it. On a list without one it is the trailing data
  * column that grows, which is where the eye is least likely to miss the space.
  */
-export declare function gridTemplateColumns(widths: Array<string | undefined | null>, floor?: string): string;
+export declare function gridTemplateColumns(widths: Array<string | undefined | null>, floor?: string, floors?: Array<string | undefined>): string;

package/dist/runtime/lib/gridTracks.js

@@ -1,4 +1,10 @@
 export const FLEX_TRACK_FLOOR = "120px";
+export function headerFloor(label, opts = {}) {
+  const text = (label ?? "").trim();
+  if (!text || opts.maxChars != null && text.length > opts.maxChars) return void 0;
+  const px = Math.ceil(text.length * 7.5) + (opts.icons ?? 0) * 18;
+  return px > Number.parseFloat(FLEX_TRACK_FLOOR) ? `${px}px` : void 0;
+}
 const MINMAX_FR = /^minmax\(\s*[^,]+,\s*([\d.]+fr)\s*\)$/i;
 const BARE_FR = /^([\d.]+)fr$/i;
 export function trackFor(width, floor = FLEX_TRACK_FLOOR) {
@@ -18,8 +24,13 @@ function absorbing(track) {
   const parts = MINMAX.exec(track);
   return `minmax(${parts ? parts[2] : track},1fr)`;
 }
-export function gridTemplateColumns(widths, floor) {
-  const tracks = widths.map((w) => trackFor(w, floor));
+export function gridTemplateColumns(widths, floor, floors) {
+  const tracks = widths.map((w, i) => {
+    const own = floors?.[i];
+    const track = trackFor(w, own ?? floor);
+    if (own && /^\d+(\.\d+)?px$/.test(track) && Number.parseFloat(track) < Number.parseFloat(own)) return own;
+    return track;
+  });
   if (tracks.length === 0) return "";
   if (!tracks.some(isFlexible)) {
     const last = tracks.length - 1;

package/dist/runtime/lib/isoLists.d.ts

@@ -1,6 +1,6 @@
 /**
- * The two international lists every studio ends up needing: countries
- * (ISO 3166-1 alpha-2) and currencies (ISO 4217).
+ * The international lists every studio ends up needing: countries
+ * (ISO 3166-1 alpha-2), currencies (ISO 4217) and languages (ISO 639-1).
  *
  * They live in `studio-shared` rather than in a studio because a country is
  * not a Commerce concern — Mail wants a sender country, Analytics wants a
@@ -59,3 +59,38 @@ export declare function currencyOptions(locale?: string): IsoOption[];
 export declare function countryLabel(code: unknown, locale?: string): string;
 /** `'EUR'` → `'Euro'`. Unknown codes come back unchanged. */
 export declare function currencyLabel(code: unknown, locale?: string): string;
+/** ISO 639-1, unsorted. Use `languageOptions()` to display them. */
+export declare function languageCodes(): readonly string[];
+/** Every language, sorted by its name in `locale` — „Deutsch“, „Englisch“ … */
+export declare function languageOptions(locale?: string): IsoOption[];
+/** `'de'` → `'Deutsch'`, `'de-AT'` → `'Deutsch (Österreich)'`. Unknown codes come back unchanged. */
+export declare function languageLabel(code: unknown, locale?: string): string;
+/**
+ * The circle flag a currency is drawn with (Michael 18.10.: icons in the
+ * currency picker, the same round look as the countries). The vendored flag
+ * set has no currency symbols, so a currency borrows its issuer's flag: the
+ * euro the EU's, every national currency its country's — ISO 4217 codes start
+ * with the issuing country (`CHF` → CH, `GBP` → GB). Supranational and special
+ * codes (`X…`: CFA franc, gold, SDR) have no single issuer and get the neutral
+ * disc. Returns the lowercase slug `CircleFlag` takes.
+ */
+export declare function currencyFlag(code: unknown): string;
+/** `'da'` → `'DK'`; null for a language with no single home country. */
+export declare function likelyCountry(language: unknown): string | null;
+/**
+ * The circle flag a language or locale is drawn with, as the lowercase slug
+ * `CircleFlag` takes: the chosen region when there is one (`de-AT` → `at`),
+ * otherwise the language's likely country (`de` → `de`, `en` → `gb`), and
+ * `''` when neither exists — the caller then shows its neutral globe.
+ */
+export declare function localeFlag(code: unknown): string;
+/**
+ * A locale code split into the two choices a picker offers — language and an
+ * optional region — and put back together (`de` + `AT` → `de-AT`). Null when
+ * the runtime cannot canonicalise it, which is how a nonsense tag is refused.
+ */
+export declare function composeLocale(language: string | null | undefined, region?: string | null): string | null;
+export declare function splitLocale(code: unknown): {
+    language: string | null;
+    region: string | null;
+};

package/dist/runtime/lib/isoLists.js

@@ -1,6 +1,9 @@
 const COUNTRY_CODES = Object.freeze(
   "AD AE AF AG AI AL AM AO AQ AR AS AT AU AW AX AZ BA BB BD BE BF BG BH BI BJ BL BM BN BO BQ BR BS BT BV BW BY BZ CA CC CD CF CG CH CI CK CL CM CN CO CR CU CV CW CX CY CZ DE DJ DK DM DO DZ EC EE EG EH ER ES ET FI FJ FK FM FO FR GA GB GD GE GF GG GH GI GL GM GN GP GQ GR GS GT GU GW GY HK HM HN HR HT HU ID IE IL IM IN IO IQ IR IS IT JE JM JO JP KE KG KH KI KM KN KP KR KW KY KZ LA LB LC LI LK LR LS LT LU LV LY MA MC MD ME MF MG MH MK ML MM MN MO MP MQ MR MS MT MU MV MW MX MY MZ NA NC NE NF NG NI NL NO NP NR NU NZ OM PA PE PF PG PH PK PL PM PN PR PS PT PW PY QA RE RO RS RU RW SA SB SC SD SE SG SH SI SJ SK SL SM SN SO SR SS ST SV SX SY SZ TC TD TF TG TH TJ TK TL TM TN TO TR TT TV TW TZ UA UG UM US UY UZ VA VC VE VG VI VN VU WF WS YE YT ZA ZM ZW".split(" ")
 );
+const LANGUAGE_CODES = Object.freeze(
+  "aa ab ae af ak am an ar as av ay az ba be bg bi bm bn bo br bs ca ce ch co cr cs cu cv cy da de dv dz ee el en eo es et eu fa ff fi fj fo fr fy ga gd gl gn gu gv ha he hi ho hr ht hu hy hz ia id ie ig ii ik io is it iu ja jv ka kg ki kj kk kl km kn ko kr ks ku kv kw ky la lb lg li ln lo lt lu lv mg mh mi mk ml mn mr ms mt my na nb nd ne ng nl nn no nr nv ny oc oj om or os pa pi pl ps pt qu rm rn ro ru rw sa sc sd se sg si sk sl sm sn so sq sr ss st su sv sw ta te tg th ti tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo wa wo xh yi yo za zh zu".split(" ")
+);
 export const DEFAULT_ISO_LOCALE = "de";
 export function countryCodes() {
   return COUNTRY_CODES;
@@ -31,7 +34,10 @@ function collator(locale) {
 function build(codes, type, locale) {
   const names = displayNames(type, locale);
   const compare = collator(locale).compare;
-  return codes.map((code) => ({ code, label: names?.of(code) || code })).sort((a, b) => compare(a.label, b.label));
+  return codes.map((code) => {
+    const name = names?.of(code);
+    return { code, label: name || code, named: !!name && name.toLowerCase() !== code.toLowerCase() };
+  }).sort((a, b) => Number(b.named) - Number(a.named) || compare(a.label, b.label)).map(({ code, label }) => ({ code, label }));
 }
 const cache = /* @__PURE__ */ new Map();
 function cached(key, make) {
@@ -60,3 +66,50 @@ export function currencyLabel(code, locale = DEFAULT_ISO_LOCALE) {
   if (!key) return "";
   return displayNames("currency", locale)?.of(key) || key;
 }
+export function languageCodes() {
+  return LANGUAGE_CODES;
+}
+export function languageOptions(locale = DEFAULT_ISO_LOCALE) {
+  return cached(`language:${locale}`, () => build(LANGUAGE_CODES, "language", locale));
+}
+export function languageLabel(code, locale = DEFAULT_ISO_LOCALE) {
+  const key = typeof code === "string" ? code.trim().replace("_", "-") : "";
+  if (!key) return "";
+  return displayNames("language", locale)?.of(key) || key;
+}
+export function currencyFlag(code) {
+  const key = typeof code === "string" ? code.trim().toUpperCase() : "";
+  if (key === "EUR") return "eu";
+  if (!/^[A-Z]{3}$/.test(key) || key.startsWith("X")) return "xx";
+  const issuer = key.slice(0, 2);
+  return COUNTRY_CODES.includes(issuer) ? issuer.toLowerCase() : "xx";
+}
+const LIKELY_COUNTRY = Object.freeze(Object.fromEntries(
+  "aa:ET ab:GE af:ZA ak:GH am:ET an:ES ar:EG as:IN av:RU ay:BO az:AZ ba:RU be:BY bg:BG bi:VU bm:ML bn:BD bo:CN br:FR bs:BA ca:ES ce:RU ch:GU co:FR cr:CA cs:CZ cv:RU cy:GB da:DK de:DE dv:MV dz:BT ee:GH el:GR en:GB es:ES et:EE eu:ES fa:IR ff:SN fi:FI fj:FJ fo:FO fr:FR fy:NL ga:IE gd:GB gl:ES gn:PY gu:IN gv:IM ha:NG he:IL hi:IN ho:PG hr:HR ht:HT hu:HU hy:AM hz:NA id:ID ig:NG ii:CN ik:US is:IS it:IT iu:CA ja:JP jv:ID ka:GE kg:CD ki:KE kj:NA kk:KZ kl:GL km:KH kn:IN ko:KR kr:NG ks:IN ku:TR kv:RU kw:GB ky:KG lb:LU lg:UG li:NL ln:CD lo:LA lt:LT lu:CD lv:LV mg:MG mh:MH mi:NZ mk:MK ml:IN mn:MN mr:IN ms:MY mt:MT my:MM na:NR nb:NO nd:ZW ne:NP ng:NA nl:NL nn:NO no:NO nr:ZA nv:US ny:MW oc:FR oj:CA om:ET or:IN os:GE pa:IN pl:PL ps:AF pt:PT qu:PE rm:CH rn:BI ro:RO ru:RU rw:RW sa:IN sc:IT sd:PK se:NO sg:CF si:LK sk:SK sl:SI sm:WS sn:ZW so:SO sq:AL sr:RS ss:ZA st:ZA su:ID sv:SE sw:TZ ta:IN te:IN tg:TJ th:TH ti:ET tk:TM tl:PH tn:ZA to:TO tr:TR ts:ZA tt:RU tw:GH ty:PF ug:CN uk:UA ur:PK uz:UZ ve:ZA vi:VN wa:BE wo:SN xh:ZA yo:NG za:CN zh:CN zu:ZA".split(" ").map((pair) => pair.split(":"))
+));
+export function likelyCountry(language) {
+  const key = typeof language === "string" ? language.trim().toLowerCase() : "";
+  return LIKELY_COUNTRY[key] ?? null;
+}
+export function localeFlag(code) {
+  const { language, region } = splitLocale(code);
+  if (region) return region.toLowerCase();
+  return likelyCountry(language)?.toLowerCase() ?? "";
+}
+export function composeLocale(language, region) {
+  const lang = (language ?? "").trim().toLowerCase();
+  if (!/^[a-z]{2,3}$/.test(lang)) return null;
+  const reg = (region ?? "").trim().toUpperCase();
+  const tag = reg ? `${lang}-${reg}` : lang;
+  try {
+    return Intl.getCanonicalLocales(tag)[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+export function splitLocale(code) {
+  const raw = typeof code === "string" ? code.trim().replace("_", "-") : "";
+  if (!raw) return { language: null, region: null };
+  const [language, region] = raw.split("-");
+  return { language: language?.toLowerCase() || null, region: region && /^[A-Za-z]{2}$/.test(region) ? region.toUpperCase() : null };
+}

package/dist/runtime/lib/notice.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Headline + subtitle out of one paragraph (EmptyNote, Michael 19.10.).
+ *
+ * Copy written as a single paragraph — a placeholder tab, an empty-state
+ * sentence — still has to read as a headline with an explanation under it.
+ * The first sentence heads, the rest explains. An abbreviation ("z. B.",
+ * "bzw.", "Nr.") does not end a sentence, so a short or dotted word before
+ * the period never splits.
+ */
+export interface NoticeParts {
+    title: string;
+    description: string | null;
+}
+export declare function splitNotice(text: string | null | undefined): NoticeParts;

package/dist/runtime/lib/notice.js

@@ -0,0 +1,19 @@
+const ABBREVIATIONS = /* @__PURE__ */ new Set(["bzw", "usw", "ggf", "inkl", "zzgl", "evtl", "etc", "vgl", "ca", "nr", "max", "min", "abs", "gem", "sog", "e.g", "i.e", "vs"]);
+export function splitNotice(text) {
+  const source = (text ?? "").trim();
+  if (!source) return { title: "", description: null };
+  const pattern = /([.!?])\s+(?=[A-ZÄÖÜ„"(])/g;
+  let match;
+  while (match = pattern.exec(source)) {
+    const end = match.index;
+    if (match[1] === ".") {
+      const word = /([\p{L}.]+)$/u.exec(source.slice(0, end))?.[1] ?? "";
+      const bare = word.replace(/\.$/, "");
+      if (bare.length <= 2 || ABBREVIATIONS.has(bare.toLowerCase())) continue;
+    }
+    const title = source.slice(0, end + 1).trim();
+    const description = source.slice(pattern.lastIndex).trim();
+    return { title, description: description || null };
+  }
+  return { title: source, description: null };
+}

package/dist/runtime/lib/pageSize.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rows per page (PE-1052, Michael 15.10.): 50 by default, 25 / 50 / 100 / 200
+ * to choose from, remembered per user and table. The dummy keeps the choice in
+ * localStorage; the cockpit's `user_preferences` row is where it goes on
+ * transfer (same split as the density toggle).
+ */
+export declare const PAGE_SIZE_OPTIONS: readonly [25, 50, 100, 200];
+export declare const DEFAULT_PAGE_SIZE = 50;
+/** The storage key for one table's page size. */
+export declare function pageSizeStorageKey(table: string): string;
+/** The remembered size for a table, if it is one of the offered sizes. */
+export declare function readPageSize(table: string | null | undefined): number | null;
+export declare function writePageSize(table: string | null | undefined, size: number): void;
+/** The sizes the footer offers — the standard four, plus a surface's own if it set another. */
+export declare function pageSizeOptions(current: number): number[];

package/dist/runtime/lib/pageSize.js

@@ -0,0 +1,26 @@
+export const PAGE_SIZE_OPTIONS = [25, 50, 100, 200];
+export const DEFAULT_PAGE_SIZE = 50;
+export function pageSizeStorageKey(table) {
+  return `cockpit.datatable.pageSize:${table}`;
+}
+export function readPageSize(table) {
+  if (!table) return null;
+  try {
+    if (typeof window === "undefined") return null;
+    const n = Number(window.localStorage.getItem(pageSizeStorageKey(table)));
+    return PAGE_SIZE_OPTIONS.includes(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+export function writePageSize(table, size) {
+  if (!table) return;
+  try {
+    if (typeof window === "undefined") return;
+    window.localStorage.setItem(pageSizeStorageKey(table), String(size));
+  } catch {
+  }
+}
+export function pageSizeOptions(current) {
+  return [.../* @__PURE__ */ new Set([...PAGE_SIZE_OPTIONS, current])].sort((a, b) => a - b);
+}

package/dist/runtime/lib/rowMove.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Moving a row by dragging it, as arithmetic the table does not have to own.
+ *
+ * The DataTable only knows rows and keys. What a move MEANS — which position
+ * column is written, which rows have to change — is the surface's business, so
+ * the table answers one question and stops: "the operator put row X here; what
+ * is the order now?". Kept apart from the component so the edge cases are a
+ * test rather than something found by dragging.
+ */
+/** Which half of the row under the pointer the dragged row is dropped on. */
+export type DropEdge = 'before' | 'after';
+/**
+ * The edge of a row a pointer is nearest to.
+ *
+ * The middle of the row, not an arithmetic row height: a row whose label wraps
+ * is taller than its neighbours, and an index derived from "pointer offset ÷ 40
+ * pixels" puts the row one slot off on every list that has a long value in it.
+ */
+export declare function dropEdge(pointerY: number, rowTop: number, rowHeight: number): DropEdge;
+/**
+ * Where a row dragged from `from` lands when dropped on the `edge` of the row
+ * at `target`, as an index into the list WITHOUT the dragged row taken out.
+ *
+ * Returns null when the drop changes nothing — onto itself, or onto the edge
+ * it already touches (the bottom of the row above, the top of the row below).
+ * A move that changes nothing must not write anything, and it is easy to send
+ * two position updates for a row the operator merely picked up and put back.
+ */
+export declare function dropTargetIndex(from: number, target: number, edge: DropEdge): number | null;
+/** The keys in their new order, `from` moved to `to`. */
+export declare function moveKey<K>(keys: readonly K[], from: number, to: number): K[];
+/**
+ * The keyboard half of the same move: one step up or down, or null at an end.
+ *
+ * Dragging is a pointer gesture and cannot be the only way to reorder a list —
+ * the handle is a button, and the arrow keys on it move the row one place.
+ */
+export declare function stepTarget(from: number, delta: -1 | 1, length: number): number | null;

package/dist/runtime/lib/rowMove.js

@@ -0,0 +1,20 @@
+export function dropEdge(pointerY, rowTop, rowHeight) {
+  return pointerY < rowTop + rowHeight / 2 ? "before" : "after";
+}
+export function dropTargetIndex(from, target, edge) {
+  if (from < 0 || target < 0) return null;
+  const insertAt = edge === "before" ? target : target + 1;
+  const to = insertAt > from ? insertAt - 1 : insertAt;
+  return to === from ? null : to;
+}
+export function moveKey(keys, from, to) {
+  if (from < 0 || from >= keys.length || to < 0 || to >= keys.length || from === to) return [...keys];
+  const next = [...keys];
+  const [moved] = next.splice(from, 1);
+  next.splice(to, 0, moved);
+  return next;
+}
+export function stepTarget(from, delta, length) {
+  const to = from + delta;
+  return to < 0 || to >= length ? null : to;
+}

package/dist/runtime/lib/sidebarAreas.d.ts

@@ -0,0 +1,46 @@
+import type { SidebarNavSection } from '../types/nav.js';
+/**
+ * Area mode of the studio sidebar (Commerce Studio, click dummy variant C3).
+ *
+ * The section the route is in shows its rows as before. Every other section
+ * shrinks to a single "area" row; resting on it (or
+ * clicking it) lays a panel with that section's rows next to the sidebar.
+ * Nothing folds: which section is open follows the route, not a toggle.
+ */
+export type SidebarAreaBlock = {
+    kind: 'section';
+    section: SidebarNavSection;
+} | {
+    kind: 'area';
+    section: SidebarNavSection;
+};
+/** True when one of the section's rows (or their tabs) holds `path`. */
+export declare function sectionHoldsActive(section: SidebarNavSection, path: string, best?: number): boolean;
+/**
+ * A section whose one entry carries the section's own name (Konfiguration →
+ * Konfiguration) is that entry: a plain link row, never an area with a panel
+ * of one (Michael 17.10.).
+ */
+export declare function isSelfNamed(section: SidebarNavSection): boolean;
+/**
+ * Which sections render as rows and which as area rows. Only a section without
+ * a label (the pinned Dashboard row) and the route's own section show rows;
+ * a one-row section is an area too, so every section reads the same way
+ * (Michael 17.10.). With `best`, only the section of the closest match opens.
+ */
+export declare function sidebarAreaBlocks(sections: SidebarNavSection[], path: string, best?: number): SidebarAreaBlock[];
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Safe triangle: is `p` inside the triangle spanned by where the pointer last
+ * rested on the open area row (`apex`) and the panel's near edge (`top`,
+ * `bottom`)? Then the pointer is on its way into the panel and crossing other
+ * area rows must not switch the panel (Tog's Apple menus, Amazon's menu-aim).
+ */
+export declare function inSafeTriangle(p: Point, apex: Point, top: Point, bottom: Point): boolean;
+/** Timings, in ms. Opening waits for a rest; switching an open panel does not. */
+export declare const AREA_OPEN_DELAY = 150;
+export declare const AREA_AIM_DELAY = 180;
+export declare const AREA_CLOSE_DELAY = 300;

package/dist/runtime/lib/sidebarAreas.js

@@ -0,0 +1,25 @@
+import { sidebarItemHoldsActive, sidebarItemMatchLength } from "./sidebarNav.js";
+export function sectionHoldsActive(section, path, best) {
+  if (best === void 0) return section.items.some((item) => sidebarItemHoldsActive(item, path));
+  return best >= 0 && section.items.some((item) => sidebarItemMatchLength(item, path) === best);
+}
+export function isSelfNamed(section) {
+  return section.items.length === 1 && section.items[0].label === section.label;
+}
+export function sidebarAreaBlocks(sections, path, best) {
+  return sections.map(
+    (section) => !section.label || isSelfNamed(section) || sectionHoldsActive(section, path, best) ? { kind: "section", section } : { kind: "area", section }
+  );
+}
+export function inSafeTriangle(p, apex, top, bottom) {
+  const side = (a, b, c) => (a.x - c.x) * (b.y - c.y) - (b.x - c.x) * (a.y - c.y);
+  const d1 = side(p, apex, top);
+  const d2 = side(p, top, bottom);
+  const d3 = side(p, bottom, apex);
+  const neg = d1 < 0 || d2 < 0 || d3 < 0;
+  const pos = d1 > 0 || d2 > 0 || d3 > 0;
+  return !(neg && pos);
+}
+export const AREA_OPEN_DELAY = 150;
+export const AREA_AIM_DELAY = 180;
+export const AREA_CLOSE_DELAY = 300;

package/dist/runtime/lib/sidebarNav.d.ts

@@ -1,3 +1,4 @@
+import type { InjectionKey, Ref } from 'vue';
 import type { SidebarNavItem } from '../types/nav.js';
 /**
  * Pure helpers behind `SidebarNav` / `SidebarNavLink`. They live outside the
@@ -12,16 +13,34 @@ import type { SidebarNavItem } from '../types/nav.js';
  */
 /** Stable identity for `v-for` keys — `to` is unique where it exists. */
 export declare function sidebarItemKey(item: SidebarNavItem): string;
-/** True when `path` is the item's own route, or sits below it. */
+/**
+ * True when `path` is the item's own route, or sits below it. `path` may carry
+ * a query: an item whose `to` names one (`/configuration?tab=markets`) is the
+ * page with exactly those parameters (an empty value: the parameter is
+ * absent); every other item ignores the query.
+ */
 export declare function sidebarItemIsActive(item: SidebarNavItem, path: string): boolean;
 /** True when the item, or any of its tabs, matches `path`. */
 export declare function sidebarItemHoldsActive(item: SidebarNavItem, path: string): boolean;
+/**
+ * How closely the item (or one of its tabs) matches `path`: the length of the
+ * longest matching route, -1 when none does. Two rows can both hold a path —
+ * Konfiguration's Zahlung owns `/payments/providers`, Auftragsabwicklung's
+ * Zahlungen owns `/payments` — and only the closer one is where you are.
+ */
+export declare function sidebarItemMatchLength(item: SidebarNavItem, path: string): number;
+/** The closest match any row of the sidebar has for `path` (-1: none). */
+export declare function sidebarBestMatch(sections: ReadonlyArray<{
+    items: SidebarNavItem[];
+}>, path: string): number;
+/** Injected by `SidebarNav`: the closest match of the whole sidebar for the route. */
+export declare const SIDEBAR_BEST_MATCH: InjectionKey<Ref<number>>;
 /**
  * Which row gets the highlight. The tabs of a group are not rows of their own,
  * so the group stays lit for every one of them — an operator on *Carriers*
  * still sees where they are, which is **Shipping**.
  */
-export declare function sidebarItemIsCurrent(item: SidebarNavItem, path: string): boolean;
+export declare function sidebarItemIsCurrent(item: SidebarNavItem, path: string, best?: number): boolean;
 /**
  * Where the row links. A group with a route of its own opens that (it is the
  * default tab); a pure container — a heading several apps contribute to, where

package/dist/runtime/lib/sidebarNav.js

@@ -3,14 +3,33 @@ export function sidebarItemKey(item) {
 }
 export function sidebarItemIsActive(item, path) {
   if (!item.to) return false;
-  if (item.exact) return path === item.to;
-  return path === item.to || path.startsWith(`${item.to}/`);
+  const [bare, query = ""] = path.split("?");
+  const [to, wanted] = item.to.split("?");
+  if (wanted !== void 0) {
+    const have = new URLSearchParams(query);
+    return bare === to && [...new URLSearchParams(wanted)].every(([k, v]) => (have.get(k) ?? "") === v);
+  }
+  if (item.exact) return bare === to;
+  return bare === to || bare.startsWith(`${to}/`);
 }
 export function sidebarItemHoldsActive(item, path) {
   return sidebarItemIsActive(item, path) || (item.children ?? []).some((child) => sidebarItemHoldsActive(child, path));
 }
-export function sidebarItemIsCurrent(item, path) {
-  return sidebarItemHoldsActive(item, path);
+export function sidebarItemMatchLength(item, path) {
+  const own = sidebarItemIsActive(item, path) ? item.to.length + 0.5 : -1;
+  return Math.max(own, ...(item.children ?? []).map((child) => tabMatchLength(child, path)));
+}
+function tabMatchLength(item, path) {
+  const own = sidebarItemIsActive(item, path) ? item.to.length : -1;
+  return Math.max(own, ...(item.children ?? []).map((child) => tabMatchLength(child, path)));
+}
+export function sidebarBestMatch(sections, path) {
+  return Math.max(-1, ...sections.flatMap((section) => section.items.map((item) => sidebarItemMatchLength(item, path))));
+}
+export const SIDEBAR_BEST_MATCH = Symbol("sidebar-best-match");
+export function sidebarItemIsCurrent(item, path, best) {
+  if (best === void 0) return sidebarItemHoldsActive(item, path);
+  return best >= 0 && sidebarItemMatchLength(item, path) === best;
 }
 export function sidebarItemTarget(item) {
   if (item.to) return item.to;

package/dist/runtime/lib/solarIconMap.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GENERATED by `node scripts/icons.mjs`. Do not edit by hand.
+ *
+ * The closed set of Solar icons the cockpit resolves by name: every icon the
+ * app manifests, this repo's code and the curated picker set ask for. Named
+ * imports, so the bundle carries these 150 instead of all 1,413
+ * (PE-985). A name outside the set renders the fallback glyph; run
+ * `pnpm icons` after adding one, and `pnpm icons:check` to verify.
+ */
+import type { Component } from 'vue';
+import { Record } from '#solar-icons';
+export declare const SOLAR_ICON_MAP: Readonly<Record<string, Component>>;
+/** Manifest names Solar does not have → the glyph drawn for them. */
+export declare const SOLAR_ICON_ALIASES: Readonly<Record<string, string>>;
+/** Drawn for a name outside the map. */
+export declare const SOLAR_FALLBACK_ICON: Component;