mirror of
https://github.com/caiwx86/small-packages.git
synced 2026-11-16 13:12:56 +08:00
update 2026-09-23 23:57:29
This commit is contained in:
1 parent
77395e0373
commit
e22304fb46
172 files changed
+367
-44976
No files matched your search
@@ -1,25 +0,0 @@
|
||||
/*!
|
||||
* luci-theme-footstrap
|
||||
* Copyright 2026 footstrap contributors
|
||||
* Licensed under the Apache License v2.0
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Portions of styles/base are derived from luci-theme-bootstrap, whose notices
|
||||
* the Apache License requires this file to carry for as long as that code ships:
|
||||
* Copyright 2012 Nut & Bolt <david@nut-bolt.nl>
|
||||
* Copyright 2011 Twitter, Inc
|
||||
*/
|
||||
|
||||
/* Layer order, declared here and nowhere else. A later layer beats an earlier one regardless of
|
||||
* specificity, so a theme rule never needs !important to outrank base; one that needs it to beat
|
||||
* another footstrap rule belongs in a later layer. Unlayered rules beat every layer, and that slot
|
||||
* is deliberately empty.
|
||||
*
|
||||
* tokens design tokens + the outbound bridge to LuCI's --*-color-* names styles/0*
|
||||
* base widget defaults every LuCI view assumes exist styles/base/*
|
||||
* theme footstrap components and layouts styles/theme/*
|
||||
* page per-page corrections styles/pages/*
|
||||
*
|
||||
* build-css.sh concatenates those four directories into cascade.css, which is generated and
|
||||
* gitignored — never edit it. */
|
||||
@layer tokens, base, theme, page;
|
||||
@@ -1,569 +0,0 @@
|
||||
@layer tokens {
|
||||
/* Design tokens, in two tiers, and the split is load-bearing:
|
||||
*
|
||||
* PRIVATE --fs-* every rule in this theme reads only these
|
||||
* EXPORT --*-color-* LuCI's conventional names, defined FROM the private tier and read
|
||||
* by nobody here — they exist so a third-party luci-app-* keeps
|
||||
* working and keeps following the palette and dark mode
|
||||
*
|
||||
* :root is a shared scope and every luci-app-* drops CSS into the same document, unlayered,
|
||||
* which outranks every cascade layer. An app declaring --accent or the conventional
|
||||
* --text-color-high, which base itself once read 158 times, repaints the theme: 312 of 336
|
||||
* gallery elements with a hostile :root before the split, 0 after. The bridge is outward-only,
|
||||
* and tools/audit.py fails on any read of an export name inside styles/.
|
||||
*
|
||||
* docs/design-system.md. Light = :root; dark = :root[data-darkmode="true"]. */
|
||||
:root {
|
||||
/* Palette colours are in 03-palettes.css, one swappable block per colourway x mode;
|
||||
* everything here is palette-independent or var()-derived. The inks (--fs-on-accent and
|
||||
* friends) live in those blocks too, beside the fills they must be legible against: a
|
||||
* dark palette has light fills and needs a dark ink, and one global `#fff` failed WCAG AA
|
||||
* on seven of the eight dark-palette fills (down to 1.69:1). */
|
||||
/* pop surfaces (menus, dropdown lists, the select picker): one value rather than a
|
||||
* literal per site */
|
||||
--fs-shadow-pop: 0 12px 34px rgba(0,0,0,.30);
|
||||
/* ---- two focus rings, and which one a control takes is the contract ----
|
||||
* -soft is a TINT (10-15% of the accent), measuring 1.15-1.29:1 on the surface it lands
|
||||
* on: a glow, not an indicator, where WCAG 1.4.11 wants 3:1. It is legitimate only beside
|
||||
* a second channel — every field taking it also flips border-color to --fs-accent, which
|
||||
* measures 4.57-7.04:1 across palette x mode x surface, so the border is the indicator and
|
||||
* the tint is the halo.
|
||||
*
|
||||
* -solo is for a control where the ring is the WHOLE indicator and nothing else changes on
|
||||
* focus: the sidebar menu links and chrome icon buttons, the section tabs, both range
|
||||
* sliders. Its 2px of surface is what lets it read against a FILLED control, where an
|
||||
* accent ring would otherwise sit on an accent box; solid accent then measures 5.19-7.04
|
||||
* on panel and 4.61-7.55 on the canvas.
|
||||
*
|
||||
* The invalid twin takes -fill (18%), not -soft: a red ring must read as an alarm rather
|
||||
* than a hover tint, and it is paired with a red border. */
|
||||
--fs-focus-ring: 0 0 0 3px var(--fs-accent-soft);
|
||||
--fs-focus-ring-solo: 0 0 0 2px var(--fs-panel), 0 0 0 5px var(--fs-accent);
|
||||
--fs-focus-ring-invalid: 0 0 0 3px var(--fs-danger-fill);
|
||||
/* The chosen-row rail: a chosen row says so with an opaque surface and an inset bar, never
|
||||
* with a tint of the accent under accent text (4.21:1 in dark — theme/65-dropdown.css).
|
||||
* Named because it is written in three places that cannot be one rule: the open dropdown's
|
||||
* row, a native `select option:checked`, and the ring the focused row wears on top. The
|
||||
* first two are pinned to each other by tools/mirror.mjs. */
|
||||
--fs-row-rail: inset 2px 0 0 var(--fs-accent);
|
||||
|
||||
/* The hairline: every separator in this theme is the same one-pixel line in the same
|
||||
* border colour, so it is stated once rather than in 69 longhand declarations that would
|
||||
* each have to change for a 2px high-contrast line or a softer colour. The shorthand is
|
||||
* the token, so `border`, `border-top` and friends all take it. */
|
||||
--fs-hairline: 1px solid var(--fs-border);
|
||||
/* a field reacting to focus: the ring arrives and the edge changes colour together, and a
|
||||
* transition list that drifts apart shows the border moving before the ring */
|
||||
--fs-field-transition: border-color var(--fs-dur), box-shadow var(--fs-dur);
|
||||
|
||||
/* the theme's one colour literal, deliberately: black at .7 is the absence of light behind
|
||||
* a dialog, not a tint of any token — a palette-tinted scrim over a dark page dims
|
||||
* nothing. A token, so the rules stay literal-free. */
|
||||
--fs-scrim: rgba(0, 0, 0, .7);
|
||||
|
||||
/* ---- role tint ladder (derived) ----
|
||||
* A tint OF a role, mixed FROM it, so it follows the palette with nothing hand-maintained.
|
||||
* Unnamed, these levels drift: the same outline border was 40% in a table and 45% in the
|
||||
* action bar, the same hover fill 12% in one file and 18% in another.
|
||||
*
|
||||
* -soft 12% a quiet FILL — outline-button :hover
|
||||
* -fill 18% a stronger FILL — callout/diff surface, the invalid ring
|
||||
* -line 40% a HAIRLINE — outline-button border, diff border
|
||||
* -line-hi 55% that hairline on :hover
|
||||
*
|
||||
* The role x step matrix is complete on purpose, read or not: a gap is how the drift
|
||||
* starts, since a rule wanting a level that does not exist invents a percentage.
|
||||
* --fs-accent-soft is the one member not here — its strength differs per MODE (10% light,
|
||||
* 15% dark; hicontrast dark 14%). LIGHT is identical across every palette and lives as one
|
||||
* declaration in 03-palettes.css's shared :root instead; DARK still varies by palette (one
|
||||
* differs by a digit) and stays declared per palette block. */
|
||||
--fs-good-soft: color-mix(in srgb, var(--fs-good) 12%, transparent);
|
||||
--fs-warn-soft: color-mix(in srgb, var(--fs-warn) 12%, transparent);
|
||||
--fs-danger-soft: color-mix(in srgb, var(--fs-danger) 12%, transparent);
|
||||
|
||||
--fs-accent-fill: color-mix(in srgb, var(--fs-accent) 18%, transparent);
|
||||
--fs-good-fill: color-mix(in srgb, var(--fs-good) 18%, transparent);
|
||||
--fs-warn-fill: color-mix(in srgb, var(--fs-warn) 18%, transparent);
|
||||
--fs-danger-fill: color-mix(in srgb, var(--fs-danger) 18%, transparent);
|
||||
|
||||
--fs-accent-line: color-mix(in srgb, var(--fs-accent) 40%, transparent);
|
||||
--fs-good-line: color-mix(in srgb, var(--fs-good) 40%, transparent);
|
||||
--fs-warn-line: color-mix(in srgb, var(--fs-warn) 40%, transparent);
|
||||
--fs-danger-line: color-mix(in srgb, var(--fs-danger) 40%, transparent);
|
||||
|
||||
--fs-accent-line-hi: color-mix(in srgb, var(--fs-accent) 55%, transparent);
|
||||
--fs-good-line-hi: color-mix(in srgb, var(--fs-good) 55%, transparent);
|
||||
--fs-warn-line-hi: color-mix(in srgb, var(--fs-warn) 55%, transparent);
|
||||
--fs-danger-line-hi: color-mix(in srgb, var(--fs-danger) 55%, transparent);
|
||||
/* The warn row has no reader today and is kept on purpose: LuCI emits no warning BUTTON,
|
||||
* so only -fill is consumed. The row is what makes the next component reach for a token
|
||||
* instead of mixing its own percentage. A grep finding no `var(--fs-warn-line)` is
|
||||
* expected. */
|
||||
|
||||
/* The circular-arrows refresh glyph, as a mask so its colour follows the palette
|
||||
* (--fs-good active, --fs-dim paused). One copy: the poll pill collapses to it both in the
|
||||
* rail and in the bar's compact cluster. A static glyph on purpose — a spinner makes an
|
||||
* idle poll look busy and moves the click target that pauses it.
|
||||
*
|
||||
* OURS, and redrawn to keep it so. It was derived from Lucide's `refresh-cw` (ISC) —
|
||||
* `M21 3v5h-5` was byte-identical — which is a second outside licence obligation this theme
|
||||
* never declared. Redrawn as two OPEN arcs with solid triangular heads: a different
|
||||
* construction, not a nudge of the same one (Lucide caps a continuous stroke with an
|
||||
* L-shaped hook). Solid heads rather than chevrons because chevrons dissolve at the 18px
|
||||
* this renders at. */
|
||||
--fs-icon-refresh: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23000' stroke-width='2' stroke-linecap='round'%3E%3Cpath d='M4.4 9.6A8.5 8.5 0 0 1 18.6 7.6'/%3E%3Cpath d='M19.6 14.4A8.5 8.5 0 0 1 5.4 16.4'/%3E%3Cpath fill='%23000' stroke='none' d='M21.6 10.6 15.4 8.4 20.4 4.2Z'/%3E%3Cpath fill='%23000' stroke='none' d='M2.4 13.4 8.6 15.6 3.6 19.8Z'/%3E%3C/svg%3E");
|
||||
/* …and the size it is drawn at, which css-dup cannot police for a glyph inlined once and
|
||||
* sized at two call sites. The two sites legitimately differ in technique — the rail masks
|
||||
* the element and drops the border, the bar keeps the bordered square — but not in size. */
|
||||
--fs-icon-refresh-sz: calc(18px * var(--fs-density-type));
|
||||
|
||||
/* Hover cue for a solid control — the one cue that cannot be a colour, the fill it shifts
|
||||
* being whatever the role token says. Per mode, and the DIRECTION FLIPS: `filter`
|
||||
* recolours the text too, and a light-mode solid button is a saturated fill with white
|
||||
* ink, which cannot get brighter — brightening drops white on --fs-accent from 5.19:1 to
|
||||
* 4.59:1 at 1.08 and to 4.08:1 at a visible 1.15, an AA failure caused by hovering. So
|
||||
* light darkens (.90 lands at 4.94:1, still clear of the 4.5 floor) and dark, whose fill
|
||||
* is light and ink dark, brightens (1.15). */
|
||||
--fs-hover-lift: brightness(.90);
|
||||
|
||||
/* ---- motion: four durations, because the UI does four things ----
|
||||
* There is deliberately no easing token: every transition and animation omits the timing
|
||||
* function and takes the CSS default (ease), which is one curve, nothing to keep in sync
|
||||
* and fewer bytes than naming it. A rule needing another curve is making a design decision
|
||||
* and must justify it in a comment.
|
||||
*
|
||||
* The scale governs `animation` too, not only `transition`: one gesture ridden at three
|
||||
* durations is drift css-dup cannot see, the declaration bodies differing.
|
||||
* 95-a11y-media.css kills all of this under prefers-reduced-motion. */
|
||||
--fs-dur: .15s; /* a state change: colour, border, shadow, background, filter */
|
||||
--fs-dur-move: .2s; /* something that moves or unfolds: transform, max-height */
|
||||
--fs-dur-fade: .25s; /* a transient thing fading in or out: spinner, notification */
|
||||
--fs-dur-fill: .4s; /* a progress bar growing to its value */
|
||||
--fs-content-max: 1280px; /* content column cap */
|
||||
/* content column side padding, read by .fs-content, the top bar's centering calc and the
|
||||
* notification width calc, so the three cannot drift */
|
||||
--fs-content-pad: calc(28px * var(--fs-density-space));
|
||||
/* The shell's geometry: tokens, not literals, because the JS reads them back — the CSS
|
||||
* lays the sidebar out and fs-chrome.js's fitShell() subtracts that cut from the viewport
|
||||
* to decide whether what is left is readable. With copies in JS, narrowing the rail here
|
||||
* leaves the measurement subtracting the old width. */
|
||||
--fs-sidebar-w: calc(224px * var(--fs-density-box)); /* the expanded vertical sidebar's column */
|
||||
--fs-rail-w: calc(68px * var(--fs-density-box)); /* ...and the same sidebar collapsed to its icon rail */
|
||||
--fs-content-min: 500px; /* below this a content column stops being readable */
|
||||
/* the bar's surface: the top-nav bar and the sidebar's phone bar are one component in two
|
||||
* markups, so one token keeps the two identical. OPAQUE on purpose. It was 88% of the panel
|
||||
* under a 12px backdrop blur, and the pair was measured on the page most favourable to it —
|
||||
* a pattern wallpaper at full strength, the bar sitting over scrolled content: dropping the
|
||||
* blur moved 0.04% of the pixels, and what the translucency actually bought was the page
|
||||
* showing through the chrome, which reads as a glitch rather than as glass. */
|
||||
--fs-bar-bg: var(--fs-panel);
|
||||
/* height of that bar, and the scroll-margin every anchor target needs to clear it
|
||||
* (base/10-reset.css): if the two drift, an in-page jump lands under the bar */
|
||||
/* The chrome's own controls — the square buttons (search, appearance, log out) and the poll
|
||||
* pill — ride the bar rather than cutting panel-coloured holes in it: the bar is one surface,
|
||||
* and a control on it is carried by its hairline, not by a second fill. `transparent`, so the
|
||||
* control shows the bar itself rather than a second surface stacked on it.
|
||||
*
|
||||
* The backdrop a control lands on is therefore --fs-bar-bg, which is --fs-panel: the same
|
||||
* construction `.label`'s comment in theme/35-alerts.css leans on, so a coloured variant keeps
|
||||
* its >=4.5:1 by the palette's guarantee rather than by measurement. A palette that wants the
|
||||
* old panel2 hole sets this back to var(--fs-panel2). */
|
||||
--fs-bar-ctl-bg: transparent;
|
||||
/* The select's chevron, drawn rather than fetched. It used to be an inline SVG data-URI, and
|
||||
* a URI cannot read var() — the stroke colour had to be written INTO the string, so the
|
||||
* declaration was repeated once per palette and once per mode: ten copies of one glyph, ~2.4 KB
|
||||
* of the shipped sheet, and ten chances for a palette to be recoloured while its chevron was
|
||||
* not. Two gradient bands cost one declaration and take their colour from the palette's own
|
||||
* --fs-dim at paint time, so a new palette gets a correct chevron for free. The 45% / 55% stops
|
||||
* are the band's thickness; the two layers are positioned by the rules that use this, since
|
||||
* only they know the field's inset. What is given up is the round line cap the SVG had, which
|
||||
* at 12px is not visible — compared side by side before the swap. */
|
||||
--fs-select-chevron:
|
||||
linear-gradient(-45deg, transparent 45%, var(--fs-dim) 45% 55%, transparent 55%),
|
||||
linear-gradient(45deg, transparent 45%, var(--fs-dim) 45% 55%, transparent 55%);
|
||||
--fs-bar-h: calc(46px * var(--fs-density-box));
|
||||
/* the square icon button in the bar and rail: the logo box, the .fs-themerow controls,
|
||||
* Log out and the collapsed poll pill are one size, so the right cluster reads as a row
|
||||
* of equal squares */
|
||||
--fs-btn-size: calc(34px * var(--fs-density-box));
|
||||
|
||||
/* Corner-radius scale: one user-tunable base (Appearance -> Rounding, 0-20px, pre-painted
|
||||
* on :root by partials/head.ut) with three semantic radii scaling from it proportionally,
|
||||
* so every surface rounds in step and pills stay round. At base 12: card 12, control 10,
|
||||
* chip 8. Every border-radius in theme/ and pages/ reads one of these; the only bare px
|
||||
* left are 0, 50% and three that are not a card's corner at all. */
|
||||
--fs-radius-base: 12px;
|
||||
--fs-radius-lg: var(--fs-radius-base); /* cards, panels, modals, table frame, popovers */
|
||||
--fs-radius: calc(var(--fs-radius-base) * 5 / 6); /* controls: inputs, buttons, dropdowns, tabs (10 @12) */
|
||||
--fs-radius-sm: calc(var(--fs-radius-base) * 2 / 3); /* chips, code, small insets, rail toggle (8 @12) */
|
||||
--fs-radius-pill: 999px; /* pills, toggles, badges — always round */
|
||||
|
||||
/* A card's inner gutter (.cbi-section). A token because it is read back to UNDO it:
|
||||
* theme/45-misc.css bleeds the realtime graphs out to the card's border edge by this
|
||||
* padding plus the 1px border, so a literal in both places would re-clip every graph when
|
||||
* the gutter narrows. */
|
||||
--fs-card-pad: calc(16px * var(--fs-density-space));
|
||||
/* the vertical rhythm between cards (.cbi-section, tab groups, alerts, action bars):
|
||||
* an unnamed level drifts, so it is stated once */
|
||||
--fs-card-gap: calc(16px * var(--fs-density-space));
|
||||
|
||||
--fs-font-sans: "Manrope", system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
|
||||
--fs-font-mono: "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, monospace;
|
||||
|
||||
/* ---- type scale ----
|
||||
*
|
||||
* 13px is the base deliberately: a router UI is dense tables of addresses and counters, and
|
||||
* the size was chosen for that. The rhythm around it is a unitless 1.5 rather than a hard
|
||||
* 18px — `line-height: 18px` is inherited as 18px into a 20px heading and clips it, while
|
||||
* 1.5 is re-resolved against each element's own size.
|
||||
*
|
||||
* Every step is a whole px; the line box 1.5 computes is not (13 -> 19.5), which is what
|
||||
* unitless leading gives on an odd size. What must stay whole is a BOX: never size an
|
||||
* element `--fs-type * --fs-leading` — take the nearer --fs-space step.
|
||||
*
|
||||
* Five steps, and the count is the point: a scale with 1px gaps builds no hierarchy, it
|
||||
* just makes two rules look unrelated in a grep. Ratio is roughly 1.25 per step, and
|
||||
* anything needing a size off this list is making a design decision and should say so. */
|
||||
/* ---- density: one axis, three multipliers ----
|
||||
*
|
||||
* Compact / Normal / Large is a client preference stamped as :root[data-density]; absent
|
||||
* means Normal, so the default costs no attribute and no override.
|
||||
*
|
||||
* Three multipliers, because one knob gets all three kinds of size wrong:
|
||||
*
|
||||
* --fs-density-type TEXT, moving least (.9 / 1.15). Compact is a request for less air,
|
||||
* not for smaller writing; .9 puts the base at 12px, which is the
|
||||
* floor.
|
||||
* --fs-density-space pure AIR — padding, margin, gap — which is what buys the room, so
|
||||
* it moves most (.65 at Compact). It does not grow at Large, where
|
||||
* inflating the air just reads as zoom.
|
||||
* --fs-density-box boxes that must HOLD text or an icon: the sidebar, the rail, the
|
||||
* bar height, the icon buttons, the control-height floors. They
|
||||
* cannot follow the air — the type gives up only a tenth, so a
|
||||
* sidebar cut by 35% no longer fits the labels it exists to show.
|
||||
*
|
||||
* This is only expressible because every size in the theme reads one of these tokens: a
|
||||
* size written outside the ladders silently stops responding to the axis.
|
||||
*
|
||||
* Type is rounded to whole pixels, a fractional font size rendering soft; space is not,
|
||||
* since a sub-pixel padding is invisible and rounding it would collide steps together. */
|
||||
--fs-density-type: 1;
|
||||
--fs-density-space: 1;
|
||||
--fs-density-box: 1;
|
||||
|
||||
/* ---- control heights: three steps, following the density ----
|
||||
* A minimum height stops a button collapsing onto its text, so it is part of how dense the
|
||||
* UI feels: left literal, Compact shrinks the writing while the buttons stay put.
|
||||
* Not --fs-control-h below, which is a FIELD's height derived from the text it must hold;
|
||||
* these are the floors a chrome control gets when its content is not text. */
|
||||
--fs-ctl-h-sm: calc(30px * var(--fs-density-box)); /* dense/small: .btn.small, table-row buttons */
|
||||
--fs-ctl-h: calc(38px * var(--fs-density-box)); /* the default control */
|
||||
--fs-ctl-h-lg: calc(44px * var(--fs-density-box)); /* prominent: .btn.large, the login submit */
|
||||
|
||||
/* Unrounded here, rounded in the @supports below, and the split is the difference between
|
||||
* a soft failure and no page: `round()` is the youngest thing this theme depends on
|
||||
* (Chromium 125, Firefox 118, Safari 15.4), and a custom property holds any token stream,
|
||||
* so an engine without it parses these fine and fails at SUBSTITUTION — `var(--fs-type)`
|
||||
* is then invalid at computed-value time and computes to `unset`, taking every font-size,
|
||||
* line-height and field min-height with it. Measured by serving a sheet with `round(`
|
||||
* renamed: 5881 of 5912 elements on Overview change, body type goes 13px -> 16px, and 5880
|
||||
* font-size and 5733 line-height declarations are lost. Declared this way, such an engine
|
||||
* keeps the whole ladder and pays a fractional pixel at the two non-default densities. */
|
||||
/* One step BELOW the ladder's smallest, and it exists for one measured reason: the Port
|
||||
* status card's traffic figures. They are the widest thing a card must fit whole, so their
|
||||
* size is what sets how narrow a card may be — at --fs-type-xs the floor is 106px, at 10px
|
||||
* it is 94px, which is what turns ten cards plus a lonely eleventh into one row of eleven.
|
||||
* A figure read as a pair of numbers beside a label tolerates the step that body text would
|
||||
* not. Declared here rather than as a literal in the page rule so the density axis stays in
|
||||
* one place. */
|
||||
--fs-type-2xs: calc(10px * var(--fs-density-type));
|
||||
--fs-type-xs: calc(11px * var(--fs-density-type)); /* eyebrow, badges, tooltips, dense metadata */
|
||||
--fs-type: calc(13px * var(--fs-density-type)); /* body, tables, fields, menu items — the base */
|
||||
--fs-type-lg: calc(16px * var(--fs-density-type)); /* section titles (h3/legend), alert headings */
|
||||
--fs-type-xl: calc(20px * var(--fs-density-type)); /* page titles */
|
||||
--fs-type-2xl: calc(26px * var(--fs-density-type)); /* h1 — only a third-party app emits a bare one */
|
||||
/* ---- WEIGHT: there are only ever three, and they had six spellings ----------
|
||||
* The theme ships no font at all — the stacks name Manrope and JetBrains Mono first and
|
||||
* fall through to the system faces — so these are not a ramp to pick from: they are the
|
||||
* two weights a reader is likely to actually have, plus the "un-bold this"
|
||||
* value. `700` and `bold` were both in use and are the same weight; so are `400` and
|
||||
* `normal`, and 400 has no face at all (it resolves onto the 600 one — that is why body
|
||||
* text is semibold by design, and why adding a 400 face would silently restyle every page).
|
||||
* Naming them leaves one spelling each. */
|
||||
--fs-weight-normal: 400; /* "not bold" — no face of its own; resolves onto the 600 */
|
||||
--fs-weight: 600; /* the UI default: body, labels, controls */
|
||||
--fs-weight-bold: 700; /* titles, table headers, the eyebrow */
|
||||
|
||||
--fs-leading: 1.5; /* unitless ON PURPOSE — see above (13 -> 19.5px) */
|
||||
--fs-leading-tight: 1.2; /* headings and single-line plates, where 1.5 looks loose */
|
||||
|
||||
/* ---- THE EYEBROW — one microlabel idiom, named once -------------------------
|
||||
*
|
||||
* Uppercase + tracked + bold + muted is ONE thing this theme draws in a dozen places: table
|
||||
* column headers, the stacked-card `data-title` labels, the Appearance group labels, the rail
|
||||
* flyout titles, the login field titles, the search-result section note. It had drifted into
|
||||
* four spellings of that one idiom — letter-spacing .04/.05/.06em, weight 600 vs 700, colour
|
||||
* --fs-dim vs --fs-faint — the same unnamed-level drift the role x step matrix above exists to
|
||||
* stop, only in typography. An eyebrow is a LABEL, so it takes the quietest ink and the widest
|
||||
* tracking of the set; the alert table's 600 was the odd one out and read lighter than every
|
||||
* other header on the page.
|
||||
*
|
||||
* SIZE is deliberately NOT here: 10px (a card/chrome label) and 11px (a table header, i.e.
|
||||
* --fs-type-xs) are two real tiers, and collapsing them would resize half the tables.
|
||||
*
|
||||
* Two things that look like eyebrows are NOT and must stay out: `h6` is a HEADING (it takes the
|
||||
* type scale and the heading ink), and `.fs-navlabel` is the menu's section separator, whose
|
||||
* .1em is deliberately wider than any label — it separates, it does not caption. */
|
||||
--fs-eyebrow-tracking: .06em;
|
||||
--fs-eyebrow-weight: 700;
|
||||
--fs-eyebrow-color: var(--fs-faint);
|
||||
|
||||
/* ---- SPACE SCALE — a 4px grid ----------------------------------------------
|
||||
*
|
||||
* Same story: the 18px/9px pair base used was upstream's line-height and half of it, so
|
||||
* every gutter in the theme was a function of Twitter's leading. A 4px grid is independent
|
||||
* of the type scale, which is the point — changing the font size must not silently
|
||||
* re-space every widget. `--fs-card-pad` (16px) and `--fs-content-pad` (28px) are already
|
||||
* on this grid and stay named for their role; these are the generic steps.
|
||||
*
|
||||
* Do NOT add a step because one rule wants 10px. An unnamed level is how the radius tints
|
||||
* drifted into four strengths for two decisions (see the ladder above): pick the nearer
|
||||
* step, or argue in a comment for why this rule is genuinely different. */
|
||||
/* The grid is 4px, but the theme genuinely works at 2px between the low steps: a chip's
|
||||
* inset, a nav item's row padding and a card's inner gutter all landed on 6/10/14 and no
|
||||
* amount of rounding makes them 4/8/12 without visibly changing the control. So the half
|
||||
* steps are NAMED rather than pretended away — they were the single largest group of
|
||||
* magic numbers left in the tree (6px x26, 10px x32, 14px x13, 2px x13). Above 16px the
|
||||
* grid stays 4px: nothing needs finer, and every value that had drifted between the steps
|
||||
* up there (22, 26, 42) was snapped onto one. */
|
||||
--fs-space-0-5: calc(2px * var(--fs-density-space));
|
||||
--fs-space-1: calc(4px * var(--fs-density-space));
|
||||
--fs-space-1-5: calc(6px * var(--fs-density-space));
|
||||
--fs-space-2: calc(8px * var(--fs-density-space));
|
||||
--fs-space-2-5: calc(10px * var(--fs-density-space));
|
||||
--fs-space-3: calc(12px * var(--fs-density-space));
|
||||
--fs-space-3-5: calc(14px * var(--fs-density-space));
|
||||
--fs-space-4: calc(16px * var(--fs-density-space));
|
||||
--fs-space-5: calc(20px * var(--fs-density-space));
|
||||
--fs-space-6: calc(24px * var(--fs-density-space));
|
||||
--fs-space-7: calc(28px * var(--fs-density-space));
|
||||
/* The top of the ladder is sparse on purpose — these three are gutters and insets, not
|
||||
* rhythm, and each has two or three users: the sidebar accordion's indent and the search
|
||||
* palette's bottom padding (-7), the room a field leaves for its own chevron (-8), the login
|
||||
* card's bottom margin and the gauge's two right gutters (-10). They are named so that no
|
||||
* padding in this theme is an unexplained number, not because a fourth caller is expected. */
|
||||
--fs-space-8: calc(32px * var(--fs-density-space));
|
||||
--fs-space-10: calc(40px * var(--fs-density-space));
|
||||
|
||||
/* the spinner glyph's box (base/95-luci.css `.spinning::before`, width and height): one
|
||||
* number, one name, read in one place */
|
||||
--fs-spin-size: var(--fs-space-5);
|
||||
|
||||
|
||||
/* One control height for every single-line field — input, select, .cbi-select,
|
||||
* .cbi-dropdown and the checkbox/radio row beside them. Derived rather than measured by
|
||||
* hand: the text box (--fs-type x --fs-leading = 19.5px) plus the vertical inset those
|
||||
* fields carry (2 x --fs-space-1) plus both 1px borders = 29.5 -> ceil 32 at the default
|
||||
* density. A literal here is arithmetic over one particular leading, so
|
||||
* re-scaling the type silently leaves every control the wrong height for its own text. */
|
||||
--fs-control-h: calc(var(--fs-type) * var(--fs-leading) + var(--fs-space-1) * 2 + 2px);
|
||||
|
||||
/* How wide an elastic control gets in a form row. A `.cbi-value-field` is `flex: 1`, so
|
||||
* anything asking for 100% takes the whole card, and a form whose controls each end at a
|
||||
* different x reads as broken. Fixed-width controls keep their own 210px; this is the
|
||||
* ceiling for the ones that stretch. It is a COLUMN width, like the label column beside
|
||||
* it, so it is deliberately not on the 4px step scale. */
|
||||
--fs-field-max: 440px;
|
||||
|
||||
/* ---- stacking scale ----
|
||||
* Every z-index in the theme comes from here. Bare numbers across seven files record
|
||||
* nothing about what should sit above what, which is how a popover came to paint over an
|
||||
* open modal; as an ordered list that is obvious.
|
||||
*
|
||||
* Bottom to top:
|
||||
* raise in-flow child that must clear its siblings (zonebadge tooltip)
|
||||
* sticky the sticky bars: top-nav, sidebar phone bar
|
||||
* flyout nav panels: rail flyouts, top-nav dropdowns, rail tooltips
|
||||
* header base's sticky <header> (above content, below any popup)
|
||||
* popover the Appearance popover — ABOVE the chrome, BELOW a modal
|
||||
* overlay #modal_overlay: a modal is modal, it covers the chrome
|
||||
* tooltip .cbi-tooltip — must read over modal content
|
||||
* dropdown an OPEN .cbi-dropdown list — over everything, including inside a modal
|
||||
* ------------------------------------------------------------------------ */
|
||||
--fs-z-raise: 2;
|
||||
--fs-z-sticky: 50;
|
||||
--fs-z-flyout: 70;
|
||||
--fs-z-header: 800;
|
||||
--fs-z-popover: 850;
|
||||
--fs-z-overlay: 900;
|
||||
--fs-z-tooltip: 1000;
|
||||
--fs-z-dropdown: 1100;
|
||||
|
||||
/* ---- export tier: outbound only ----
|
||||
* Nothing in styles/ may read these (tools/audit.py fails the build if it does). They
|
||||
* exist so a third-party luci-app-* addressing them still gets our palette and dark mode,
|
||||
* and so an app overwriting one restyles only its own widgets.
|
||||
*
|
||||
* high/medium/low is a PROMINENCE scale, not decoration: apps do ask for the gradation —
|
||||
* one paints its "no data" latency with --primary-color-low, another reads eleven of these
|
||||
* names, and stock firewall.js and status/cpu.js read them too — so three aliases of one
|
||||
* token hand back a flat colour.
|
||||
*
|
||||
* Direction is bootstrap's, which every app was calibrated against: `high` is the most
|
||||
* pronounced value of the role, except --background-color-*, which is an ELEVATION axis
|
||||
* (high = raised). The mechanism differs per family, by measurement — see each block.
|
||||
*
|
||||
* Binding constraint: apps read a level as `color:` about as often as as `background:`, so
|
||||
* every level must clear WCAG AA as text on --fs-bg/--fs-panel/--fs-panel2 and carry a
|
||||
* legible --on-*-color as a fill. */
|
||||
--background-color-high: var(--fs-panel);
|
||||
--background-color-medium: color-mix(in srgb, var(--fs-panel) 55%, var(--fs-panel2));
|
||||
--background-color-low: var(--fs-panel2);
|
||||
|
||||
/* -low is --fs-faint, the theme's own third ink, and not a duplicate of -medium: making the
|
||||
* two the same token flattens the export (`spread(high, low)` falls to 0.082 in the
|
||||
* default palette, under the 0.10 the ramp promises) and hands an app asking for a
|
||||
* gradation one colour twice. Legibility is measured rather than assumed — every level is
|
||||
* held to AA as text on all three surfaces and as a fill under its --on-* ink, in both
|
||||
* modes, across the whole palette x tint matrix. */
|
||||
--text-color-highest: var(--fs-text);
|
||||
--text-color-high: var(--fs-text);
|
||||
--text-color-medium: var(--fs-dim);
|
||||
--text-color-low: var(--fs-faint);
|
||||
|
||||
/* borders carry no text, so -low may fade toward the surface: a hairline is supposed to
|
||||
* disappear into it */
|
||||
--border-color-high: color-mix(in srgb, var(--fs-border) 60%, var(--fs-text));
|
||||
--border-color-medium: var(--fs-border);
|
||||
--border-color-low: color-mix(in srgb, var(--fs-border) 55%, var(--fs-panel));
|
||||
|
||||
/* Accent ramps: the axis is CHROMA at constant lightness — `high` is the pure palette
|
||||
* colour and each step mixes it toward --fs-dim in oklch, which interpolates lightness
|
||||
* linearly and so drains saturation while leaving luminance put, keeping every level
|
||||
* printable as text. Both alternatives were measured and rejected:
|
||||
*
|
||||
* fading `low` toward the surface spends contrast we do not have — in dark every accent
|
||||
* already sits at 4.56-4.59:1, and an 8% fade took one level to 4.18:1;
|
||||
*
|
||||
* pushing `high` toward --fs-text collapses the ramp in dark, where --fs-text is
|
||||
* near-white: the strong end comes back 0.055 from the weak end, i.e. flat.
|
||||
*
|
||||
* Bootstrap's own ramp walks lightness, which is why it reads inverted in dark mode and
|
||||
* lands at 3.6:1. Keep its direction, drop its mechanism. Every step is mixed FROM the
|
||||
* token it grades, so there is no hand-kept second copy of a colour, and
|
||||
* tools/export-tier.mjs proves the whole tier across palette x mode. */
|
||||
--primary-color-high: var(--fs-accent);
|
||||
--primary-color-medium: color-mix(in oklch, var(--fs-accent) 78%, var(--fs-dim));
|
||||
--primary-color-low: color-mix(in oklch, var(--fs-accent) 45%, var(--fs-dim));
|
||||
--on-primary-color: var(--fs-on-accent);
|
||||
|
||||
--error-color-high: var(--fs-danger);
|
||||
--error-color-medium: color-mix(in oklch, var(--fs-danger) 78%, var(--fs-dim));
|
||||
--error-color-low: color-mix(in oklch, var(--fs-danger) 45%, var(--fs-dim));
|
||||
--on-error-color: var(--fs-on-danger);
|
||||
|
||||
--success-color-high: var(--fs-good);
|
||||
--success-color-medium: color-mix(in oklch, var(--fs-good) 78%, var(--fs-dim));
|
||||
--success-color-low: color-mix(in oklch, var(--fs-good) 45%, var(--fs-dim));
|
||||
--on-success-color: var(--fs-on-good);
|
||||
|
||||
--warn-color-high: var(--fs-warn);
|
||||
--warn-color-medium: color-mix(in oklch, var(--fs-warn) 78%, var(--fs-dim));
|
||||
--warn-color-low: color-mix(in oklch, var(--fs-warn) 45%, var(--fs-dim));
|
||||
--on-warn-color: var(--fs-on-warn);
|
||||
|
||||
--fs-disabled-opacity: .6;
|
||||
color-scheme: light;
|
||||
}
|
||||
|
||||
/* ---- the rounded half of the type ladder, for engines that can round ----
|
||||
*
|
||||
* A fractional font size renders soft, so every size is meant to land on a whole pixel — but a
|
||||
* token using `round()` on an engine without it is not a fallback, it is a deleted token that
|
||||
* takes every rule reading it (see the ladder above). So the ladder is declared plainly there
|
||||
* and rounded here, where the at-rule can be asked first. --fs-control-h is derived from
|
||||
* --fs-type and rounds UP to the 4px control ladder for the same reason.
|
||||
*
|
||||
* `@supports (width: round(1px, 1px))` rather than a `calc()` probe: the function has to be
|
||||
* tested where a length is expected. */
|
||||
@supports (width: round(1px, 1px)) {
|
||||
:root {
|
||||
--fs-type-2xs: calc(round(10px * var(--fs-density-type), 1px));
|
||||
--fs-type-xs: calc(round(11px * var(--fs-density-type), 1px));
|
||||
--fs-type: calc(round(13px * var(--fs-density-type), 1px));
|
||||
--fs-type-lg: calc(round(16px * var(--fs-density-type), 1px));
|
||||
--fs-type-xl: calc(round(20px * var(--fs-density-type), 1px));
|
||||
--fs-type-2xl: calc(round(26px * var(--fs-density-type), 1px));
|
||||
--fs-control-h: calc(round(up, calc(var(--fs-type) * var(--fs-leading) + var(--fs-space-1) * 2 + 2px), 4px));
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- the density axis ----
|
||||
*
|
||||
* Normal is a bare :root, so the default path costs no attribute and no override.
|
||||
*
|
||||
* These multiply the LADDERS, not the rules: a size on a ladder follows the axis for free and
|
||||
* one that is not silently ignores it. */
|
||||
:root[data-density="compact"] {
|
||||
/* type moves least (.9 against .65 for the air): padding is where the room is, so leaning
|
||||
* on the text would cost legibility to save very little. At .9 the base is 12px and the
|
||||
* eyebrow 10px, which is the floor. */
|
||||
--fs-density-type: .9;
|
||||
--fs-density-box: .85;
|
||||
--fs-density-space: .65;
|
||||
}
|
||||
:root[data-density="large"] {
|
||||
/* Large is about the TEXT, so the air does not grow with it: only the type and the boxes
|
||||
* that hold it get bigger. Inflating the spacing too pushes content off the screen and
|
||||
* makes the setting read as zoom, which is the browser's job. */
|
||||
--fs-density-type: 1.15;
|
||||
--fs-density-box: 1.15;
|
||||
--fs-density-space: 1;
|
||||
}
|
||||
|
||||
/* ---- the content-width axis ----
|
||||
*
|
||||
* No :root[data-content-width] blocks here (issue #44 moved this from a three-step picker to a
|
||||
* slider): the value is a real px length written straight onto --fs-content-max as an inline
|
||||
* style by fs-axes.js's propAxis, the same shape Rounding uses, and read back exactly as before
|
||||
* by `.fs-content`, the modal width calc and the top layout's centring padding
|
||||
* (theme/20-shell.css, theme/50-toplayout.css) — deliberately including the modal, which follows
|
||||
* the column on purpose rather than keeping its own separate cap the reader would have to
|
||||
* reconcile against.
|
||||
*
|
||||
* The range is 1280-3840, and neither end is derived from this file: 1280 (--fs-content-max
|
||||
* above) is the value the theme has always drawn, so the slider's left end IS today's look and
|
||||
* the axis can never go narrower than the default — a difference from every other numeric axis,
|
||||
* none of which has a floor that also has to be the default. --fs-content-min (500px) was the
|
||||
* rule this axis had to stay clear of; with 1280 as the floor it is now a property of the range
|
||||
* instead, 780px below the nearest point the slider can reach. 3840 stands in for "uncapped": no
|
||||
* CSS viewport width in ordinary use reaches it, since even a physical 4K panel reports a scaled
|
||||
* CSS width well under it — and `columnWidth()`'s `Math.min(state.outerW - cut, g.contentMax)`
|
||||
* needs a real px length either way, `none`/`100%` failing both the `calc()` in
|
||||
* 50-toplayout.css and `px()`'s getComputedStyle probe in fs-chrome.js.
|
||||
*
|
||||
* Step 128px: 2,560px of travel at 20 stops, matching Rounding/Photo dim/Pattern strength's stop
|
||||
* count rather than Pattern scale's near-pixel drag — a stop here should move a table's column
|
||||
* count, not shave a pixel off a margin, and 128 is the largest round number that divides the
|
||||
* range into stops that few. */
|
||||
|
||||
:root[data-darkmode="true"] {
|
||||
/* palette colours are in 03-palettes.css; only mode-level, palette-independent
|
||||
* tokens live here */
|
||||
--fs-disabled-opacity: .45;
|
||||
/* the hover cue flips direction here (see --fs-hover-lift): a dark-mode solid button is a
|
||||
* light fill with dark ink, so brightening moves it away from both the page and its own
|
||||
* ink */
|
||||
--fs-hover-lift: brightness(1.15);
|
||||
color-scheme: dark;
|
||||
}
|
||||
|
||||
/* No component bridge in any notation (--*-hsl triples, --*-rgb read as `rgba(var(--x), .3)`):
|
||||
* a hand-kept second copy of a colour goes stale in silence when a palette is recoloured, and
|
||||
* a missing triple makes the declaration invalid at computed-value time, so the tint vanishes
|
||||
* with no error tools/audit.py can catch — the var IS defined, only elsewhere. A tint of X is
|
||||
* mixed FROM X, and a component copy must not be reintroduced in any notation:
|
||||
* rgba(var(--error-color-high-rgb), .3) -> color-mix(in srgb, var(--fs-danger) 30%, transparent)
|
||||
* The one surviving --*-rgb is --zone-color-rgb, which is not ours: luci-mod-network writes it
|
||||
* inline on a zone badge (base/95-luci.css). */
|
||||
}
|
||||
@@ -1,587 +0,0 @@
|
||||
@layer tokens {
|
||||
/* ---- colourways (palettes) ----
|
||||
*
|
||||
* Every colour is a variable and every palette is one self-contained block per mode, so a new
|
||||
* colourway is copy-one-pair-and-recolour. Five ship: footstrap (GitHub Primer, the default),
|
||||
* hicontrast, bootstrap (the stock LuCI theme's colours), 2020 (the OpenWrt 2020 theme's
|
||||
* colourway) and forum (the OpenWrt forum's Discourse colourway).
|
||||
*
|
||||
* TO ADD A COLOURWAY "sunset":
|
||||
* 1. Copy the two hicontrast blocks below, rename data-palette to "sunset".
|
||||
* 2. Set every colour. FIVE are declared as -base with the live token derived from them,
|
||||
* so the colour axes can recolour them with no second copy to keep in sync: the canvas
|
||||
* --fs-bg-base → --fs-bg (TINT block), the accent --fs-accent-base → --fs-accent and
|
||||
* the three status colours --fs-good-base / --fs-warn-base / --fs-danger-base (COLOUR
|
||||
* AXES block). A palette never declares --fs-good itself.
|
||||
* 3. Set the four INKS (--fs-on-accent/-good/-warn/-danger) — see below.
|
||||
* 4. Register the name in all four places, because each one fails DIFFERENTLY and quietly:
|
||||
* the PALETTE axis in fs-prefs.js (live switching), the `_sd_pal` whitelist AND the
|
||||
* pre-paint switch in partials/head.ut (a router default outside the whitelist becomes
|
||||
* '' and the page paints in the default palette), the label map in fs-appearance.js (an
|
||||
* unnamed palette is missing from the picker, not broken), and matrix() in
|
||||
* tools/lib/gallery.mjs — a palette absent there is one export-tier.mjs,
|
||||
* a11y-gallery.mjs and placeholder-ink.mjs never measure, so it ships ungated.
|
||||
* Nothing else: layout, components and the --*-color-* export bridge key off these tokens, and
|
||||
* every tint, shadow and hairline is a color-mix() over them.
|
||||
*
|
||||
* The inks are per palette and per mode. A single global `--fs-on-accent: #fff` holds up on
|
||||
* the dark fills of a LIGHT palette and nowhere else — on a dark palette's light fills it
|
||||
* measures 1.69-2.80:1, where AA wants 4.5:1 for text and 3:1 for a UI shape. Check a new
|
||||
* colourway's inks against all four of its own fills; every pair below clears 4.5:1.
|
||||
*
|
||||
* A tint of X is mixed FROM X — do not reintroduce a component copy of a colour in any
|
||||
* notation (foot of 02-tokens.css).
|
||||
*
|
||||
* Default: footstrap fills bare :root, so a no-JS load still has colours; every other
|
||||
* colourway is opt-in. :root[data-palette=…][data-darkmode=…] (0,3,0) beats the bare blocks,
|
||||
* and each block sets a COMPLETE token set so the winner fully applies. */
|
||||
|
||||
/* Native <select> closed-control chevron (theme/60-inputs.css). A data-URI cannot
|
||||
* reference var() or currentColor, so each palette block bakes its own --fs-dim into
|
||||
* the stroke — the only way the glyph can follow palette and mode. */
|
||||
|
||||
/* ---- background tint: "which router am I on?" ----
|
||||
*
|
||||
* One hue (Appearance -> Tint, 0-360°, localStorage `fs-tint`, pre-painted on :root by
|
||||
* partials/head.ut) washed into the CANVAS — --fs-bg, the surface the cards float on — so a
|
||||
* whole install reads as green, violet or amber at a glance. localStorage is keyed
|
||||
* by origin, so the cue is per router with nothing server-side. Off (no data-tint) is the
|
||||
* palette exactly as it was.
|
||||
*
|
||||
* Nothing else moves: the cards, the chrome and the semantic colours keep the palette's own
|
||||
* values, and re-hueing a status colour would make it lie about status.
|
||||
*
|
||||
* --fs-bg-base exists because a custom property cannot be defined from itself:
|
||||
* `--fs-bg: color-mix(…, var(--fs-bg), …)` is a cycle, invalid at computed-value time, and
|
||||
* drops the colour silently. A palette names the raw canvas, this block owns the derivation,
|
||||
* and every rule goes on reading --fs-bg.
|
||||
*
|
||||
* It sets chroma and hue rather than mixing a colour in, because in a POLAR space the mix's
|
||||
* hue lands on the tint's almost immediately and the percentage never controls the strength:
|
||||
* measured on the dark canvas, "2%" and "6%" at hue 165 gave the same green. Light mode failed
|
||||
* the other way, the mix leaving sRGB and clipping, so the cue's strength depended on which
|
||||
* hue was picked. So the canvas takes the user's hue at a chroma we choose and keeps its own
|
||||
* LIGHTNESS, in one relative-colour declaration:
|
||||
* one honest knob --fs-tint-c is the strength, in chroma. Light mode has less headroom and
|
||||
* does clip at the top of the wheel, which costs a few units of strength
|
||||
* but not the direction. On a canvas of pure WHITE the cue is nearly
|
||||
* hue-blind — on bootstrap's #fff, 180° and 258° land 1/255 apart —
|
||||
* which is the price of copying a stock theme's surfaces.
|
||||
* contrast is free `l` is copied through, so AA margins barely move; the mix dragged
|
||||
* lightness toward the anchor and cost one export level 4.61 -> 4.40:1.
|
||||
*
|
||||
* tools/export-tier.mjs runs the AA matrix over six hues x both modes x every palette and
|
||||
* tools/a11y-gallery.mjs runs axe over the tinted gallery at two extreme hues. Change
|
||||
* --fs-tint-c and re-run both.
|
||||
*
|
||||
* The shipped chroma is deliberately tiny — the dark floor is below the chroma the dark canvas
|
||||
* already carries. This is an identity cue, not a colourway: a large flat field is where the
|
||||
* eye is most sensitive to a cast. Loud belongs in a palette, where the cards and chrome can
|
||||
* move too. */
|
||||
:root {
|
||||
--fs-bg: var(--fs-bg-base);
|
||||
/* the UI accent, derived from the palette's own -base hex so the accent-hue axis below can
|
||||
* rotate it with no second copy to keep in sync. Absent an accent hue, --fs-accent IS the
|
||||
* palette's -base value. */
|
||||
--fs-accent: var(--fs-accent-base);
|
||||
/* a tint OF --fs-accent, mixed FROM it: a restated literal goes stale the moment the accent
|
||||
* is recoloured or the accent-hue axis rotates it. LIGHT strength only — every palette's
|
||||
* light block wanted the identical 10%, so this one declaration replaces five copies; a
|
||||
* dark block still declares its own (15%, hicontrast 14%: 02-tokens.css line ~81) and wins
|
||||
* on specificity. */
|
||||
--fs-accent-soft: color-mix(in srgb, var(--fs-accent) 10%, transparent);
|
||||
/* the three status colours, derived from the palette's -base hex for the reason the accent
|
||||
* is: an axis rotating a token the palettes declared directly would need a second copy of
|
||||
* every value to rotate from */
|
||||
/* The surfaces, split the same way and for the same reason as the accent. A palette
|
||||
* declares the raw value; every rule reads the derived one.
|
||||
*
|
||||
* Do not add a transparency axis over these: thinning the surface thins the TEXT's
|
||||
* background out from under it, and the contrast readouts cannot even report it — a ratio
|
||||
* against a semi-transparent backdrop is a ratio against whatever is behind that pixel.
|
||||
* The wallpaper axis is the honest way to have a picture. */
|
||||
--fs-panel: var(--fs-panel-base);
|
||||
--fs-panel2: var(--fs-panel2-base);
|
||||
--fs-border: var(--fs-border-base);
|
||||
--fs-good: var(--fs-good-base);
|
||||
--fs-warn: var(--fs-warn-base);
|
||||
--fs-danger: var(--fs-danger-base);
|
||||
/* The ink of a value that is NOT there — the `placeholder` attribute and the dropdown's
|
||||
* `li[placeholder]` row. LuCI writes an option's DEFAULT there (`form.Value.placeholder`:
|
||||
* 128 for the log buffer, 514 for the log port), so an ink that reads as body text tells
|
||||
* the reader a field is set when it is empty — reported against 0.14.8, forum topic 251930
|
||||
* posts 82-83. --fs-dim was that ink and is not far enough away: on footstrap light's
|
||||
* --fs-panel2 it measures 11.12:1 against the text's 14.84:1, which is two blacks.
|
||||
*
|
||||
* Derived, not hand-listed per palette, so it follows a palette that has not been written
|
||||
* yet. The formula is spelt once and the STRENGTH is a token of its own, because it is the
|
||||
* only part that varies — per mode here, and again under prefers-contrast:more
|
||||
* (theme/95-a11y-media.css); restating the whole mix in each of those four places cost 79 B
|
||||
* of shipped sheet and gave three more copies to keep in step. That is also why it lives
|
||||
* here rather than in 02-tokens.css's ladder — the same reason --fs-accent-soft does.
|
||||
*
|
||||
* Light lands at 3.99-4.48:1 across the four palettes, 43-44% of the way from the value's
|
||||
* ink to the field: under AA on purpose, see the dark half below for the whole argument.
|
||||
* oklch because the step is a LIGHTNESS one — srgb at the same 55% stops at 3.58:1. Held by
|
||||
* `npm run placeholder`. */
|
||||
--fs-placeholder-mix: 55%;
|
||||
--fs-placeholder: color-mix(in oklch, var(--fs-text) var(--fs-placeholder-mix), var(--fs-panel2));
|
||||
/* The hues the user picked, in degrees. Declared here and not only inline by
|
||||
* head.ut/fs-prefs.js, so the stylesheet stands on its own: a var() with no definition
|
||||
* anywhere is invalid at computed-value time and takes the whole declaration down. */
|
||||
--fs-accent-h: 0;
|
||||
--fs-tint-h: 0;
|
||||
--fs-good-h: 0;
|
||||
--fs-warn-h: 0;
|
||||
--fs-danger-h: 0;
|
||||
/* Tint strength (Appearance -> Tint strength — NOT the Density select, which is the
|
||||
* UI-density axis and owns that word): a multiplier on the tint chroma below, 1 being the
|
||||
* designed strength and 2 the cap. Set inline (value/100) by head.ut and fs-prefs.js.
|
||||
*
|
||||
* 0 is not "the palette back": the rule below is a relative colour that REPLACES chroma, so
|
||||
* a multiplier of 0 also strips the cast the canvas already had (every palette's canvas is
|
||||
* a blue-grey) and leaves it neutral at the same lightness — footstrap dark rgb(28,33,40)
|
||||
* paints as rgb(33,33,33). It cannot be made into the
|
||||
* untinted page here — a conditional would have to sit on :root, which a style query cannot
|
||||
* reach. The true off is clearing the Tint hue, which drops data-tint and this rule. */
|
||||
--fs-tint-strength: 1;
|
||||
/* The uploaded login/page background. --fs-login-bg-url is the url() head.ut and fs-prefs.js
|
||||
* stamp inline; `none` here is the stand-on-its-own default the hues carry above.
|
||||
* --fs-photo-scrim is the wash laid over the photo so on-canvas text stays legible on an
|
||||
* arbitrary image — derived from --fs-bg, so it follows palette, mode and tint, and its
|
||||
* opacity bounds the effective canvas contrast whatever the photo is. Both are inert until
|
||||
* data-login-bg is present (theme/16-login-bg.css). */
|
||||
--fs-login-bg-url: none;
|
||||
/* --fs-photo-dim is the scrim opacity over a File photo, a per-browser axis like the rest.
|
||||
* The scrim is mixed from --fs-bg-BASE, not --fs-bg, so it stays neutral: the tint colours
|
||||
* --fs-bg and must never leak onto a photo. */
|
||||
--fs-photo-dim: 74%;
|
||||
--fs-photo-scrim: color-mix(in srgb, var(--fs-bg-base) var(--fs-photo-dim), transparent);
|
||||
/* The uploaded pattern, tiled behind the content by 15-wallpaper.css. --fs-pattern-url is
|
||||
* stamped inline and is `none` here for the same reason --fs-login-bg-url is. The other two
|
||||
* are ordinary per-browser axes: the tile's edge length and the layer's opacity, where .2
|
||||
* is where a neutral line reads as a drawing rather than texture (.15 is swallowed by a
|
||||
* tinted canvas). */
|
||||
--fs-pattern-url: none;
|
||||
--fs-pattern-size: 440px;
|
||||
--fs-pattern-strength: .2;
|
||||
/* How strong the cue is: a chroma, and a function of the HUE, because the canvas is not
|
||||
* neutral — every palette's canvas is a blue-grey (oklch hue 248-264) and the dark one
|
||||
* carries chroma .0153 of it. A flat chroma leaves the blue/violet end of the wheel
|
||||
* invisible, painting the canvas less blue than the palette already was. The cue is read
|
||||
* against the untinted page, so it must out-chroma the canvas's own cast where the two
|
||||
* agree: a floor plus two cos() terms, each peaking on one hue and gone 90° away.
|
||||
*
|
||||
* +boost at 258° the canvas's own hue; without it blue and violet do nothing
|
||||
* -damp at 55° red-through-yellow, which the eye picks up first, so at a shared floor
|
||||
* the warm half shouts while the cold half whispers (dark only — on a
|
||||
* near-white canvas warm is the quietest hue there is)
|
||||
*
|
||||
* One expression per mode, with no per-hue table to keep in sync. Light runs the HIGHER
|
||||
* floor: near-white has almost no chroma of its own (.0034), so the tint is the only
|
||||
* colour there. */
|
||||
--fs-tint-c: calc((.016 + .012 * max(0, cos((var(--fs-tint-h) - 258) * 1deg))) * var(--fs-tint-strength));
|
||||
}
|
||||
:root[data-darkmode="true"] {
|
||||
--fs-tint-c: calc((.011 + .016 * max(0, cos((var(--fs-tint-h) - 258) * 1deg))
|
||||
- .004 * max(0, cos((var(--fs-tint-h) - 55) * 1deg))) * var(--fs-tint-strength));
|
||||
/* 64%, against the 55% above, and the difference is what a dark palette can afford: its ink
|
||||
* starts at 6.45:1 on --fs-panel2 where the light one has 14.84:1, so the same percentage
|
||||
* would buy a hint nobody can read. It lands at 3.43-6.05:1, 33-35% of the range.
|
||||
*
|
||||
* BOTH modes ship below AA, and that is the decision this token exists to record: a hint
|
||||
* mistaken for a value makes a reader configure the wrong thing, while a hint at 3.43:1
|
||||
* makes them look twice. The AA-clearing mixes (62/80%) were measured first and moved only
|
||||
* 37% and 20% of the range — the same fault, quieter. 3:1 (SC 1.4.11, and SC 1.4.3's
|
||||
* large-text floor) is the line NOT crossed, worst 3.43:1; prefers-contrast:more buys the
|
||||
* AA ink back in both modes (theme/95-a11y-media.css); and `placeholder-ink` holds all
|
||||
* three states, axe-core being excluded from this row for the same reason. */
|
||||
--fs-placeholder-mix: 64%;
|
||||
}
|
||||
:root[data-tint="hue"] { --fs-bg: oklch(from var(--fs-bg-base) l var(--fs-tint-c) var(--fs-tint-h)); }
|
||||
|
||||
/* ---- the colour axes: five colours, two ways to set each ----
|
||||
*
|
||||
* Accent, Tint, Good, Warn and Danger are one axis pointed at five tokens (fs-prefs.js's
|
||||
* colorAxis). Each is OFF (no attribute = the palette exactly as it shipped) or set one of
|
||||
* two ways, which is what the attribute's VALUE says:
|
||||
*
|
||||
* data-x="hue" the slider — oklch(from <the palette's own> l c H). Lightness and chroma
|
||||
* are the palette's, so every contrast margin the palette was measured at
|
||||
* survives the rotation and the ink does NOT need recomputing.
|
||||
* data-x="hex" the colour field — the user's colour EXACTLY, stamped inline on :root by
|
||||
* head.ut/fs-prefs.js. An inline custom property outranks every layer, so
|
||||
* the declaration is not repeated here; what IS here is the consequence.
|
||||
*
|
||||
* The ink is derived, and only in hex mode. --fs-on-accent is the ink ON the accent fill — a
|
||||
* solid button's label, the toggle knob, the active tab pill — and the palettes pick it per
|
||||
* mode against fills they were measured against. A user-entered colour is measured against
|
||||
* nothing, so keeping the palette's ink puts white on #ffd400: 1.43:1, on the one control
|
||||
* whose whole job is to be pressed.
|
||||
*
|
||||
* So in hex mode the ink follows the LIGHTNESS of whatever was entered:
|
||||
* `oklch(from <fill> clamp(0, (l - .62) * -100, 1) 0 0)` is black above L .62 and white
|
||||
* below it, chroma zeroed so it is a neutral either way. The multiplier only has to be big
|
||||
* enough to saturate the clamp — there is deliberately no ramp between the two, because a
|
||||
* mid-grey ink is the one answer that fails against both.
|
||||
*
|
||||
* L .62 is where black and white cross over in sRGB (a mid grey is ~4.6:1 against each), so
|
||||
* the worse of the two is never much under AA and the better is far over it. It is derived
|
||||
* from the fill rather than picked per palette on purpose: an axis is set per BROWSER and
|
||||
* composes with either palette and either mode, so there is no block a per-palette answer
|
||||
* could live in.
|
||||
*
|
||||
* Tint has no ink row: it colours the CANVAS, whose text is --fs-text, a palette token this
|
||||
* axis must not move — which is also why the Appearance page reports the contrast a custom
|
||||
* canvas lands at instead of correcting it. */
|
||||
:root[data-accent="hue"] { --fs-accent: oklch(from var(--fs-accent-base) l c var(--fs-accent-h)); }
|
||||
:root[data-good="hue"] { --fs-good: oklch(from var(--fs-good-base) l c var(--fs-good-h)); }
|
||||
:root[data-warn="hue"] { --fs-warn: oklch(from var(--fs-warn-base) l c var(--fs-warn-h)); }
|
||||
:root[data-danger="hue"] { --fs-danger: oklch(from var(--fs-danger-base) l c var(--fs-danger-h)); }
|
||||
|
||||
/* The attribute is repeated to win on specificity, which is load-bearing: a palette's dark
|
||||
* block is `:root[data-darkmode="true"]`, also (0,2,0), and it declares the ink too — so at
|
||||
* equal specificity the later rule wins and the single-attribute form loses in dark mode only
|
||||
* (a grey accent kept the dark palette's near-black ink at 1.9:1 while light derived white).
|
||||
* Repeating the attribute makes it (0,3,0) and wins in both modes, never on source order. */
|
||||
:root[data-accent="hex"][data-accent] { --fs-on-accent: oklch(from var(--fs-accent) clamp(0, (l - .62) * -100, 1) 0 0); }
|
||||
:root[data-good="hex"][data-good] { --fs-on-good: oklch(from var(--fs-good) clamp(0, (l - .62) * -100, 1) 0 0); }
|
||||
:root[data-warn="hex"][data-warn] { --fs-on-warn: oklch(from var(--fs-warn) clamp(0, (l - .62) * -100, 1) 0 0); }
|
||||
:root[data-danger="hex"][data-danger] { --fs-on-danger: oklch(from var(--fs-danger) clamp(0, (l - .62) * -100, 1) 0 0); }
|
||||
|
||||
/* ---- footstrap — GitHub Primer (DEFAULT, also fills bare :root) ----
|
||||
* `[data-palette="footstrap"]` never matches — both appliers REMOVE the attribute for the
|
||||
* default rather than stamp it (fs-prefs.js listAxis, partials/head.ut:216) — and it is kept
|
||||
* anyway: dropping it leaves a bare `:root` that duplicates the derive rule above, and merging
|
||||
* those two would put one palette's raw values in the block that derives every palette's. 86 B
|
||||
* to keep the two roles apart. */
|
||||
:root,
|
||||
:root[data-palette="footstrap"] {
|
||||
/* LIGHT */
|
||||
--fs-bg-base: #f6f8fa;
|
||||
--fs-panel-base: #fff;
|
||||
--fs-panel2-base: #f6f8fa;
|
||||
--fs-border-base: #d0d7de;
|
||||
--fs-text: #1f2328;
|
||||
/* The secondary tier carries LuCI's page descriptions and every field title, which at the
|
||||
* GitHub-light greys (5.2:1 and 4.9:1 on the card) is help text a reader has to lean into.
|
||||
* Now 11.8:1 and 10.0:1, still a tier below the 15.8:1 body ink so a label stays a
|
||||
* label. */
|
||||
--fs-dim: #33383d;
|
||||
--fs-faint: #3d4348;
|
||||
--fs-accent-base: #0969da;
|
||||
--fs-track: #eaeef2;
|
||||
--fs-good-base: #197c36;
|
||||
--fs-warn-base: #946300;
|
||||
--fs-danger-base: #cf222e;
|
||||
/* ink ON the fills above — white clears AA on all four: 5.19/5.28/5.19/5.36 */
|
||||
--fs-on-accent: #fff;
|
||||
--fs-on-good: #fff;
|
||||
--fs-on-warn: #fff;
|
||||
--fs-on-danger: #fff;
|
||||
}
|
||||
:root[data-darkmode="true"],
|
||||
:root[data-palette="footstrap"][data-darkmode="true"] {
|
||||
/* DARK (dimmed) */
|
||||
--fs-bg-base: #1c2128;
|
||||
--fs-panel-base: #22272e;
|
||||
--fs-panel2-base: #2d333b;
|
||||
--fs-border-base: #444c56;
|
||||
--fs-text: #adbac7;
|
||||
--fs-dim: #8f9cab;
|
||||
--fs-faint: #959ca5;
|
||||
--fs-accent-base: #569df5;
|
||||
--fs-accent-soft: color-mix(in srgb, var(--fs-accent) 15%, transparent);
|
||||
--fs-track: #373e47;
|
||||
--fs-good-base: #5aad5d;
|
||||
--fs-warn-base: #c79128;
|
||||
--fs-danger-base: #ea7a74;
|
||||
/* dark ink: these fills are LIGHT. White measures 2.79/2.77/2.80/2.79 — a fail on
|
||||
* all four. #10151c (a shade of --fs-bg) gives 6.58/6.61/6.55/6.57. */
|
||||
--fs-on-accent: #10151c;
|
||||
--fs-on-good: #10151c;
|
||||
--fs-on-warn: #10151c;
|
||||
--fs-on-danger: #10151c;
|
||||
}
|
||||
|
||||
/* ---- hicontrast — deeper, more saturated (opt-in) ---- */
|
||||
:root[data-palette="hicontrast"] {
|
||||
/* LIGHT
|
||||
* The four accents below are DARKER than the default palette's, not brighter: brighter
|
||||
* made the palette named "hicontrast" the lower-contrast one — --fs-good #17b978 as a
|
||||
* label on --fs-panel measured 2.55:1 against the default's 5.08:1. They serve both as
|
||||
* text on --fs-panel (status labels, outline buttons, port speeds) and as fills under
|
||||
* white ink, and both uses want >=4.5:1 against white. At 5.22/5.35/5.93/5.80 they are
|
||||
* genuinely above the default palette, which is what the name promises. */
|
||||
--fs-bg-base: #eef1f6;
|
||||
--fs-panel-base: #fff;
|
||||
--fs-panel2-base: #f6f8fb;
|
||||
--fs-border-base: #e4e9f1;
|
||||
--fs-text: #101725;
|
||||
/* …and the secondary tier moves with it, the promise above being relative: 13.5:1 and
|
||||
* 12.0:1 against the default palette's 11.8 and 10.0 */
|
||||
--fs-dim: #272f3d;
|
||||
--fs-faint: #2e3745;
|
||||
--fs-accent-base: #0b6fbd;
|
||||
--fs-track: #eaeef4;
|
||||
--fs-good-base: #0f7a52;
|
||||
--fs-warn-base: #8a5a00;
|
||||
--fs-danger-base: #c02b2b;
|
||||
/* white on the fills above: 5.22/5.35/5.93/5.80 */
|
||||
--fs-on-accent: #fff;
|
||||
--fs-on-good: #fff;
|
||||
--fs-on-warn: #fff;
|
||||
--fs-on-danger: #fff;
|
||||
}
|
||||
:root[data-palette="hicontrast"][data-darkmode="true"] {
|
||||
/* DARK */
|
||||
--fs-bg-base: #0a0d13;
|
||||
--fs-panel-base: #111620;
|
||||
--fs-panel2-base: #161c28;
|
||||
--fs-border-base: #232b3a;
|
||||
--fs-text: #e8edf5;
|
||||
--fs-dim: #9ba6b8;
|
||||
--fs-faint: #8f9aad;
|
||||
--fs-accent-base: #3ba7ff;
|
||||
--fs-accent-soft: color-mix(in srgb, var(--fs-accent) 14%, transparent);
|
||||
--fs-track: #1b2230;
|
||||
--fs-good-base: #43e0a0;
|
||||
--fs-warn-base: #ffb454;
|
||||
--fs-danger-base: #ff6b6b;
|
||||
/* dark ink: white on these neons measures 2.57/1.69/1.76/2.78, while #0a0d13 (= --fs-bg-base)
|
||||
* gives 7.55/11.49/11.03/7.01 */
|
||||
--fs-on-accent: #0a0d13;
|
||||
--fs-on-good: #0a0d13;
|
||||
--fs-on-warn: #0a0d13;
|
||||
--fs-on-danger: #0a0d13;
|
||||
}
|
||||
|
||||
/* ---- bootstrap — the colours of luci-theme-bootstrap, the LuCI default (opt-in) ----
|
||||
*
|
||||
* The surfaces, greys and semantic colours of the stock theme, so an admin who wants the look
|
||||
* they already know keeps it and still gets the chrome, the client navigation and the axes.
|
||||
*
|
||||
* Bootstrap computes everything from HSL axes; these are those axes evaluated:
|
||||
* --background-color high/medium/low #fff / #f9f9f9 / #f5f5f5 (dark #222 / #282828 / #2c2c2c)
|
||||
* --text-color high/medium #404040 / #808080 (dark #bfbfbf / #7f7f7f)
|
||||
* --border-color high/medium #ccc / #ddd (dark #555 / #444)
|
||||
* The canvas and the card are both --background-color-high: bootstrap is flat and lets the
|
||||
* border carry the structure. panel2 is its --background-color-low, the surface it stripes
|
||||
* tables and hovers rows with.
|
||||
*
|
||||
* Where this deviates: bootstrap's semantic colours do not clear AA on bootstrap's own
|
||||
* surfaces (on --fs-panel2, success 2.73:1, warn 1.61:1, error 3.65:1, primary 4.22:1; in dark
|
||||
* error 3.44:1 and success 4.44:1), and
|
||||
* every palette here is held to 4.5:1 on all three because the export tier is what other
|
||||
* people's apps print text in. So each is taken from the step of bootstrap's own ramp that
|
||||
* clears it where one exists, and otherwise keeps hue and saturation while the value moves
|
||||
* until it clears 4.95:1. Warn is the only large move: no yellow readable as text on white is
|
||||
* still that yellow.
|
||||
*
|
||||
* Bootstrap's dark header gradient is not here: the chrome reads --fs-panel, so a palette
|
||||
* cannot give the bar its own colour — that would need a chrome token pair, which is a change
|
||||
* to the chrome, not a colourway. */
|
||||
:root[data-palette="bootstrap"] {
|
||||
/* LIGHT */
|
||||
--fs-bg-base: #fff;
|
||||
--fs-panel-base: #fff;
|
||||
--fs-panel2-base: #f5f5f5;
|
||||
--fs-border-base: #ccc;
|
||||
/* The ink is the one place this colourway leaves bootstrap's own values behind, the same
|
||||
* decision the default palette made: its #404040 body and #6a6a6a muted tier measure
|
||||
* 10.4:1 and 5.4:1 on white, and the muted one carries every field title. Matched to the
|
||||
* default palette's light ramp ratio for ratio (15.7 / 11.7 / 10.0), in neutral greys, so
|
||||
* what is copied is the hue and not the readability. */
|
||||
--fs-text: #232323;
|
||||
--fs-dim: #383838;
|
||||
--fs-faint: #424242;
|
||||
/* --primary-color-medium; -high (#1976d2) measured 4.22:1 on --fs-panel2 */
|
||||
--fs-accent-base: #1564c0;
|
||||
--fs-track: #eee;
|
||||
--fs-good-base: #007936; /* --success-color-low */
|
||||
--fs-warn-base: #826706; /* #efbd0b darkened; 1.61:1 as text is not a rounding error */
|
||||
--fs-danger-base: #d00000; /* --error-color-low */
|
||||
/* ink ON the fills above — white clears AA on all four: 5.81/5.54/5.40/5.70 */
|
||||
--fs-on-accent: #fff;
|
||||
--fs-on-good: #fff;
|
||||
--fs-on-warn: #fff;
|
||||
--fs-on-danger: #fff;
|
||||
}
|
||||
:root[data-palette="bootstrap"][data-darkmode="true"] {
|
||||
/* DARK */
|
||||
--fs-bg-base: #222;
|
||||
--fs-panel-base: #282828;
|
||||
/* bootstrap's own dark --background-color-low (#2c2c2c) sits 0.016 from --fs-panel, under
|
||||
* the 0.02 the ramp check wants, so an app asking high/-low for a gradation gets one colour
|
||||
* twice; #303030 is 0.031. Its light pair is 0.039 apart, so the same check catches this in
|
||||
* the theme this palette is named after. */
|
||||
--fs-panel2-base: #303030;
|
||||
--fs-border-base: #444;
|
||||
--fs-text: #bfbfbf;
|
||||
/* Bootstrap's dark has no third ink, so the two quiet tiers are this palette's own and AA
|
||||
* decides where the fainter one sits: the export tier's -low follows --fs-faint, and on a
|
||||
* tinted --fs-panel2 #969696 measures 4.46:1, under the floor for a name apps print text
|
||||
* in. #9a9a9a is the first step that clears it, so the floor pins --fs-faint and the step
|
||||
* between the tiers comes from above (--fs-dim moves up by the 12 channel steps the
|
||||
* hicontrast dark ramp uses). Both are already a deviation, and one step more is cheaper
|
||||
* than collapsing --text-color-medium and -low onto one colour. */
|
||||
--fs-dim: #a6a6a6;
|
||||
--fs-faint: #9a9a9a;
|
||||
--fs-accent-base: #53a4c2;
|
||||
--fs-accent-soft: color-mix(in srgb, var(--fs-accent) 15%, transparent);
|
||||
--fs-track: #333;
|
||||
--fs-good-base: #1aaf7b;
|
||||
--fs-warn-base: #aa9968;
|
||||
--fs-danger-base: #dd807e;
|
||||
/* dark ink: these fills are light, and bootstrap's own --on-*-color in dark is likewise its
|
||||
* --background-color-high. #222 gives 5.65/5.65/5.66/5.65. */
|
||||
--fs-on-accent: #222;
|
||||
--fs-on-good: #222;
|
||||
--fs-on-warn: #222;
|
||||
--fs-on-danger: #222;
|
||||
}
|
||||
/* ---- 2020 — the OpenWrt 2020 theme's colourway ----
|
||||
*
|
||||
* `luci-theme-openwrt-2020` is one colour scheme and no dark mode: the OpenWrt CI cyan
|
||||
* (#00B5E2) on the deep navy (#002B49), white content, and three semantic colours. This
|
||||
* palette carries that identity onto footstrap's surfaces.
|
||||
*
|
||||
* The cyan is the whole identity and is unreadable as text on white (2.09:1 against the 4.5:1
|
||||
* the export tier wants), so the LIGHT mode keeps the hue and darkens it while the DARK mode,
|
||||
* whose surfaces are the navy the cyan was designed against, carries it near its own value.
|
||||
* That split is the point of the pair.
|
||||
*
|
||||
* The three semantic colours get the same treatment: on white, 2020's green is 2.28:1 and its
|
||||
* amber 3.42:1, while its red clears AA at 5.25:1 and is the one kept close to the original.
|
||||
*
|
||||
* The navy is not the chrome here. In 2020 it is the header and the sidebar, but the chrome
|
||||
* reads --fs-panel, so in dark mode the navy is the CANVAS and the chrome sits on it. */
|
||||
:root[data-palette="2020"] {
|
||||
/* LIGHT — white content, the CI cyan darkened until it can be read on it */
|
||||
--fs-bg-base: #fff;
|
||||
--fs-panel-base: #fff;
|
||||
--fs-panel2-base: #eef4f8;
|
||||
--fs-border-base: #c3d2dd;
|
||||
/* navy-tinted neutrals rather than grey: the ink belongs to the same scheme as the accent */
|
||||
--fs-text: #10202b;
|
||||
--fs-dim: #2c4150;
|
||||
--fs-faint: #3d5566;
|
||||
/* #00B5E2 held at hue, taken down until it reads: 5.89:1 on white against its own 2.09:1 */
|
||||
--fs-accent-base: #036c92;
|
||||
--fs-track: #e3ebf1;
|
||||
--fs-good-base: #276e2a; /* #5CB85C darkened; 2.28:1 as text is not a rounding error */
|
||||
--fs-warn-base: #8a5a00; /* #C80, same move */
|
||||
--fs-danger-base: #c1121f; /* #C11 is 5.25:1 already — the one that stays where it was */
|
||||
/* ink ON the fills above — white clears AA on all four */
|
||||
--fs-on-accent: #fff;
|
||||
--fs-on-good: #fff;
|
||||
--fs-on-warn: #fff;
|
||||
--fs-on-danger: #fff;
|
||||
}
|
||||
:root[data-palette="2020"][data-darkmode="true"] {
|
||||
/* DARK — 2020's own scheme: the navy is the canvas and the cyan is nearly untouched */
|
||||
--fs-bg-base: #002b49;
|
||||
--fs-panel-base: #0a3a58;
|
||||
--fs-panel2-base: #0e4362;
|
||||
--fs-border-base: #1d5a7d;
|
||||
--fs-text: #e6f1f7;
|
||||
--fs-dim: #b8cfdd;
|
||||
--fs-faint: #9dbccd;
|
||||
/* the CI cyan, one step up so it clears AA on the lightest of the three surfaces too */
|
||||
--fs-accent-base: #35c6ea;
|
||||
--fs-accent-soft: color-mix(in srgb, var(--fs-accent) 15%, transparent);
|
||||
--fs-track: #123c56;
|
||||
--fs-good-base: #74cc74; /* #5CB85C lifted for the same reason */
|
||||
--fs-warn-base: #eab346;
|
||||
--fs-danger-base: #ff9d9d;
|
||||
/* these fills are LIGHT, so the ink is the canvas navy itself */
|
||||
--fs-on-accent: #002b49;
|
||||
--fs-on-good: #002b49;
|
||||
--fs-on-warn: #002b49;
|
||||
--fs-on-danger: #002b49;
|
||||
}
|
||||
/* ---- forum — the OpenWrt forum's Discourse colourway (opt-in) ----
|
||||
*
|
||||
* Sampled from forum.openwrt.org's own `getComputedStyle(document.documentElement)`, one read
|
||||
* per colour scheme: LIGHT --primary #222 (ink) / --secondary #fff (page) / --tertiary #08c
|
||||
* (accent) / --quaternary and --danger both #e45735 / --success #090 / --highlight #ffff4d;
|
||||
* DARK --primary #ddd / --secondary #222 / --tertiary #0f82af / --danger #e45735 (unchanged
|
||||
* from light) / --success #1ca551 / --highlight #a87137. Discourse names quaternary and
|
||||
* danger as one colour in light and two in dark (#c14924); footstrap has no fifth semantic
|
||||
* slot, so the dark quaternary is not carried — --fs-danger reads the site's own --danger.
|
||||
*
|
||||
* The header bar's navy (rgb(0,43,73) = #002b49) is not here: it is the forum's masthead, not
|
||||
* its dark canvas — --secondary is #222 in BOTH the forum's own light and dark schemes (ink
|
||||
* and page swap places, the page itself never turns navy). 2020's dark canvas is navy because
|
||||
* that theme has no dark scheme of its own to sample; forum does, and it says #222. The chrome
|
||||
* reads --fs-panel regardless (2020's own note, above), so the bar could not carry it anyway.
|
||||
*
|
||||
* None of the six sampled colours clears 4.5:1 as TEXT on the surface its own scheme pairs it
|
||||
* with — Discourse checks contrast for its own use (a filled pill, an icon), not for the
|
||||
* export tier every app prints text in — so every one of them is moved the way 2020's cyan
|
||||
* was: hue and saturation held, lightness walked until the ratio clears. --fs-highlight has no
|
||||
* footstrap analogue (it marks a search hit, not a status) and the sampled #ffff4d is a
|
||||
* background wash — 1.07:1 on white — so it fills the one status slot forum's own scheme has
|
||||
* no colour for, --fs-warn, exactly as its LIGHTNESS says: the brightest of the four before the
|
||||
* move, still the one furthest from AA after it. */
|
||||
:root[data-palette="forum"] {
|
||||
/* LIGHT — the forum's own page, exactly: white canvas, near-black ink */
|
||||
--fs-bg-base: #fff;
|
||||
--fs-panel-base: #fff;
|
||||
--fs-panel2-base: #f0f0f0;
|
||||
--fs-border-base: #ddd;
|
||||
--fs-text: #222;
|
||||
--fs-dim: #3d3d3d;
|
||||
--fs-faint: #4a4a4a;
|
||||
/* --tertiary #08c measures 3.89:1 on white; #0074ad held the hue at 5.12:1 there but
|
||||
* only 4.49:1 on --fs-panel2, under the 4.5:1 floor the export tier holds every surface to;
|
||||
* #0073ac holds it at 5.19:1 on white and 4.55:1 on --fs-panel2 */
|
||||
--fs-accent-base: #0073ac;
|
||||
--fs-track: #eee;
|
||||
/* --success #090 measured 3.78:1, #008000 5.14:1; --quaternary/--danger #e45735
|
||||
* measured 3.68:1, #c63c1b 5.17:1; --highlight #ffff4d measured 1.07:1 as text, #717100
|
||||
* 5.17:1 — see the block comment above for why highlight fills warn */
|
||||
--fs-good-base: #008000;
|
||||
--fs-warn-base: #717100;
|
||||
--fs-danger-base: #c63c1b;
|
||||
/* white on the fills above: 5.19/5.14/5.17/5.17 */
|
||||
--fs-on-accent: #fff;
|
||||
--fs-on-good: #fff;
|
||||
--fs-on-warn: #fff;
|
||||
--fs-on-danger: #fff;
|
||||
}
|
||||
:root[data-palette="forum"][data-darkmode="true"] {
|
||||
/* DARK — the forum's own dark scheme: #222 canvas, #ddd ink, both exactly as sampled */
|
||||
--fs-bg-base: #222;
|
||||
--fs-panel-base: #262626;
|
||||
--fs-panel2-base: #2e2e2e;
|
||||
--fs-border-base: #3a3a3a;
|
||||
--fs-text: #ddd;
|
||||
--fs-dim: #a3a3a3;
|
||||
--fs-faint: #969696;
|
||||
/* --tertiary #0f82af measured 3.66:1 on --fs-bg and 3.12:1 on --fs-panel2, both under the
|
||||
* 4.5:1 the export tier wants for a colour printed as text; #13a8e3 holds the hue at
|
||||
* 5.86:1 on --fs-bg and 5.00:1 on --fs-panel2 */
|
||||
--fs-accent-base: #13a8e3;
|
||||
--fs-accent-soft: color-mix(in srgb, var(--fs-accent) 15%, transparent);
|
||||
--fs-track: #333;
|
||||
/* --success #1ca551 measured 4.24:1 on --fs-panel2, #1fb65a 5.11:1; --danger #e45735
|
||||
* measured 3.69:1, #eb8066 5.05:1; --highlight #a87137 measured 3.29:1, #c99259 5.00:1 —
|
||||
* same reasoning as the light block for why highlight fills warn */
|
||||
--fs-good-base: #1fb65a;
|
||||
--fs-warn-base: #c99259;
|
||||
--fs-danger-base: #eb8066;
|
||||
/* dark ink: these fills are light, and #222 (= --fs-bg-base) gives 5.86/5.98/5.86/5.92 */
|
||||
--fs-on-accent: #222;
|
||||
--fs-on-good: #222;
|
||||
--fs-on-warn: #222;
|
||||
--fs-on-danger: #222;
|
||||
/* The masthead, and the one place the forum's navy belongs. rgb(0,43,73) is what
|
||||
forum.openwrt.org paints its header with in its DARK scheme — measured live; its light
|
||||
scheme has a white header (--header_background #fff, ink #333), which is what this
|
||||
palette's light half already gives, so the navy is declared here and only here.
|
||||
A flat fill, like --fs-bar-bg everywhere (02-tokens.css): the bar's own ink (#ddd)
|
||||
measures 10.7:1 on it and its dimmed ink (#a3a3a3) 5.8:1. */
|
||||
--fs-bar-bg: #002b49;
|
||||
}
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
@layer tokens {
|
||||
/* Static twins for every token whose value is a color-mix(), for a browser that has none.
|
||||
*
|
||||
* Last in the tokens layer on purpose: it has to outrank 02-tokens.css AND the per-palette
|
||||
* definitions in 03-palettes.css, and directory order is source order (build-css.sh).
|
||||
*
|
||||
* Why a whole file rather than a fallback declaration in front of each color-mix(): a custom
|
||||
* property keeps whatever token stream it is given, so the failure is deferred to the point of USE
|
||||
* — `background: var(--fs-good-soft)` becomes invalid at computed-value time and computes to
|
||||
* `unset`, which is `initial` for a non-inherited property. IACVT does not fall back to an earlier
|
||||
* declaration in the same block, so the two-declaration trick that works for `background:
|
||||
* color-mix(…)` written literally does nothing for a token. 36 tokens are affected; without this
|
||||
* block a browser below the floor paints borders in currentcolor and loses every soft surface.
|
||||
*
|
||||
* color-mix() lands in Chrome 111, Firefox 113 and Safari 16.2 (all 2022-2023). See docs/css.md
|
||||
* for the theme's browser floor and which feature sets it.
|
||||
*
|
||||
* The rules: a tint over transparent degrades to `transparent` — an absent surface never lowers
|
||||
* contrast, while a solid version of the same colour under its own text does. A hairline degrades
|
||||
* to the solid colour it is a fraction of. A focus ring degrades to the -solo ring, which is
|
||||
* already color-mix-free, because an invisible focus ring is an accessibility regression rather
|
||||
* than a cosmetic one. */
|
||||
@supports not (color: color-mix(in srgb, red 50%, transparent)) {
|
||||
:root {
|
||||
/* tints: absent, not solid */
|
||||
--fs-accent-soft: transparent;
|
||||
--fs-good-soft: transparent;
|
||||
--fs-warn-soft: transparent;
|
||||
--fs-danger-soft: transparent;
|
||||
--fs-accent-fill: transparent;
|
||||
--fs-good-fill: transparent;
|
||||
--fs-warn-fill: transparent;
|
||||
--fs-danger-fill: transparent;
|
||||
|
||||
/* hairlines: the solid colour they are a fraction of */
|
||||
--fs-accent-line: var(--fs-accent);
|
||||
--fs-good-line: var(--fs-good);
|
||||
--fs-warn-line: var(--fs-warn);
|
||||
--fs-danger-line: var(--fs-danger);
|
||||
--fs-accent-line-hi: var(--fs-accent);
|
||||
--fs-good-line-hi: var(--fs-good);
|
||||
--fs-warn-line-hi: var(--fs-warn);
|
||||
--fs-danger-line-hi: var(--fs-danger);
|
||||
|
||||
/* the two rings, restated: -soft and -fill are transparent above, and a ring nobody can
|
||||
* see is worse than a heavy one. -solo is already color-mix-free and measured. */
|
||||
--fs-focus-ring: var(--fs-focus-ring-solo);
|
||||
--fs-focus-ring-invalid: 0 0 0 2px var(--fs-panel), 0 0 0 5px var(--fs-danger);
|
||||
|
||||
--background-color-medium: var(--fs-panel2);
|
||||
|
||||
/* the scrim over an uploaded photo: --fs-photo-dim is a percentage this cannot apply, so
|
||||
* take the fixed dialog scrim. Losing it entirely would leave login text over a photo. */
|
||||
--fs-photo-scrim: var(--fs-scrim);
|
||||
|
||||
/* placeholder ink: the quietest ink the palette states outright. Below the floor the
|
||||
* hint is back to reading like a value, which is the pre-0.14.9 look and still the
|
||||
* safer degradation — an unresolvable token takes `color` down to `unset`, and an
|
||||
* inherited near-black placeholder over a light field beats an unstyled one. */
|
||||
--fs-placeholder: var(--fs-faint);
|
||||
|
||||
/* export tier — third-party apps read these, so they must resolve to something.
|
||||
* -medium keeps the hue, -low degrades to the dim text colour it was mixed toward. */
|
||||
--border-color-high: var(--fs-border);
|
||||
--border-color-low: var(--fs-border);
|
||||
--primary-color-medium: var(--fs-accent);
|
||||
--primary-color-low: var(--fs-dim);
|
||||
--error-color-medium: var(--fs-danger);
|
||||
--error-color-low: var(--fs-dim);
|
||||
--success-color-medium: var(--fs-good);
|
||||
--success-color-low: var(--fs-dim);
|
||||
--warn-color-medium: var(--fs-warn);
|
||||
--warn-color-low: var(--fs-dim);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,115 +0,0 @@
|
||||
@layer base {
|
||||
/* Element reset (Meyer, trimmed to what a LuCI view can emit). */
|
||||
|
||||
/* scroll-margin-top: an anchor jump must clear the sticky bar or it lands underneath it
|
||||
* (WCAG 2.2 SC 2.4.11). The token, never a literal — the bar is 46px. */
|
||||
*, *::before, *::after {
|
||||
scroll-margin-top: var(--fs-bar-h);
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
border: 0;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
abbr[title], acronym[title] {
|
||||
border-bottom: 1px dotted;
|
||||
font-weight: inherit;
|
||||
cursor: help;
|
||||
}
|
||||
|
||||
table {
|
||||
border-collapse: collapse;
|
||||
border-spacing: 0;
|
||||
}
|
||||
|
||||
/* `hidden` is how a VIEW says an element is not there, and the only way available to code that
|
||||
* ships no stylesheet. The UA gives it `display: none` at the weakest possible strength, so any
|
||||
* `display` a theme sets on a class beats it and the element paints anyway: measured here on
|
||||
* `.tr` (table-row), `.td` (table-cell), `ul.nav > li` (block), `.cbi-page-actions` (flex) and
|
||||
* `.ifacebox` (inline-flex).
|
||||
*
|
||||
* The flag is the point, not a workaround for a layer mistake: this must outrank every display
|
||||
* in tokens/base/theme/page at once, including the id-specific ones in the page layer, and it
|
||||
* has to keep doing so for rules not written yet. `until-found` is excluded
|
||||
* because there `display: none` would break the find-in-page reveal the value exists for. */
|
||||
[hidden]:not([hidden="until-found"]) { display: none !important; }
|
||||
|
||||
html {
|
||||
font-size: 100%;
|
||||
height: 100%;
|
||||
}
|
||||
|
||||
/* :focus-visible, not :focus — the ring is for the keyboard, and the UA heuristic keeps it off a
|
||||
* mouse click. A 1px dotted outline is near-invisible on a dark panel, and it was the only focus
|
||||
* indicator generic links had. */
|
||||
a:focus-visible {
|
||||
outline: 2px solid var(--fs-accent);
|
||||
outline-offset: 2px;
|
||||
}
|
||||
|
||||
sub, sup {
|
||||
font-size: 75%;
|
||||
line-height: 0;
|
||||
position: relative;
|
||||
vertical-align: baseline;
|
||||
}
|
||||
|
||||
sup {
|
||||
top: -.5em;
|
||||
}
|
||||
|
||||
sub {
|
||||
bottom: -.25em;
|
||||
}
|
||||
|
||||
/* font-size: theme/60-inputs.css (the control-typography rule + `option`) — absorbed */
|
||||
button,
|
||||
input,
|
||||
select,
|
||||
option,
|
||||
textarea {
|
||||
margin: 0;
|
||||
box-sizing: border-box;
|
||||
vertical-align: baseline;
|
||||
}
|
||||
|
||||
button,
|
||||
input[type="button"],
|
||||
input[type="reset"],
|
||||
input[type="submit"] {
|
||||
cursor: pointer;
|
||||
appearance: button;
|
||||
word-break: break-all;
|
||||
}
|
||||
|
||||
/* disabled-opacity fade: 30-forms.css, same elements + pointer-events/cursor */
|
||||
|
||||
input[type="search"] {
|
||||
appearance: textfield;
|
||||
/* no box-sizing: content-box — it contradicts the universal border-box above, and the
|
||||
* theme sizes fields by padding, so a search box comes out ~22px too wide */
|
||||
}
|
||||
|
||||
input[type="search"]::-webkit-search-decoration {
|
||||
appearance: none;
|
||||
}
|
||||
|
||||
textarea {
|
||||
overflow: auto;
|
||||
vertical-align: top;
|
||||
font-family: var(--fs-font-mono);
|
||||
}
|
||||
|
||||
/* LuCI's .control-group is bootstrap's JOINED input-group: the trailing button pulled back over
|
||||
* the input so their borders coincided, with its left corners squared to match. This theme does
|
||||
* not join controls — every button takes the full token radius from a later layer, so the
|
||||
* squared corners never apply while the pull-back still does and the button's rounded corner
|
||||
* sits on the input's (issue #7). Separate controls with a real gap instead.
|
||||
*
|
||||
* The password reveal is the one group that IS joined, and theme/60-inputs.css builds that seam
|
||||
* itself (one border around the group, `gap: 0`). */
|
||||
.control-group {
|
||||
display: inline-flex;
|
||||
gap: var(--fs-space-2);
|
||||
}
|
||||
}
|
||||
@@ -1,166 +0,0 @@
|
||||
@layer base {
|
||||
/* The body box, links, and the type scale a view inherits from plain markup.
|
||||
* body background/padding/font-family: theme/20-shell.css — absorbed.
|
||||
* Every size and gutter here reads the scale in 02-tokens.css rather than stating a literal. */
|
||||
body {
|
||||
font-size: var(--fs-type);
|
||||
font-weight: var(--fs-weight-normal);
|
||||
/* unitless: it inherits as a FACTOR, so a 20px heading gets 30px of leading instead of the
|
||||
* flat length that would clip it */
|
||||
line-height: var(--fs-leading);
|
||||
color: var(--fs-text);
|
||||
min-height: 100%;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
/* gutter, not `overflow-y: scroll`: the same no-reflow guarantee without a dead scrollbar
|
||||
* down every short page */
|
||||
scrollbar-gutter: stable;
|
||||
}
|
||||
|
||||
a {
|
||||
color: var(--fs-accent);
|
||||
text-decoration: none;
|
||||
line-height: inherit;
|
||||
font-weight: inherit;
|
||||
}
|
||||
|
||||
a:hover {
|
||||
color: var(--fs-accent);
|
||||
text-decoration: underline;
|
||||
}
|
||||
|
||||
.nowrap:not(span) {
|
||||
/* :not(span) — a badge must be free to wrap on a narrow screen, and nowrap
|
||||
defeats every other width constraint on it */
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
p,
|
||||
.cbi-map-descr,
|
||||
.cbi-section-descr,
|
||||
.table .tr.cbi-section-table-descr .th {
|
||||
font-size: var(--fs-type);
|
||||
font-weight: var(--fs-weight-normal);
|
||||
margin-bottom: var(--fs-space-2);
|
||||
/* prose, so no orphans: a single trailing word on its own line reads as a rendering fault.
|
||||
* `pretty`, not `balance` — balance is capped at a few lines and re-flows the whole block,
|
||||
* which is for headings. An unsupporting browser ignores it. */
|
||||
text-wrap: pretty;
|
||||
}
|
||||
|
||||
p small {
|
||||
font-size: var(--fs-type-xs);
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
|
||||
/* The heading ramp lives in theme/45-misc.css — absorbed whole (weights, sizes, ink);
|
||||
* theme/30-tables.css owns `legend`. Only the `<h_ small>` treatment remains here. */
|
||||
|
||||
/* one rule for every `<h_ small>`, relative so it tracks whatever step its heading sits on */
|
||||
h1 small,
|
||||
h2 small,
|
||||
h3 small,
|
||||
h4 small,
|
||||
h5 small,
|
||||
h6 small {
|
||||
font-size: .7em;
|
||||
font-weight: var(--fs-weight-normal);
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
|
||||
ul, ol {
|
||||
margin: 0 0 var(--fs-space-4) var(--fs-space-6);
|
||||
}
|
||||
|
||||
ul ul,
|
||||
ul ol,
|
||||
ol ol,
|
||||
ol ul {
|
||||
margin-bottom: 0;
|
||||
}
|
||||
|
||||
ul {
|
||||
list-style: disc;
|
||||
}
|
||||
|
||||
ol {
|
||||
list-style: decimal;
|
||||
}
|
||||
|
||||
li {
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
|
||||
dl {
|
||||
margin-bottom: var(--fs-space-4);
|
||||
}
|
||||
|
||||
dl dt {
|
||||
font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
dl dd {
|
||||
margin-inline-start: var(--fs-space-2);
|
||||
}
|
||||
|
||||
hr {
|
||||
margin: var(--fs-space-5) 0;
|
||||
border: 0;
|
||||
border-bottom: var(--fs-hairline);
|
||||
}
|
||||
|
||||
strong {
|
||||
font-style: inherit;
|
||||
font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
em {
|
||||
font-style: italic;
|
||||
font-weight: inherit;
|
||||
line-height: inherit;
|
||||
}
|
||||
|
||||
small { font-size: var(--fs-type) }
|
||||
|
||||
address {
|
||||
display: block;
|
||||
margin-bottom: var(--fs-space-4);
|
||||
}
|
||||
|
||||
/* no shared padding: both members set their own below (code a chip's inset, pre a block's) */
|
||||
code, pre {
|
||||
font-family: var(--fs-font-mono);
|
||||
font-size: var(--fs-type);
|
||||
border-radius: var(--fs-radius-sm);
|
||||
}
|
||||
|
||||
code {
|
||||
/* panel2 (6.45:1), not a border-level surface: --fs-text on the latter is 4.40:1 in dark,
|
||||
* under AA */
|
||||
background-color: var(--fs-panel2);
|
||||
color: var(--fs-text);
|
||||
padding: 1px var(--fs-space-1);
|
||||
/* task 0162: a WireGuard public key (`admin/status/wireguard`, one 44-char base64 run, no
|
||||
* space or hyphen anywhere in it) sits inside an inline `<code>` with no width of its own —
|
||||
* `white-space` stays `normal` (inherited), so the run never finds a space to wrap at and
|
||||
* measured 64px past the content column at 320px. `overflow-wrap: anywhere`, the same
|
||||
* escape hatch every other opaque, user-supplied token in this sheet already carries
|
||||
* (a MAC in pages/60-assoclist.css, a hostname in pages/10-login.css): it only ever fires
|
||||
* once a line would otherwise overflow, so a short inline snippet that already fits wraps
|
||||
* nowhere differently. */
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
|
||||
pre {
|
||||
--border-color: color-mix(in srgb, var(--fs-border) 15%, transparent);
|
||||
|
||||
background-color: var(--fs-panel2);
|
||||
display: block;
|
||||
padding: var(--fs-space-2);
|
||||
margin: 0 0 var(--fs-space-4);
|
||||
border: 1px solid var(--border-color);
|
||||
border-radius: var(--fs-radius-sm);
|
||||
white-space: pre-wrap;
|
||||
word-wrap: break-word;
|
||||
}
|
||||
}
|
||||
@@ -1,275 +0,0 @@
|
||||
@layer base {
|
||||
/* Forms: input types, the .cbi-value row layout, and the focus/disabled/
|
||||
* readonly/invalid states shared by every CBI widget. */
|
||||
fieldset {
|
||||
margin-bottom: var(--fs-space-2);
|
||||
padding-top: var(--fs-space-2);
|
||||
}
|
||||
|
||||
/* size: theme/30-tables.css (`legend`) — absorbed */
|
||||
fieldset legend {
|
||||
display: block;
|
||||
line-height: 1;
|
||||
color: var(--fs-text);
|
||||
padding-top: var(--fs-space-5);
|
||||
}
|
||||
|
||||
/* Control typography stays in BASE: moved to the theme layer, a bare-element rule out-ranks
|
||||
* every classed base refinement regardless of specificity, and the firewall's zone badges grew
|
||||
* from 10.8 to 13px. In base, classed rules beat it on specificity, which is the contract they
|
||||
* were written against. `select` is not a member — its face, size and leading live in
|
||||
* 60-inputs.css. */
|
||||
label,
|
||||
input,
|
||||
button {
|
||||
font-family: var(--fs-font-sans);
|
||||
font-size: var(--fs-type);
|
||||
font-weight: var(--fs-weight-normal);
|
||||
line-height: normal;
|
||||
}
|
||||
|
||||
.cbi-value {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
margin-bottom: var(--fs-space-4);
|
||||
align-items: baseline;
|
||||
}
|
||||
|
||||
.cbi-value-field {
|
||||
/* logical, not margin-left: this is the gap AFTER the label column, and LuCI ships four RTL
|
||||
* languages (ar/fa/he/ur). Identical to margin-left while nothing in openwrt/luci stamps
|
||||
* dir=rtl, so it costs nothing and is already correct if one ever does. */
|
||||
margin-inline-start: var(--fs-space-5);
|
||||
flex: 1;
|
||||
/* a flex item will not shrink below min-content by default, so a nested table or one long
|
||||
* unbreakable value pushes the whole row out of the card */
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
/* size + ink: theme/60-inputs.css (`.cbi-value-title`) — absorbed. Left: the label
|
||||
* column's geometry, which theme does not touch. */
|
||||
.cbi-value label.cbi-value-title {
|
||||
/* the nudge that lands the label's first baseline on the field's, tuned for the unitless
|
||||
* leading in 20-typography.css */
|
||||
padding-top: var(--fs-space-1);
|
||||
/* 180px is a column WIDTH, not a rhythm — what fits LuCI's longest option labels beside a
|
||||
* field — so it is deliberately not on the 4px step scale */
|
||||
flex: 0 0 180px;
|
||||
/* `end`, not `right`: the label is aligned TOWARDS its field, which is a logical intent.
|
||||
* Not the same as base/95-luci.css's `.left/.right/.center`, which are LuCI's forcing
|
||||
* utilities — a class named `right` means right in any direction. Never sweep those onto
|
||||
* start/end. */
|
||||
text-align: end;
|
||||
/* theme/90-responsive.css restates `flex: 1 1 100%` under 767px (label above field), and a
|
||||
* PERCENTAGE flex-basis is still a "specified size suggestion" only once it is smaller than
|
||||
* the automatic (content) minimum — with no `min-width` stated there or here, a label whose
|
||||
* text has too few break points renders at its own min-content instead of the row's width, a
|
||||
* flex item's automatic minimum size doing exactly what it always does. Sweep-measured on
|
||||
* ssclash's settings form at 320px: a Russian label rendered 320px wide inside a 254-276px
|
||||
* row (Compact/Normal/Large), the section clipped 33-50px with no scroller to reach the rest,
|
||||
* 0 with the English string in the same box. Reproduced locally the same shape with a
|
||||
* synthetic unbroken run in the gallery's own fixture (docs/gallery.html) — real RU option
|
||||
* text with normal word breaks does not need to hit this floor at all once the item can
|
||||
* shrink to the row's own width instead of its content's.
|
||||
*
|
||||
* `min-width: 0` here, not in theme/90-responsive.css: that file restates `flex`, never
|
||||
* `min-width`, so a value stated on the desktop rule survives the later layer's flex-basis
|
||||
* change untouched — the cascade only overrides the PROPERTIES a later rule actually sets. */
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
.cbi-value > .cbi-section,
|
||||
.cbi-value > .cbi-tblsection {
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
label > input[type="checkbox"],
|
||||
label > input[type="radio"] {
|
||||
vertical-align: text-top;
|
||||
margin: 0;
|
||||
}
|
||||
|
||||
label[for] {
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
/* The shared field box (the 210px x control-height default, #localtime's widening, and the
|
||||
* per-widget escapes: file, button types, checkbox/radio, .cbi-select, readonly, the
|
||||
* cell-filling widths) lives in theme/60-inputs.css — absorbed whole. The escapes had to move
|
||||
* with the box: each beat it here in-layer, and left behind they would lose to a theme rule by
|
||||
* layer whatever their specificity. */
|
||||
|
||||
.cbi-dynlist {
|
||||
height: auto;
|
||||
/* min-height: theme/60-inputs.css — absorbed */
|
||||
display: inline-flex;
|
||||
flex-direction: column;
|
||||
}
|
||||
|
||||
/* item paint: theme/60-inputs.css — absorbed. Left: the drag-and-drop machinery
|
||||
* UIDynamicList needs. */
|
||||
.cbi-dynlist > .item {
|
||||
margin-bottom: var(--fs-space-1);
|
||||
padding: var(--fs-space-1) 2em var(--fs-space-1) var(--fs-space-2);
|
||||
position: relative;
|
||||
pointer-events: auto; /* needed for drag-and-drop in UIDynamicList */
|
||||
overflow: hidden;
|
||||
word-break: break-all;
|
||||
cursor: move; /* drag-and-drop */
|
||||
user-select: text; /* text selection in drag-and-drop */
|
||||
}
|
||||
|
||||
/* display/padding/border + radius + × ink: theme/60-inputs.css (the bare `.item::after`
|
||||
* plate + its dynlist refinement) — absorbed. Left: what pins the plate to the chip. */
|
||||
.cbi-dynlist > .item::after {
|
||||
content: "×";
|
||||
position: absolute;
|
||||
align-items: center;
|
||||
top: -1px;
|
||||
inset-inline-end: -1px;
|
||||
bottom: -1px;
|
||||
font-weight: var(--fs-weight-bold);
|
||||
pointer-events: auto;
|
||||
}
|
||||
|
||||
/* indication line for drag-and-drop in UIDynamicList*/
|
||||
.cbi-dynlist > .item.drag-over {
|
||||
border-top: 1px solid var(--fs-text);
|
||||
}
|
||||
|
||||
/* Make item being dragged in UIDynamicList partially transparent*/
|
||||
.cbi-dynlist > .item.dragging {
|
||||
opacity: .5;
|
||||
}
|
||||
|
||||
/* prevent pointer changing when over the span element in UIDynamicList */
|
||||
.cbi-dynlist > .item > span {
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
.cbi-dynlist > .add-item {
|
||||
display: flex;
|
||||
}
|
||||
|
||||
/* indication line for drag-and-drop in UIDynamicList*/
|
||||
.cbi-dynlist > .add-item > .cbi-input-text.drag-over {
|
||||
border-top: 1px solid var(--fs-text);
|
||||
}
|
||||
|
||||
/* indication line for drag-and-drop in UIDynamicList*/
|
||||
.cbi-dynlist > .add-item > .cbi-button-add.drag-over {
|
||||
border-top: 1px solid var(--fs-text);
|
||||
}
|
||||
|
||||
.cbi-dynlist > .add-item > input,
|
||||
.cbi-dynlist > .add-item > button {
|
||||
/* flex: theme/60-inputs.css — absorbed */
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
/* the same one-line control height, so a toggle lines up with the field above it */
|
||||
.cbi-value-field > .cbi-checkbox,
|
||||
.cbi-value-field > div > .cbi-radio {
|
||||
height: var(--fs-control-h);
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
}
|
||||
|
||||
.cbi-radio {
|
||||
cursor: pointer;
|
||||
gap: var(--fs-space-1);
|
||||
}
|
||||
|
||||
/* .cbi-select lives in theme/60-inputs.css — absorbed whole. Do not re-add an option rule here
|
||||
* either: layer beats specificity, so theme's bare `option` outranks even
|
||||
* `.cbi-select select option:checked`. */
|
||||
|
||||
/* Checkbox/radio drawing: theme/60-inputs.css — absorbed whole (it undoes the generic input
|
||||
* box, which lives there now). */
|
||||
|
||||
/* --fs-placeholder, not --fs-dim: a placeholder carries the option's DEFAULT and must not read
|
||||
* as a value the reader typed (03-palettes.css has the numbers). */
|
||||
::placeholder {
|
||||
color: var(--fs-placeholder);
|
||||
}
|
||||
|
||||
/* Transitions and the focus/hover ring are the theme's one ring token (--fs-focus-ring /
|
||||
* --fs-focus-ring-invalid). A generic glow here rings every clicked button and every hovered
|
||||
* widget in a second, unnamed focus style. */
|
||||
|
||||
input[disabled],
|
||||
button[disabled],
|
||||
select[disabled],
|
||||
textarea[disabled],
|
||||
.cbi-dropdown[disabled]:not(.btn):not(.cbi-button),
|
||||
input[type="checkbox"][disabled]::before,
|
||||
input[type="checkbox"][disabled]::after,
|
||||
input[type="radio"][disabled]::before,
|
||||
input[type="radio"][disabled]::after {
|
||||
opacity: var(--fs-disabled-opacity);
|
||||
pointer-events: none;
|
||||
cursor: default;
|
||||
}
|
||||
|
||||
/* readonly border fade: theme/60-inputs.css — absorbed with the generic box */
|
||||
|
||||
.cbi-optionals,
|
||||
.cbi-section-create {
|
||||
padding: 0 0 var(--fs-space-3) var(--fs-space-3);
|
||||
}
|
||||
|
||||
/* `gap`, not a negative-margin pair: that trick predates flex gap and leaks, the outer -3px
|
||||
* pulling the row into whatever sits beside it */
|
||||
.cbi-section-create {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: var(--fs-space-2);
|
||||
}
|
||||
|
||||
.cbi-section-create > * {
|
||||
flex: 1 1 auto;
|
||||
}
|
||||
|
||||
/* the input's cell-filling width: theme/60-inputs.css — absorbed with the generic box */
|
||||
|
||||
/* .cbi-page-actions paint: theme/55-buttons.css — absorbed. The legacy `.actions` plate has no
|
||||
* theme override, so it stays: some luci-app-* still emits it. */
|
||||
.actions {
|
||||
background: var(--fs-panel2);
|
||||
margin-bottom: var(--fs-space-4);
|
||||
/* a plate, so it takes the card's own gutter on every side */
|
||||
padding: var(--fs-card-pad);
|
||||
border-top: var(--fs-hairline);
|
||||
border-radius: 0 0 var(--fs-radius-lg) var(--fs-radius-lg);
|
||||
text-align: end;
|
||||
}
|
||||
|
||||
/* Physical, mirrored by hand — see `.close` in base/90-widgets.css for why `float` takes no
|
||||
* logical keyword. Unmirrored it contradicts its own container: `.actions` above sets
|
||||
* `text-align: end`, which follows the writing direction, so in RTL the plate aligns its
|
||||
* content one way and the secondary action the other. Measured in a live document at 1400px:
|
||||
* 582px from the reading edge in LTR, 10px in RTL. */
|
||||
.actions .secondary-action,
|
||||
.cbi-page-actions .secondary-action{
|
||||
float: right;
|
||||
}
|
||||
:root[dir="rtl"] .actions .secondary-action,
|
||||
:root[dir="rtl"] .cbi-page-actions .secondary-action { float: left; }
|
||||
|
||||
.actions .secondary-action a,
|
||||
.cbi-page-actions .secondary-action a {
|
||||
line-height: var(--fs-control-h);
|
||||
}
|
||||
|
||||
.actions .secondary-action a:hover,
|
||||
.cbi-page-actions .secondary-action a:hover {
|
||||
text-decoration: underline;
|
||||
}
|
||||
|
||||
.cbi-page-actions > form {
|
||||
display: inline;
|
||||
margin: 0;
|
||||
}
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
@layer base {
|
||||
/* Tables. LuCI builds them out of divs carrying .table/.tr/.th/.td rather than
|
||||
* real table markup, so the display roles have to be assigned by hand. */
|
||||
.tr { display: table-row; }
|
||||
.table[width="33%"], .th[width="33%"], .td[width="33%"] { width: 33%; }
|
||||
.table[width="100%"], .th[width="100%"], .td[width="100%"] { width: 100%; }
|
||||
|
||||
.table {
|
||||
display: table;
|
||||
width: 100%;
|
||||
margin-bottom: var(--fs-space-4);
|
||||
padding: 0;
|
||||
font-size: var(--fs-type);
|
||||
border-collapse: collapse;
|
||||
position: relative;
|
||||
}
|
||||
|
||||
/* No per-cell border-top, and that is a fix rather than an omission: the theme draws a table's
|
||||
* separators on the ROW (theme/30-tables.css), so a cell border here is a second copy of every
|
||||
* separator — and because the cell line is straight and runs to the table's very edge while the
|
||||
* frame is rounded, a square corner cuts across the radius (issue #7). */
|
||||
.table .th, .table .td {
|
||||
display: table-cell;
|
||||
/* middle is deliberate: a cell's content is a mix of text, badges and buttons, and
|
||||
* top-aligning mixed-height rows reads as a layout fault */
|
||||
vertical-align: middle;
|
||||
padding: var(--fs-space-2) var(--fs-space-3);
|
||||
text-align: start;
|
||||
}
|
||||
|
||||
/* An unbreakable value must not leave the card, in ANY .table. Asking what KIND of table it is
|
||||
* first leaves a third-party key/value `<div class="table">` matching nothing, so one unbroken
|
||||
* token — an ICCID, a base64 key, a DUID — holds the column open and pushes the table outside
|
||||
* its card (measured on 3ginfo-lite).
|
||||
*
|
||||
* Not scoped to the phone tier: that leaves a hole where the column is narrow but the WINDOW is
|
||||
* not (with a 130-character token the table escaped its card by 147px at 900px and 279px at
|
||||
* 768px), which is the argument the fit engine is built on — whether something fits is a
|
||||
* property of the content and its column, not of the viewport. The cost is nil: across 8 pages
|
||||
* x 4 widths x 849 text cells nothing else changes.
|
||||
*
|
||||
* `anywhere`, not `break-word`: `break-word` permits the break without reducing the cell's
|
||||
* min-content contribution, so a `display: table` box still cannot shrink below its widest
|
||||
* token and the column stays open — tried, and the table stayed 355px wide in a 346px column.
|
||||
*
|
||||
* That is a CONTAINMENT default, right for every tier with nowhere to put an overflow — a
|
||||
* key/value include, the config table, the Overview meter rows. It is wrong for the one tier
|
||||
* that IS measured: a data table can card, break one column or scroll, so it wants the truth
|
||||
* instead, and theme/30-tables.css gives it `break-word` for as long as it is a table. Do not
|
||||
* unify the two by moving either.
|
||||
*
|
||||
* Set per ROLE: a value may break anywhere, a label breaks at words. `anywhere` costs a
|
||||
* min-content of ONE CHARACTER, which is the point on a value — the column may collapse rather
|
||||
* than push the table out — and the bug it looks like on a header, since an auto-layout table
|
||||
* hands the surplus to whichever column asks loudest and the header row pays: measured on
|
||||
* Processes, `PID` came out as "PI/D" and the header row stood 104px tall, against 54px with
|
||||
* the floor at its longest word (issue #32).
|
||||
*
|
||||
* `break-word` for the label, not `normal`: a header that IS one long token must still break
|
||||
* rather than overflow, it just may not shrink the column below that word. */
|
||||
.table .td { overflow-wrap: anywhere; }
|
||||
.table .th { overflow-wrap: break-word; }
|
||||
|
||||
/* …and the first column is a label too, whichever element it is made of.
|
||||
*
|
||||
* `anywhere` costs a min-content of one character, and auto table layout hands each column its
|
||||
* share by MAX-content, so a two-column key/value table whose value is one enormous token
|
||||
* starves the key column down to that character — measured at 8000 characters of value, the key
|
||||
* column fell from 95px to 55px, and on the reporter's host the header read one glyph per line
|
||||
* (issue #36, on Firefox and Blink alike).
|
||||
*
|
||||
* `break-word` puts the floor back at the longest WORD, the same trade `.th` makes above: the
|
||||
* first column is the row's identity, and it is what you read the table by.
|
||||
*
|
||||
* A carded row is exempt and must be: `.table.fs-stacked .td` (theme/30-tables.css) restates
|
||||
* `anywhere` from a later layer, and once every cell is on its own line there is no
|
||||
* neighbouring column left to starve. */
|
||||
.table .tr > .td:first-child { overflow-wrap: break-word; }
|
||||
|
||||
.table .tr:first-child .th {
|
||||
padding-top: var(--fs-space-2);
|
||||
font-weight: var(--fs-weight-bold);
|
||||
vertical-align: top;
|
||||
}
|
||||
|
||||
/* The empty-table plate: three lines of leading plus the cell inset it sits in, so it keeps the
|
||||
* table's own height when there is nothing to show.
|
||||
*
|
||||
* Out of flow on purpose: a single-cell row in a `display: table` spans only the FIRST column,
|
||||
* so in flow the plate is a narrow box under column one and its sentence becomes that column's
|
||||
* max-content, widening it (275px -> 502px on an empty section). Absolute takes it
|
||||
* out of the column sizing entirely and `inset-inline: 0` spans it across the table.
|
||||
*
|
||||
* WHAT IT MUST NOT DO IS PIN ITSELF TO THE BOTTOM. It used to say `bottom: 0`, which inside the
|
||||
* `position: relative` .table means the bottom of the whole TABLE — the same place as its own row
|
||||
* only while the placeholder is the last row there is. `form.TableSection` renders its `footer`
|
||||
* into a `<tfoot>` AFTER the `<tbody>`, so on every empty section that declares one the plate
|
||||
* printed straight across the totals: measured on luci-app-dockerman's Containers, Images and
|
||||
* Volumes tables (issue #36) as a 1190x35 overlap, the full width of the table, identically on
|
||||
* Blink and on Gecko 153. With no `bottom` at all an absolutely positioned box keeps its STATIC
|
||||
* position — where the row actually is — which is what was meant all along, and the reserved row
|
||||
* height below is what holds that space open. */
|
||||
.tr.placeholder {
|
||||
height: calc(3em + var(--fs-space-4));
|
||||
}
|
||||
|
||||
.tr.placeholder > .td {
|
||||
position: absolute;
|
||||
inset-inline: 0;
|
||||
text-align: center;
|
||||
line-height: 3em;
|
||||
/* …and the plate must be exactly as tall as the row reserved for it, or it hangs out of the
|
||||
* table at whichever end it is anchored to. `--fs-space-4` is two `--fs-space-2` at every
|
||||
* density, so this and the row height above are the same number twice — which is what lets
|
||||
* the cell keep its own size while the table flavours pad their ordinary cells
|
||||
* differently. Measured on Wireless, whose table pads 10px a side: the plate came out 67px
|
||||
* inside a 63px row and printed 4px below the frame's bottom border. */
|
||||
padding-block: var(--fs-space-2);
|
||||
}
|
||||
|
||||
.tr.drag-over-above,
|
||||
.tr.drag-over-below {
|
||||
border: 2px solid var(--fs-accent);
|
||||
border-width: 2px 0 0 0;
|
||||
}
|
||||
|
||||
.tr.drag-over-below {
|
||||
border-width: 0 0 2px 0;
|
||||
}
|
||||
}
|
||||
@@ -1,126 +0,0 @@
|
||||
@layer base {
|
||||
/* Page chrome: the sticky <header> band, dropdown anchoring, the tab strip, breadcrumbs and the
|
||||
* footer. styles/theme/ repaints these; what stays here is the geometry a view can rely on. */
|
||||
header {
|
||||
position: sticky;
|
||||
top: 0;
|
||||
z-index: var(--fs-z-header);
|
||||
overflow: visible;
|
||||
color: var(--fs-dim);
|
||||
display: flex;
|
||||
}
|
||||
|
||||
li.menu, .dropdown {
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.dropdown:hover ul.dropdown-menu {
|
||||
inset-inline-start: 0;
|
||||
}
|
||||
|
||||
/* Tab-strip visuals (margins, gradients, per-state colours): theme/40-tabs.css —
|
||||
* absorbed. Left: strip geometry. */
|
||||
.tabs > li, .cbi-tabmenu > li {
|
||||
flex: 0 1 auto;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
}
|
||||
|
||||
.tabs > li > a, .cbi-tabmenu > li > a {
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
text-decoration: none;
|
||||
outline: none;
|
||||
}
|
||||
|
||||
/* the tab focus ring lives in theme/40-tabs.css: an accent outline is invisible on the ACTIVE
|
||||
* pill, whose fill is that same accent. The theme repaints the rule that stood here in full
|
||||
* (same selectors), so a copy left behind would be a dead declaration tools/audit.py --strict
|
||||
* reports. */
|
||||
|
||||
.cbi-tab-disabled[data-errors]::after {
|
||||
content: attr(data-errors);
|
||||
/* badge fill: theme/40-tabs.css — absorbed */
|
||||
color: var(--fs-on-danger);
|
||||
height: var(--fs-space-4);
|
||||
min-width: var(--fs-space-4);
|
||||
/* a pill, so it says so, rather than half the height above restated by hand */
|
||||
border-radius: var(--fs-radius-pill);
|
||||
text-align: center;
|
||||
margin-inline-end: var(--fs-space-1);
|
||||
padding: 0 var(--fs-space-1);
|
||||
display: inline-flex;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
font-size: var(--fs-type);
|
||||
}
|
||||
|
||||
.cbi-tab-descr {
|
||||
/* the negative top pulls it under the tab strip it describes */
|
||||
margin: calc(var(--fs-space-2) * -1) 0 var(--fs-space-4) 0;
|
||||
}
|
||||
|
||||
/* hangs directly under the tab strip: 100% IS the strip's height by definition, where a literal
|
||||
* would be a hidden pair with whatever sizes the tab */
|
||||
.tabs .menu-dropdown, .tabs .dropdown-menu {
|
||||
top: 100%;
|
||||
border-width: 1px;
|
||||
/* square top-left only: the panel hangs off the tab above it and the two share that
|
||||
* corner */
|
||||
border-radius: 0 var(--fs-radius) var(--fs-radius) var(--fs-radius);
|
||||
}
|
||||
|
||||
/* the caret beside a tab's label, centred on the text box rather than nudged down it */
|
||||
.tabs a.menu:after, .tabs .dropdown-toggle:after {
|
||||
border-top-color: var(--fs-dim);
|
||||
align-self: center;
|
||||
margin-inline-start: var(--fs-space-1);
|
||||
}
|
||||
|
||||
.tabs li.open.menu .menu, .tabs .open.dropdown .dropdown-toggle {
|
||||
border-color: var(--fs-border);
|
||||
}
|
||||
|
||||
.tabs li.open a.menu:after, .tabs .dropdown.open .dropdown-toggle:after {
|
||||
border-top-color: var(--fs-text);
|
||||
}
|
||||
|
||||
.breadcrumb {
|
||||
padding: var(--fs-space-2) var(--fs-space-3);
|
||||
margin: 0 0 var(--fs-space-4);
|
||||
background: linear-gradient(to bottom, var(--fs-panel), var(--fs-panel2));
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
display: flex;
|
||||
flex: 0;
|
||||
}
|
||||
|
||||
.breadcrumb li {
|
||||
list-style: none;
|
||||
}
|
||||
|
||||
.breadcrumb li:not(:last-child)::after {
|
||||
content: "|";
|
||||
padding: 0 var(--fs-space-1);
|
||||
}
|
||||
|
||||
.breadcrumb .active a {
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
|
||||
/* Footer paint: theme/20-shell.css — absorbed. Left: the flex skeleton, where margin-top:auto
|
||||
* pins the footer to the bottom of the flex-column body. Do not re-add
|
||||
* `justify-content: space-between` or a span margin — they came from a two-column footer this
|
||||
* theme does not have. */
|
||||
footer {
|
||||
margin-top: auto;
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: baseline;
|
||||
}
|
||||
|
||||
footer ul.breadcrumb {
|
||||
margin-inline-start: auto;
|
||||
}
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
@layer base {
|
||||
/* the modal overlay ui.js shows for config diffs, uploads and login, plus the colour variants
|
||||
* shared by .btn / .alert-message / .cbi-tooltip */
|
||||
#modal_overlay {
|
||||
position: fixed;
|
||||
top: 0;
|
||||
bottom: 0;
|
||||
background: var(--fs-scrim);
|
||||
z-index: var(--fs-z-overlay);
|
||||
overflow: auto;
|
||||
transition: opacity var(--fs-dur);
|
||||
opacity: 0;
|
||||
visibility: hidden;
|
||||
}
|
||||
|
||||
.modal {
|
||||
width: 90%;
|
||||
/* clear of the sticky bar, and centred */
|
||||
margin: var(--fs-space-6) auto;
|
||||
min-height: var(--fs-control-h);
|
||||
max-width: 600px;
|
||||
/* a modal is a CARD — the large radius, like every other panel */
|
||||
border-radius: var(--fs-radius-lg);
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
/* box-shadow: theme/70-modal.css — absorbed; the old one was a shadow in the colour of the
|
||||
* page, and the theme gives every .modal --fs-shadow-pop instead */
|
||||
/* the card's own gutter on every side; the button row's spacing is its own business */
|
||||
padding: var(--fs-card-pad);
|
||||
min-width: 270px;
|
||||
}
|
||||
|
||||
/* .modal > * (normal leading, the .5em rhythm, max-width): theme/70-modal.css — absorbed
|
||||
* with the heading ramp, which would out-layer the leading here */
|
||||
|
||||
/* .modal > pre/textarea (pre-wrap, fill the dialog): theme/70-modal.css — absorbed with
|
||||
* the generic field box (its 210px would out-layer the width here) */
|
||||
|
||||
.modal > .button-row {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
|
||||
.modal > .button-row > button:not(:last-of-type) {
|
||||
margin-inline-end: var(--fs-space-2);
|
||||
}
|
||||
|
||||
.modal > .button-row > button:first-of-type {
|
||||
margin-inline-end: auto;
|
||||
}
|
||||
|
||||
body.modal-overlay-active {
|
||||
overflow: hidden;
|
||||
/* svh: `100vh` counts the mobile URL bar as if it were not there and crops the modal, while
|
||||
* `dvh` re-lays the dialog out on every frame of the bar's slide. The small viewport height
|
||||
* is the one that is both correct and still. */
|
||||
height: 100svh;
|
||||
}
|
||||
|
||||
body.modal-overlay-active #modal_overlay {
|
||||
inset-inline: 0;
|
||||
opacity: 1;
|
||||
visibility: visible;
|
||||
}
|
||||
|
||||
/* the cross inside a button or alert: `line-height: 1` centres the glyph in its own box, where a
|
||||
* fixed leading stops matching the moment the type scale moves */
|
||||
.btn .close, .alert-message .close {
|
||||
font-family: var(--fs-font-sans);
|
||||
line-height: 1;
|
||||
}
|
||||
|
||||
/* The whole colour-word block is absorbed — do not re-add any of it. `.btn.<word>` lives in
|
||||
* theme/55-buttons.css, `.alert-message.<word>` and `.cbi-tooltip.<word>` in
|
||||
* theme/35-alerts.css. The alert variants were already dead: theme paints plain
|
||||
* `.alert-message`, and a later layer beats this one whatever the specificity. The tooltip
|
||||
* variants were not — they were alive and un-themed, which is why the note that used to sit
|
||||
* here said the theme did not claim them; the gallery renders all four now, and that is what
|
||||
* turned the claim into a measurement. */
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
@layer base {
|
||||
/* `.btn` and `.cbi-button` are interchangeable in LuCI markup; a row action carries both plus a
|
||||
* `-<variant>` class. The paint — box, fill, radius — is theme/55-buttons.css's, along with the
|
||||
* `.item::after` member, whose plate now lives with the dynlist in theme/60-inputs.css. What is
|
||||
* left here is --on-color, which is not paint: base/95-luci.css masks the spinner glyph with
|
||||
* it, so it must track the variant. */
|
||||
.btn,
|
||||
.cbi-button {
|
||||
--on-color: var(--fs-text);
|
||||
|
||||
cursor: pointer;
|
||||
font-size: var(--fs-type);
|
||||
white-space: pre;
|
||||
}
|
||||
|
||||
/* border-color: theme/60-inputs.css — absorbed. The ink stays: theme paints no colour here. */
|
||||
.cbi-input-invalid,
|
||||
.cbi-input-invalid.cbi-dropdown:not(.btn):not(.cbi-button),
|
||||
.cbi-input-invalid.cbi-dropdown:not([open]) > ul > li,
|
||||
.cbi-value-error input {
|
||||
color: var(--fs-danger);
|
||||
}
|
||||
|
||||
/* `--on-color` only. A `border-color` here would be dead: theme/55-buttons.css sets `border` on
|
||||
* `.cbi-button, .btn`, and a later layer beats this one whatever the specificity, so the
|
||||
* variant wears the theme's colour either way — proven, not reasoned: stripping the ones that
|
||||
* used to sit here changes no computed style over docs/gallery.html, which renders every one of
|
||||
* these variants. `--on-color` stays because it is not paint — base/95-luci.css masks the
|
||||
* spinner glyph with it. */
|
||||
.cbi-button-positive,
|
||||
.cbi-button-fieldadd,
|
||||
.cbi-button-add,
|
||||
.cbi-button-save {
|
||||
--on-color: var(--fs-good);
|
||||
}
|
||||
|
||||
.btn.primary,
|
||||
.cbi-button-action,
|
||||
.cbi-button-apply,
|
||||
.cbi-button-reload,
|
||||
.cbi-button-edit {
|
||||
--on-color: var(--fs-accent);
|
||||
}
|
||||
|
||||
.cbi-button-negative,
|
||||
.cbi-section-remove .cbi-button,
|
||||
.cbi-button-reset,
|
||||
.cbi-button-remove {
|
||||
--on-color: var(--fs-danger);
|
||||
}
|
||||
|
||||
.cbi-page-actions::after {
|
||||
display: table;
|
||||
content: "";
|
||||
clear: both;
|
||||
}
|
||||
|
||||
.cbi-page-actions > * {
|
||||
vertical-align: middle;
|
||||
}
|
||||
|
||||
/* No `float` here: theme/55-buttons.css makes `.cbi-page-actions` a flex container, and float
|
||||
* does not apply to a flex item, so one would compute to `none` and move nothing while reading
|
||||
* like a physical side the logical-property sweep had missed. No context revives it — print
|
||||
* hides the whole container (theme/97-print.css). Verified in a live document in both writing
|
||||
* directions: the button sits 569px from the reading edge with the float and 569px without. */
|
||||
.cbi-page-actions > :not([method="post"]):not(.cbi-button-apply):not(.cbi-button-negative):not(.cbi-button-save):not(.cbi-button-reset) {
|
||||
margin-inline-end: var(--fs-space-1);
|
||||
}
|
||||
|
||||
/* fills and borders: theme/55-buttons.css — absorbed. --on-color stays (the spinner mask). */
|
||||
.btn.primary,
|
||||
.cbi-button-action.important,
|
||||
.cbi-page-actions .cbi-button-apply,
|
||||
.cbi-section-actions .cbi-button-edit {
|
||||
--on-color: var(--fs-on-accent);
|
||||
}
|
||||
|
||||
.cbi-button-positive.important,
|
||||
.cbi-page-actions .cbi-button-save {
|
||||
--on-color: var(--fs-on-good);
|
||||
}
|
||||
|
||||
.cbi-button-negative.important {
|
||||
--on-color: var(--fs-on-danger);
|
||||
/* fill + border: theme/55-buttons.css — absorbed */
|
||||
}
|
||||
|
||||
.cbi-page-actions .cbi-button-apply + .cbi-button-save,
|
||||
.cbi-page-actions .cbi-button-negative + .cbi-button-save {
|
||||
--on-color: var(--fs-good);
|
||||
/* fill + border: theme/55-buttons.css — absorbed */
|
||||
}
|
||||
}
|
||||
@@ -1,143 +0,0 @@
|
||||
@layer base {
|
||||
/* small widgets a view or a third-party luci-app-* can drop anywhere: tooltip, progress bar,
|
||||
* zone badge, button states, close cross, alert box, .label pill */
|
||||
/* .cbi-title-ref colour: theme/45-misc.css — absorbed. The arrow stays: content,
|
||||
* not paint. */
|
||||
.cbi-title-ref::after {
|
||||
content: "➙";
|
||||
}
|
||||
|
||||
.cbi-tooltip-container {
|
||||
cursor: help;
|
||||
}
|
||||
|
||||
.cbi-tooltip {
|
||||
position: absolute;
|
||||
z-index: var(--fs-z-tooltip);
|
||||
/* logical: `left: -10000px` in an RTL document parks the tooltip past the INLINE-END edge,
|
||||
* which is scrollable overflow — every page grew a 10000px horizontal scrollbar in ar/fa/he
|
||||
* (measured). Past the inline-start edge is unreachable in both directions. */
|
||||
inset-inline-start: -10000px;
|
||||
/* box-shadow: theme/35-alerts.css — absorbed */
|
||||
border-radius: var(--fs-radius-sm);
|
||||
background: var(--fs-panel);
|
||||
/* `pre`, not `pre-wrap`, NEVER wraps — task 0162: live-audit measured a firewall rule-jump
|
||||
* tooltip (`nftables/iptables`, "Chain POSTROUTING, Rule #1") 65-72px past the column at
|
||||
* 320px, spaces and all, because `pre` disables wrapping outright regardless of where a space
|
||||
* sits. `pre-wrap` keeps every literal run of whitespace this rule was carried for — the same
|
||||
* reason `35-alerts.css`'s validation tooltip and a multi-line firewall hint still read
|
||||
* correctly — while letting the browser wrap at one of them once the line is too long. */
|
||||
white-space: pre-wrap;
|
||||
padding: var(--fs-space-0-5) var(--fs-space-1);
|
||||
opacity: 0;
|
||||
transition: opacity var(--fs-dur-fade);
|
||||
}
|
||||
|
||||
.cbi-tooltip-container:hover .cbi-tooltip:not(:empty) {
|
||||
inset-inline-start: auto;
|
||||
opacity: 1;
|
||||
transition: opacity var(--fs-dur-fade);
|
||||
}
|
||||
|
||||
/* .cbi-progressbar paint: theme/25-progressbar.css — absorbed. The fill's starting
|
||||
* width stays: the poll JS animates the inline width up from it. */
|
||||
.cbi-progressbar > div {
|
||||
width: 0%;
|
||||
}
|
||||
|
||||
.zonebadge .cbi-tooltip {
|
||||
padding: 1px;
|
||||
background: inherit;
|
||||
margin: -1.6em 0 0 -5px;
|
||||
border-radius: var(--fs-radius-sm);
|
||||
pointer-events: none;
|
||||
/* box-shadow: theme/35-alerts.css states one elevation for every .cbi-tooltip */
|
||||
}
|
||||
|
||||
.zonebadge .cbi-tooltip > * {
|
||||
margin: 1px;
|
||||
z-index: var(--fs-z-raise);
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.zone-forwards {
|
||||
display: flex;
|
||||
flex-wrap: nowrap;
|
||||
}
|
||||
|
||||
.zone-forwards > * {
|
||||
flex: 1 1 40%;
|
||||
padding: 1px;
|
||||
text-wrap: auto;
|
||||
}
|
||||
|
||||
.zone-forwards > span {
|
||||
flex-basis: 10%;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.zone-forwards .zone-src,
|
||||
.zone-forwards .zone-dest {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
}
|
||||
|
||||
/* pressed-state shadow (.btn.active/:active): theme/55-buttons.css — absorbed */
|
||||
.btn.disabled,
|
||||
.btn[disabled] {
|
||||
cursor: default;
|
||||
opacity: var(--fs-disabled-opacity);
|
||||
}
|
||||
|
||||
/* `.btn.large` / `.btn.small`: theme/55-buttons.css, in full — absorbed. */
|
||||
|
||||
/* close cross — colour, shadow, opacities: theme/70-modal.css — absorbed. Left:
|
||||
* geometry. */
|
||||
/* `line-height: 1` centres the glyph in its own box; it was 13.5px under a 20px face, and a
|
||||
* hand-nudged length only lands for one font size */
|
||||
/* Physical, and mirrored by hand below — the same shape as `::-webkit-resizer`
|
||||
* (theme/60-inputs.css) and the two chevrons (theme/20-shell.css). `float` takes no logical
|
||||
* keyword this theme can rely on: `inline-end` is newer than
|
||||
* the `oklch(from …)` and `:has()` this sheet already requires only in Chromium, and a browser
|
||||
* that does not know the keyword drops the declaration and leaves the cross floating
|
||||
* nowhere. Measured in a live document at 1400px: the cross sat 549px from the reading edge in
|
||||
* LTR and 41px in RTL, i.e. it jumped from the end of the heading to its start — in front of
|
||||
* the title, where a dismissal control is not. It appears in every modal and in every
|
||||
* `.alert-message`, so this is the RTL bug with the widest reach. */
|
||||
.close {
|
||||
float: right;
|
||||
font-size: var(--fs-type-xl);
|
||||
font-weight: var(--fs-weight-bold);
|
||||
line-height: 1;
|
||||
}
|
||||
:root[dir="rtl"] .close { float: left; }
|
||||
|
||||
.close:hover {
|
||||
text-decoration: none;
|
||||
}
|
||||
|
||||
/* alert paint: theme/35-alerts.css — absorbed. Left: geometry and the white-space reset. */
|
||||
.alert-message {
|
||||
position: relative;
|
||||
margin-bottom: var(--fs-space-2);
|
||||
white-space: unset;
|
||||
}
|
||||
|
||||
.alert-message .close {
|
||||
margin-top: 1px;
|
||||
}
|
||||
|
||||
/* colour, margin and the content reset: theme/35-alerts.css — absorbed with the heading ramp */
|
||||
|
||||
.alert-message button {
|
||||
margin: var(--fs-space-1) 0;
|
||||
}
|
||||
|
||||
/* `.label` pill and variants: theme/35-alerts.css — absorbed, as is the indicator pill
|
||||
* (showIndicator() only ever emits into #indicators, which theme/20-shell.css paints). */
|
||||
header [data-indicator] {
|
||||
white-space: nowrap;
|
||||
text-shadow: none;
|
||||
margin: var(--fs-space-1) 0 var(--fs-space-1) var(--fs-space-1);
|
||||
}
|
||||
}
|
||||
@@ -1,749 +0,0 @@
|
||||
@layer base {
|
||||
/* Widgets with no generic equivalent: CBI section tables, interface/zone badges,
|
||||
* the uci change dialog, spinners, the file browser, and a few rules luci-mod-*
|
||||
* depends on. */
|
||||
/* .hidden: theme/60-inputs.css (with the .cbi-* variants LuCI emits) */
|
||||
form.inline { display: inline; margin-bottom: 0; }
|
||||
|
||||
#modemenu li:last-child span.divider { display: none }
|
||||
|
||||
/* #syslog: absorbed into pages/70-syslog.css — in base it LOST to the theme layer's generic
|
||||
* form-field box (a layer beats specificity), so the log rendered as a 210px column. */
|
||||
|
||||
/* `:not(.placeholder)`: a hover cue promises a row you can act on, and the empty-table row is
|
||||
* not one. The theme's row hover already spares it (theme/30-tables.css, issue #5.2), but this
|
||||
* rule paints the CELL, and a placeholder row carrying no `.cbi-section-table-row` class
|
||||
* escapes that guard — measured on UPnP (issue #15).
|
||||
* Fixed here rather than repainted later, so there is one hover contract. */
|
||||
.cbi-section-table .tr:not(.placeholder):hover .td,
|
||||
.cbi-section-table .tr:not(.placeholder):hover .th,
|
||||
.cbi-section-table .tr:not(.placeholder):hover::before {
|
||||
background-color: var(--fs-panel2);
|
||||
}
|
||||
|
||||
.cbi-section-table .tr.cbi-section-table-descr .th {
|
||||
font-weight: var(--fs-weight-normal);
|
||||
}
|
||||
|
||||
.cbi-section-table-titles {
|
||||
font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
/* The GridSection name column, where the two releases' markup genuinely differs and one
|
||||
* stylesheet serves both: 25.12's form.js renders the name as a real `th` plus
|
||||
* `td.cbi-section-table-titles` and keeps `data-title` on the row only for the drag handle,
|
||||
* while 24.10 renders no cell at all and expects `::before` to generate the column from
|
||||
* `data-title`. Upstream ships a different cascade.css per branch (25.12's says
|
||||
* `content: none`, 24.10's `content: attr(data-title) " "`), so taking 25.12's copy verbatim
|
||||
* deletes the Name column on every 24.10 router (issue #9).
|
||||
*
|
||||
* Each row type therefore asks the MARKUP, never the release:
|
||||
* header — carries `data-title` on 24.10 only; 25.12 appends a real `th` instead.
|
||||
* row — BOTH set `data-title`, so the discriminator is the name cell 25.12 adds.
|
||||
* descr — has neither, so it follows the header that already proved the branch. It needs the
|
||||
* empty spacer (`data-title` is absent, so the content is just " ") or its column
|
||||
* labels sit one cell left of the values they describe. A descr row with no header
|
||||
* row above it (every column carrying a description but no title) therefore keeps no
|
||||
* spacer — no shipped page renders that, so it is untested rather than handled.
|
||||
* Never key on the VALUE: the header's data-title is _('Name'), i.e. translated.
|
||||
*
|
||||
* This rule states only that the column EXISTS — its padding, type and separator are the cell
|
||||
* rules' job in theme/30-tables.css, next to the real cells it has to line up with. (Upstream
|
||||
* declares the border-top here; ours would draw the stray line above the header that issue #7
|
||||
* removed from every other cell.) */
|
||||
/* SPLIT OFF THE :has() HALF, and the split is the point: an engine that cannot parse `:has()`
|
||||
* throws away the WHOLE rule, siblings included — so a Firefox older than 121 lost the two
|
||||
* plain selectors above with it, and stacked tables came up with no card labels at all. Same
|
||||
* declarations, two rules, and the half that needs nothing new survives on its own. */
|
||||
.cbi-section-table-titles.named[data-title]::before,
|
||||
.cbi-section-table-titles.named[data-title] ~ .cbi-section-table-descr.named::before {
|
||||
content: attr(data-title) " ";
|
||||
display: table-cell;
|
||||
vertical-align: middle;
|
||||
}
|
||||
.cbi-section-table-row[data-title]:not(:has(> .cbi-section-table-titles))::before {
|
||||
content: attr(data-title) " ";
|
||||
display: table-cell;
|
||||
vertical-align: middle;
|
||||
}
|
||||
|
||||
.left { text-align: left !important; }
|
||||
.right { text-align: right !important; }
|
||||
.center { text-align: center !important; }
|
||||
.top { vertical-align: top !important; }
|
||||
.middle { vertical-align: middle !important; }
|
||||
.bottom { vertical-align: bottom !important; }
|
||||
|
||||
table table td,
|
||||
.cbi-value-field table td {
|
||||
border: none;
|
||||
}
|
||||
|
||||
/* cell-filling field widths (+ the numeric-cell refinement): theme/30-tables.css —
|
||||
* absorbed with the generic field box, which would out-layer them here */
|
||||
|
||||
.table.cbi-section-table .td.cbi-section-table-cell {
|
||||
white-space: nowrap;
|
||||
text-align: end;
|
||||
}
|
||||
|
||||
.td.cbi-section-actions {
|
||||
text-align: end;
|
||||
vertical-align: middle;
|
||||
width: 15%;
|
||||
}
|
||||
|
||||
.td.cbi-section-actions > * {
|
||||
display: flex;
|
||||
}
|
||||
|
||||
.td.cbi-section-actions > :not(.cbi-dropdown) > *,
|
||||
.td.cbi-section-actions > * > form > * {
|
||||
flex: 1 1 4em;
|
||||
/* at 1px apart, adjacent row actions sat inside each other's 24px target circle
|
||||
* (WCAG 2.2 SC 2.5.8) — see the min-height in theme/55-buttons.css */
|
||||
margin: 0 var(--fs-space-1);
|
||||
}
|
||||
|
||||
.td.cbi-section-actions > * > form {
|
||||
display: inline-flex;
|
||||
margin: 0;
|
||||
}
|
||||
|
||||
.table.valign-middle .td {
|
||||
vertical-align: middle;
|
||||
}
|
||||
|
||||
.cbi-rowstyle-2,
|
||||
.tr.table-titles,
|
||||
.tr.cbi-section-table-titles {
|
||||
background: var(--fs-panel2);
|
||||
}
|
||||
|
||||
th[data-sortable-row] { cursor: pointer; }
|
||||
th[data-sort-direction="asc"]::after { content: "\a0\25b2"; }
|
||||
th[data-sort-direction="desc"]::after { content: "\a0\25bc"; }
|
||||
|
||||
/* The help sentence, indented to clear the ? glyph its ::before hangs in the margin. The
|
||||
* indent and the glyph's own `left` are ONE relationship — both said 1.25em, stated twice — so
|
||||
* they now derive from a single local. */
|
||||
.cbi-value-description {
|
||||
--help-indent: 1.25em;
|
||||
|
||||
margin: var(--fs-space-1) 0 0 var(--help-indent);
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.cbi-value-description:not(:empty)::before {
|
||||
/* OURS, and drawn as a STROKE like every other glyph this theme owns (--spinner-icon below,
|
||||
* --fs-icon-refresh in 02-tokens.css: fill:none, round caps, a 24 grid). It replaces a solid
|
||||
* filled path copied verbatim from luci-theme-bootstrap: a drawn path is authored expression
|
||||
* in a way `padding: 8px` is not, which made it the sharpest item in that inheritance. */
|
||||
--help-icon: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23000' stroke-width='2.2' stroke-linecap='round' stroke-linejoin='round'><circle cx='12' cy='12' r='9.4'/><path d='M8.9 9.4a3.2 3.2 0 1 1 3.9 3.6v1.4'/><path d='M12.8 17.6h-.02'/></svg>");
|
||||
|
||||
position: absolute;
|
||||
inset-inline-start: calc(var(--help-indent) * -1);
|
||||
content: "\a0";
|
||||
display: inline-block;
|
||||
width: 1em;
|
||||
height: 1em;
|
||||
margin-inline-end: var(--fs-space-1);
|
||||
background: var(--fs-accent);
|
||||
mask-image: var(--help-icon);
|
||||
mask-size: cover;
|
||||
-webkit-mask-image: var(--help-icon);
|
||||
-webkit-mask-size: cover;
|
||||
}
|
||||
|
||||
/* tint (and the 6%-not-12% reasoning): theme/30-tables.css — absorbed */
|
||||
.cbi-section-error {
|
||||
border: 1px solid var(--fs-danger);
|
||||
border-radius: var(--fs-radius);
|
||||
padding: var(--fs-space-2);
|
||||
margin-bottom: var(--fs-space-4);
|
||||
}
|
||||
|
||||
.cbi-section-error ul { margin: 0 0 0 var(--fs-space-5); }
|
||||
|
||||
.cbi-section-error ul li {
|
||||
/* colour: theme/35-alerts.css — absorbed */
|
||||
font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
.ifacebox {
|
||||
border: var(--fs-hairline);
|
||||
margin: 0 var(--fs-space-3);
|
||||
text-align: center;
|
||||
white-space: nowrap;
|
||||
/* surface: theme/45-misc.css (flat) — absorbed */
|
||||
border-radius: var(--fs-radius-sm);
|
||||
display: inline-flex;
|
||||
flex-direction: column;
|
||||
/* a plate of single-line labels, not prose */
|
||||
line-height: var(--fs-leading-tight);
|
||||
min-width: 100px;
|
||||
}
|
||||
|
||||
.ifacebox .ifacebox-head {
|
||||
border-bottom: var(--fs-hairline);
|
||||
/* the head sits INSIDE the box's 1px border, so its own radius is the box's less that
|
||||
* border — restating a smaller literal is how the two drifted apart before. */
|
||||
border-radius: calc(var(--fs-radius-sm) - 1px) calc(var(--fs-radius-sm) - 1px) 0 0;
|
||||
padding: var(--fs-space-0-5);
|
||||
/* surface + ink: theme/45-misc.css — absorbed */
|
||||
}
|
||||
|
||||
/* The !important fights luci-mod-network's inline zone-colour `style=`: a raw zone colour is too
|
||||
* bright on a dark panel, so it is re-mixed at .4/.3.
|
||||
*
|
||||
* No fallback on --zone-color-rgb, and that is load-bearing: LuCI sets that var inline only
|
||||
* where there IS a zone colour, so elsewhere the declaration is invalid at computed-value time
|
||||
* and, being !important, resolves to `unset` and wipes the plain inline background — which is
|
||||
* the desired outcome. A fallback grey makes the rule apply there and tints five interface
|
||||
* boxes that correctly show the panel behind them (measured, computed-style diff). */
|
||||
[data-darkmode="true"] .zonebadge[style],
|
||||
[data-darkmode="true"] .ifacebox-head[style] {
|
||||
background: linear-gradient(rgba(var(--zone-color-rgb), .4), rgba(var(--zone-color-rgb), .3)) !important;
|
||||
}
|
||||
|
||||
/* `.ifacebox` above is `white-space: nowrap` — right for a plate of one-word head labels, wrong
|
||||
* for the body's own stat/address lines once they are long enough to need a break: measured
|
||||
* three times under three different scopes before this rule (Network overview's
|
||||
* `#cbi-network-interface`, the upstream plates' `.network-status-table`, and — pseudo-loc,
|
||||
* gallery's plain Port-tile fixture with no `port_*.svg` icon — a 320px/Large stat line "1000
|
||||
* Mbit/s / 1.2 GiB / 8.3 GiB" already 33px past a 118px box in PLAIN ENGLISH, no translation
|
||||
* involved) — the base rule owns it once instead of a fourth scoped copy the next real page
|
||||
* would need again. `overflow-wrap: anywhere`, not `break-word`: only `anywhere` lowers the
|
||||
* box's own min-content, letting the flex item actually shrink to the tile (65-dropdown.css's
|
||||
* own reasoning for the same two properties). */
|
||||
.ifacebox .ifacebox-body {
|
||||
padding: var(--fs-space-1);
|
||||
white-space: normal;
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
|
||||
#cbi-network-interface .ifacebox img {
|
||||
width: 24px;
|
||||
height: 24px;
|
||||
}
|
||||
|
||||
.ifacebadge {
|
||||
display: inline-block;
|
||||
flex-direction: row;
|
||||
border: var(--fs-hairline);
|
||||
padding: var(--fs-space-0-5);
|
||||
/* surface: theme/45-misc.css (flat) — absorbed */
|
||||
color: var(--fs-text);
|
||||
border-radius: var(--fs-radius-sm);
|
||||
cursor: default;
|
||||
/* a badge is one line of label — the tight step, like .ifacebox above */
|
||||
line-height: var(--fs-leading-tight);
|
||||
}
|
||||
|
||||
.ifacebadge img {
|
||||
width: 32px;
|
||||
height: 32px;
|
||||
vertical-align: middle;
|
||||
}
|
||||
|
||||
.ifacebadge-active {
|
||||
/* border-color: theme/45-misc.css (accent) — absorbed */
|
||||
font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
.network-status-table {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
|
||||
.network-status-table .ifacebox {
|
||||
margin: var(--fs-space-2);
|
||||
flex-grow: 1;
|
||||
}
|
||||
|
||||
.network-status-table .ifacebox-body {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
height: 100%;
|
||||
text-align: start;
|
||||
/* the wrap fix (an uncompressed IPv6 is ~380px of unbreakable text, measured 45px over the
|
||||
* card at 390px before it shipped) now lives on `.ifacebox .ifacebox-body` above, generalised
|
||||
* to every plate rather than restated per scope — this rule keeps only what is unique to the
|
||||
* upstream layout: full-height flex column, address-block start alignment. */
|
||||
}
|
||||
|
||||
/* The head got the port tiles' `nowrap` (short one-word labels: "wan", "lan2") but sits in the
|
||||
* SAME shrinking flex item as the body above, and RU's "IPv4 Upstream" caption is a sentence,
|
||||
* not a word: "Подключение IPv4 (внешняя сеть)" measured 301px in a 288px column at 320px/
|
||||
* Density Large, 41.3px past #view, with the .cbi-section clipped by 42px and no scroller — EN
|
||||
* at the same width and density: 0. Same two declarations as the body, same reasoning. */
|
||||
.network-status-table .ifacebox-head {
|
||||
white-space: normal;
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
|
||||
.network-status-table .ifacebox-body > * {
|
||||
margin: var(--fs-space-1);
|
||||
}
|
||||
|
||||
.network-status-table .ifacebox-body > span {
|
||||
flex: 10 10 auto;
|
||||
height: 100%;
|
||||
}
|
||||
|
||||
.network-status-table .ifacebox-body > div {
|
||||
margin: -.125em;
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
|
||||
#dsl_status_table .ifacebox-body span > strong {
|
||||
display: inline-block;
|
||||
min-width: 35%;
|
||||
}
|
||||
|
||||
.ifacebadge.large,
|
||||
.network-status-table .ifacebox-body .ifacebadge {
|
||||
display: flex;
|
||||
flex: 1;
|
||||
padding: var(--fs-space-1);
|
||||
min-width: 220px;
|
||||
margin: var(--fs-space-1);
|
||||
}
|
||||
|
||||
.ifacebadge.large {
|
||||
display: inline-flex;
|
||||
}
|
||||
|
||||
.network-status-table .ifacebox-body .ifacebadge > span {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.ifacebadge > *,
|
||||
.ifacebadge.large > * {
|
||||
margin: 0 var(--fs-space-1);
|
||||
}
|
||||
|
||||
.zonebadge {
|
||||
padding: var(--fs-space-0-5);
|
||||
border-radius: var(--fs-radius-sm);
|
||||
display: inline-block;
|
||||
white-space: nowrap;
|
||||
color: var(--fs-text);
|
||||
}
|
||||
|
||||
.zonebadge > em,
|
||||
.zonebadge > strong {
|
||||
margin: 0 var(--fs-space-1);
|
||||
display: inline-block;
|
||||
}
|
||||
|
||||
/* .zonebadge input width: theme/30-tables.css — absorbed with the generic box */
|
||||
|
||||
.zonebadge > .ifacebadge {
|
||||
margin-inline-start: var(--fs-space-0-5);
|
||||
}
|
||||
|
||||
.zonebadge-empty {
|
||||
/* width/style only — colour + ink: theme/45-misc.css */
|
||||
border: 1px dashed var(--fs-border);
|
||||
font-style: italic;
|
||||
font-size: smaller;
|
||||
}
|
||||
|
||||
/* color: theme/60-inputs.css — absorbed. */
|
||||
div.cbi-value var,
|
||||
.td.cbi-value-field var {
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
div.cbi-value var[data-tooltip],
|
||||
.td.cbi-value-field var[data-tooltip],
|
||||
div.cbi-value var.cbi-tooltip-container,
|
||||
.td.cbi-value-field var.cbi-tooltip-container {
|
||||
cursor: help;
|
||||
border-bottom: 1px dotted var(--fs-accent);
|
||||
}
|
||||
|
||||
div.cbi-value var.cbi-tooltip-container,
|
||||
.td.cbi-value-field var.cbi-tooltip-container .cbi-tooltip {
|
||||
font-style: normal;
|
||||
white-space: normal;
|
||||
color: var(--fs-text);
|
||||
}
|
||||
|
||||
#modal_overlay > .modal.uci-dialog,
|
||||
#modal_overlay > .modal.cbi-modal {
|
||||
max-width: 900px;
|
||||
}
|
||||
|
||||
#modal_overlay > .modal.login > button.important {
|
||||
/* no !important needed: the ID makes this (1,3,1), which no button rule can reach */
|
||||
/* Coverage vocabulary, not a live control: nothing in luci-base gives a modal the `login`
|
||||
* class (ui.showModal takes classes and no call site passes one), and this theme's own
|
||||
* login is a server-rendered form, not a modal. It is inherited from luci-theme-bootstrap,
|
||||
* which carries the same selector, so an app that emits it gets a themed result — a step up
|
||||
* the scale, where it was a bare 120% of whatever the button happened to be. */
|
||||
font-size: var(--fs-type-lg);
|
||||
margin-top: var(--fs-space-2);
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
/* a list of changed settings, one per line: prose leading, not a hand 170%. */
|
||||
.uci-change-list {
|
||||
line-height: var(--fs-leading);
|
||||
white-space: pre;
|
||||
}
|
||||
|
||||
/* one changed-setting row. It carried `line-height: 15px` — a hand number under a 13px face;
|
||||
* a row of single-line code takes the tight step like every other plate here. */
|
||||
.uci-dialog div > del,
|
||||
.uci-dialog div > ins,
|
||||
.uci-dialog div > var {
|
||||
margin-bottom: var(--fs-space-0-5);
|
||||
border: var(--fs-hairline);
|
||||
line-height: var(--fs-leading-tight);
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
padding: var(--fs-space-0-5);
|
||||
position: relative;
|
||||
background-color: var(--fs-panel2);
|
||||
}
|
||||
|
||||
.uci-dialog div > ins {
|
||||
background-color: var(--fs-good-fill);
|
||||
border-color: var(--fs-good-line);
|
||||
}
|
||||
|
||||
.uci-dialog div > del {
|
||||
background-color: var(--fs-danger-fill);
|
||||
border-color: var(--fs-danger-line);
|
||||
}
|
||||
|
||||
.uci-dialog var > ins {
|
||||
background-color: var(--fs-good-fill);
|
||||
}
|
||||
|
||||
.uci-dialog var > del {
|
||||
background-color: var(--fs-danger-fill);
|
||||
}
|
||||
|
||||
.uci-change-list > var > * {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.uci-dialog del,
|
||||
.uci-dialog ins,
|
||||
.uci-dialog var {
|
||||
text-decoration: none;
|
||||
font-family: var(--fs-font-mono);
|
||||
font-style: normal;
|
||||
color: var(--fs-text);
|
||||
display: block;
|
||||
}
|
||||
|
||||
.uci-change-legend {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
|
||||
.uci-change-legend-label {
|
||||
flex-basis: 150px;
|
||||
margin: var(--fs-space-0-5);
|
||||
display: flex;
|
||||
align-items: center;
|
||||
}
|
||||
|
||||
.uci-change-legend-label > ins,
|
||||
.uci-change-legend-label > del,
|
||||
.uci-change-legend-label > var {
|
||||
margin-inline-end: var(--fs-space-1);
|
||||
width: 16px;
|
||||
height: 16px;
|
||||
display: flex;
|
||||
}
|
||||
|
||||
.uci-change-legend-label > * > * {
|
||||
flex-basis: 100%;
|
||||
padding: 1px;
|
||||
}
|
||||
|
||||
#applyreboot-section {
|
||||
line-height: 300%;
|
||||
}
|
||||
|
||||
@keyframes flash {
|
||||
0% { opacity: 1; }
|
||||
50% { opacity: .5; }
|
||||
100% { opacity: 1; }
|
||||
}
|
||||
|
||||
.flash {
|
||||
animation: flash var(--fs-dur-fade);
|
||||
}
|
||||
|
||||
#view > div.spinning:first-child {
|
||||
display: table;
|
||||
margin: 15vh auto;
|
||||
}
|
||||
|
||||
/* Rotate in CSS, NEVER with a SMIL <animateTransform> inside the data-URI: that runs in
|
||||
* the SVG's own document, which the page's `prefers-reduced-motion` cannot reach — the
|
||||
* one spinner a motion-sensitive user could not turn off. theme/95-a11y-media.css now
|
||||
* stops it like everything else. (The circle under the arc is rotationally symmetric,
|
||||
* so spinning the whole box looks identical.) */
|
||||
/* ---- the glyph sits in the flow, which is the fix for a whole bug class ----
|
||||
*
|
||||
* Absolutely positioned, the host has to be told to leave room for it — a `padding-left` that
|
||||
* must out-rank whatever else pads that element. That race cannot be won: every padding rule
|
||||
* aimed at a button is a candidate and the loser is silent, the glyph simply drawing on top of
|
||||
* the label. Twice reported from the field, each time by a more specific rule than the last:
|
||||
* issue #15 (`.td .cbi-button`, 0,2,0) and issue #22, whose
|
||||
* `.cbi-section .table[id] .td .cbi-button` is 0,5,0 — there the ladder had padding-left at
|
||||
* 10px against the 32px the glyph needs.
|
||||
*
|
||||
* In the flow the glyph reserves its own space, so no host needs a padding and there is nothing
|
||||
* to out-rank. `flex: 0 0 auto` because the buttons are `inline-flex` and a flex item with a
|
||||
* mask is squeezable; `vertical-align: middle` for the non-flex hosts. The centring is the
|
||||
* host's own align-items or baseline alignment. */
|
||||
.spinning::before {
|
||||
--spinner-icon: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20' stroke='%23000' stroke-width='3' fill='none'><circle cx='10' cy='10' r='8' stroke-opacity='.5'/><path d='M10 2c4 0 8 4 8 8'/></svg>");
|
||||
|
||||
display: inline-block;
|
||||
flex: 0 0 auto;
|
||||
vertical-align: middle;
|
||||
margin-inline-end: var(--fs-space-1);
|
||||
width: var(--fs-spin-size);
|
||||
height: var(--fs-spin-size);
|
||||
content: " ";
|
||||
background: var(--on-color, #000);
|
||||
mask: var(--spinner-icon) center/cover no-repeat;
|
||||
-webkit-mask: var(--spinner-icon) center/cover no-repeat;
|
||||
/* The two deliberate exceptions to the motion scale (02-tokens.css), both because this
|
||||
* is a LOOP, not a state change: 1s is a spinner period, not one of the four durations;
|
||||
* and `linear` is the one justified curve — `ease` would slow at each turn's seam, so an
|
||||
* infinite rotation visibly stutters once a second instead of spinning. */
|
||||
animation: fs-spin 1s linear infinite;
|
||||
}
|
||||
|
||||
/* One user in this theme (`.spinning::before` above) — the rail's poll glyph is
|
||||
* deliberately STATIC (theme/20-shell.css; the spin was what broke that click).
|
||||
* Unscoped anyway: keyframe names resolve document-wide, so a luci-app-* may ride it. */
|
||||
@keyframes fs-spin { to { transform: rotate(360deg); } }
|
||||
|
||||
[data-darkmode="true"] .spinning::before {
|
||||
background: var(--on-color, #fff);
|
||||
}
|
||||
|
||||
[data-tab-title] {
|
||||
height: 0;
|
||||
opacity: 0;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
/* the revealed state of both collapsibles — tab pane and file browser — in one rule */
|
||||
[data-tab-active="true"],
|
||||
.cbi-filebrowser.open {
|
||||
opacity: 1;
|
||||
height: auto;
|
||||
overflow: visible;
|
||||
transition: opacity var(--fs-dur-fade);
|
||||
}
|
||||
|
||||
.cbi-filebrowser {
|
||||
/* `min(210px, 100%)`, not a bare 210: the floor keeps the file list readable, and a floor
|
||||
* wider than the field it sits in is not a floor but an overflow — measured at a 300px
|
||||
* viewport, the panel held 210px inside a 203px field and its whole upload row (the input,
|
||||
* Upload file, Cancel) stood 7px outside the card. Same shape as the dynlist's floor one file
|
||||
* over, and the same fix. Nothing moves at any width where the field is wider than 210. */
|
||||
min-width: min(210px, 100%);
|
||||
max-width: 100%;
|
||||
/* width/style only; radius: theme/60-inputs.css — absorbed */
|
||||
border: var(--fs-hairline);
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
opacity: 0;
|
||||
height: 0;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
/* padding: theme/60-inputs.css — absorbed. The zero side padding here was what let a 36px
|
||||
* themed button touch this element's own clip box and lose its corners to it. */
|
||||
.cbi-filebrowser > * {
|
||||
max-width: 100%;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
margin: .25em .25em 0 .25em;
|
||||
white-space: nowrap;
|
||||
border-bottom: var(--fs-hairline);
|
||||
}
|
||||
|
||||
.cbi-filebrowser .cbi-button-positive {
|
||||
margin-inline-end: .25em;
|
||||
}
|
||||
|
||||
/* `.cbi-filebrowser > *` above gives every row `nowrap` + ellipsis on the assumption that a row
|
||||
* is ONE LINE OF TEXT — true for the path and each listing row, false for `.right`: its content
|
||||
* is the upload strip (its own flex row) plus the Create/Cancel buttons, none of it text that an
|
||||
* ellipsis can stand in for. `nowrap`, inherited by `.upload` and its Browse button, was blocking
|
||||
* the wrap that button already had (`flex-wrap: wrap`, theme/60-inputs.css) from ever firing, and
|
||||
* `overflow: hidden` had no ellipsis to show for a clipped BUTTON — pseudo-loc measured Cancel's
|
||||
* label rendered 76px past this box with no "…" drawn, the severe case the gate's own docs call
|
||||
* "text the reader cannot reach", not the accepted dropdown/tab shape. `normal` restores the
|
||||
* ordinary wrap a button row gets everywhere else in the theme; `visible` undoes a clip a
|
||||
* text-only rule has no business applying to a row of controls. */
|
||||
.cbi-filebrowser > .right {
|
||||
white-space: normal;
|
||||
overflow: visible;
|
||||
}
|
||||
|
||||
.cbi-filebrowser > div {
|
||||
border-bottom: none;
|
||||
}
|
||||
|
||||
.cbi-filebrowser > ul > li {
|
||||
display: flex;
|
||||
flex-direction: row;
|
||||
}
|
||||
|
||||
/* row hover surface, and the row's whole flex sizing: theme/60-inputs.css — absorbed. The
|
||||
* proportional split that lived here (name `flex: 10` / actions `flex: 3`) fitted base's ~20px
|
||||
* buttons and not the theme's 36px ones, which is how a file row came to clip its own Delete. */
|
||||
.cbi-filebrowser > ul > li > div:first-child {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.cbi-filebrowser > ul > li > div:last-child {
|
||||
text-align: end;
|
||||
}
|
||||
|
||||
.cbi-filebrowser > ul > li > div:last-child > button {
|
||||
padding: .125em .25em;
|
||||
}
|
||||
|
||||
.cbi-filebrowser .upload {
|
||||
display: flex;
|
||||
flex-direction: row;
|
||||
flex-wrap: wrap;
|
||||
margin: 0 -.125em .25em -.125em;
|
||||
padding: 0 0 .125em 0;
|
||||
border-bottom: var(--fs-hairline);
|
||||
}
|
||||
|
||||
.cbi-filebrowser .upload > * {
|
||||
margin: .125em;
|
||||
flex: 1;
|
||||
}
|
||||
|
||||
.cbi-filebrowser .upload > .btn {
|
||||
flex-basis: 60px;
|
||||
}
|
||||
|
||||
.cbi-filebrowser .upload > div {
|
||||
flex: 10;
|
||||
min-width: 150px;
|
||||
}
|
||||
|
||||
/* the upload input's width: theme/60-inputs.css — absorbed with the generic box */
|
||||
|
||||
@keyframes fade-in {
|
||||
0% { opacity: 0; }
|
||||
100% { opacity: 1; }
|
||||
}
|
||||
|
||||
@keyframes fade-out {
|
||||
0% { opacity: 1; }
|
||||
100% { opacity: 0; }
|
||||
}
|
||||
|
||||
/* The `fade-in` keyframes above stay although nothing here rides them: it is an upstream
|
||||
* animation NAME a luci-app-* may ride (coverage contract, docs/conventions.md). The theme's own
|
||||
* rule on the `.fade-in` CLASS is gone on purpose — luci-mod-status re-marks with it on every
|
||||
* poll tick, so anything hung there replays on every tick across the whole column.
|
||||
*
|
||||
* `fs-fade` is the theme's own and is one-shot: the rail flyout and the search overlay each
|
||||
* play it once, when the surface opens, which is why its 4px rise is right there and wrong on
|
||||
* a class the poll rewrites. Both keyframes live here because every keyframes in this theme
|
||||
* does, and an unresolvable animation-name is simply dropped, silently. */
|
||||
@keyframes fs-fade {
|
||||
from { opacity: 0; transform: translateY(4px); }
|
||||
to { opacity: 1; transform: none; }
|
||||
}
|
||||
|
||||
.fade-out {
|
||||
animation: fade-out var(--fs-dur-fade);
|
||||
}
|
||||
|
||||
.assoclist .ifacebadge {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
white-space: normal;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.assoclist .ifacebadge > img {
|
||||
margin: var(--fs-space-1);
|
||||
}
|
||||
|
||||
.assoclist .td:nth-of-type(3),
|
||||
.assoclist .td:nth-of-type(5) {
|
||||
width: 25%;
|
||||
}
|
||||
|
||||
.assoclist .td:nth-of-type(6) button {
|
||||
word-break: normal;
|
||||
}
|
||||
|
||||
/* Statistics renders its graphs as PNGs on a white ground, so dark mode inverts them. 180deg is
|
||||
* arithmetic rather than taste: invert() maps every hue to h+180, so rotating 180 back restores
|
||||
* the original hue while keeping the inverted lightness. Read back off collectd's own cpu
|
||||
* series, at 150deg System (h=0) came back at h=301 and User (h=240) at h=180 — 59 and 60
|
||||
* degrees out, i.e. the blue plot was drawn cyan. At 180deg all three primaries are exact.
|
||||
*
|
||||
* It is not exact for every colour and cannot be: CSS hue-rotate is a linear matrix
|
||||
* approximation, so a non-primary survives only approximately (amber lands 13deg out). Do not
|
||||
* tune the angle — moving off 180 trades an exact red/green/blue for a marginally better
|
||||
* amber. */
|
||||
[data-darkmode="true"] [data-page="admin-statistics-graphs"] [data-plugin] img {
|
||||
filter: invert(100%) hue-rotate(180deg);
|
||||
}
|
||||
|
||||
/* Realtime graphs (Status → Load/Traffic) inject resources/svg/*.svg into a div with
|
||||
* an inline style. The <svg> root carries none itself, so the background needs no flag.
|
||||
* Its grid <line>s do — `style="stroke:black"` in the .svg — and a black hairline is
|
||||
* invisible on a dark panel; only an author !important beats an inline declaration. */
|
||||
#view div[style] > svg {
|
||||
background-color: var(--fs-panel);
|
||||
}
|
||||
|
||||
#view div[style] > svg line[style] {
|
||||
stroke: var(--fs-text) !important;
|
||||
}
|
||||
|
||||
/* …and the axis labels beside them: every <text> in the .svg carries an inline fill of the
|
||||
* file's own light grey plus a black halo, drawn for the black background the file assumes
|
||||
* rather than for the panel this theme paints. On a light palette that grey lands on white at
|
||||
* 1.16:1, legible only as the shadow around it, against 17.9:1 for --fs-text, and 14.7:1 on the
|
||||
* dark panel, where it is the halo that has to go instead. Both come from an inline
|
||||
* declaration, so both need the flag.
|
||||
*
|
||||
* The weight is not decoration: the SVG hardcodes a 9pt label, the smallest type this theme
|
||||
* renders, and at the regular weight also the thinnest.
|
||||
*
|
||||
* A CHILD combinator, and the difference is a page: Channel Analysis derives a colour per BSSID
|
||||
* and paints both the curve and its SSID label with it, and those labels are built inside a
|
||||
* <g>, while the grey axis labels are direct children of the <svg>. A descendant selector
|
||||
* recolours both and leaves the curves as they were; `> text[style]` reaches only the axis. */
|
||||
#view div[style] > svg > text[style] {
|
||||
fill: var(--fs-text) !important;
|
||||
text-shadow: none !important;
|
||||
font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
/* Overview Hide/Show toggle pills: theme/35-alerts.css (.cbi-title .label) +
|
||||
* pages/20-overview.css (chevron variant) — absorbed. */
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
@layer page {
|
||||
/* LOGIN — the server-rendered form of themes/footstrap/sysauth.ut, as a centred card.
|
||||
*
|
||||
* Scoped by `.fs-login`, a class that template puts on the form: the form is ours, so naming it
|
||||
* is free, where the `form:has(> .cbi-map input[name="luci_username"])` it replaced cost 49
|
||||
* characters × 17 rules, ~0.8 KB of the stylesheet. Nothing else ever matched that selector —
|
||||
* ui.js builds no login form of its own and has no `luci_username` anywhere.
|
||||
*
|
||||
* The theme ships its own sysauth.ut so the page carries NO chrome: without one, LuCI falls back
|
||||
* to the generic template, which includes the header without blank_page and draws the whole
|
||||
* sidebar around a page whose only control is a password field.
|
||||
*
|
||||
* Do not turn this into a modal (form in a `<section hidden>`, revealed by a view module): the
|
||||
* view runs before a session exists, its RPCs answer "Access denied", render() never runs, and
|
||||
* the page is blank with no way to log in. Server-rendered, the form works with JS off. */
|
||||
.fs-login {
|
||||
/* A DEFINITE width, never `max-width`: the card is a direct flex item of <body>
|
||||
* (base/20-typography.css makes body a flex column so the footer can margin-top:auto),
|
||||
* and on the cross axis an `auto` side margin overrides the stretch and sizes the item
|
||||
* to FIT-CONTENT. `max-width: 400px` capped nothing — the card collapsed to its
|
||||
* min-content, ~131px, and the description wrapped one word per line. */
|
||||
width: min(400px, calc(100% - 32px));
|
||||
margin: 7vh auto var(--fs-space-10);
|
||||
background: var(--fs-panel); border: var(--fs-hairline); border-radius: var(--fs-radius-lg);
|
||||
/* the token, not a literal 45%-black 60px halo: that ignored the palette and drew
|
||||
* a heavy grey cloud under a white card in light mode. */
|
||||
padding: var(--fs-space-6) var(--fs-space-6) var(--fs-space-6); box-shadow: var(--fs-shadow-pop);
|
||||
}
|
||||
/* The router's own name, first line of the card (sysauth.ut): a centred identity block, set apart
|
||||
* from the form, above a left-aligned heading and left-aligned fields — the shape an appliance
|
||||
* console uses. Centred and separated is what makes the mixed alignment read as deliberate
|
||||
* rather than as a stray line, the 24px gap below being the card's own padding.
|
||||
*
|
||||
* Still smaller than the heading it stands over (16px against its 20px): it answers "which box
|
||||
* is this", which matters only until you have read it, while `Authorization Required` answers
|
||||
* "what now", the page's actual subject. Set larger, the two swap roles and the heading reads
|
||||
* as a subtitle.
|
||||
*
|
||||
* Not a heading element, on purpose: the outline is about the page's subject, and a heading
|
||||
* above it would announce the login form as two sections.
|
||||
*
|
||||
* The eyebrow tokens are NOT reused, though this is an eyebrow's position: they carry
|
||||
* `text-transform: uppercase`, and a hostname is a name — `Rb5009-Usb` is not what the admin
|
||||
* typed, and case is the only thing telling two similar names apart on a router farm.
|
||||
*
|
||||
* `overflow-wrap: anywhere` because the card is a DEFINITE 400px (above) and a hostname is one
|
||||
* unbreakable token of up to 63 characters — nothing in it is a break opportunity, so without
|
||||
* this a long one runs out of the card instead of wrapping inside it. */
|
||||
.fs-login-host {
|
||||
margin: 0 0 var(--fs-space-6); text-align: center;
|
||||
font-size: var(--fs-type-lg); font-weight: var(--fs-weight-bold); color: var(--fs-dim);
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
.fs-login .cbi-map,
|
||||
.fs-login .cbi-section,
|
||||
.fs-login .cbi-section-node {
|
||||
background: none; border: 0; padding: 0; margin: 0; box-shadow: none;
|
||||
}
|
||||
/* the login card IS the panel — the generic "heading gets its own card" rule would
|
||||
* draw a second frame inside it. `h1` because this page has no title bar to carry the
|
||||
* document's top-level heading (sysauth.ut says why); the card rule in theme/45-misc.css is
|
||||
* written for `.cbi-map > h2` and so does not reach it, but the reset stays listed — the
|
||||
* heading's level is not what should decide whether a second frame appears inside this card. */
|
||||
.fs-login .cbi-map > h1,
|
||||
.fs-login .cbi-map-descr {
|
||||
background: none; border: 0; border-radius: 0; box-shadow: none; padding: 0;
|
||||
}
|
||||
/* the h2's size, on an h1: the ramp puts an h1 at 26px (theme/45-misc.css) and in a 400px card
|
||||
* that wraps `Authorization Required` onto two lines. The heading was the right SIZE all along
|
||||
* — only its level was wrong. `margin`, because the ramp gives an h1 a bottom margin and this
|
||||
* card sets its own rhythm. */
|
||||
.fs-login .cbi-map > h1 {
|
||||
font-size: var(--fs-type-xl); font-weight: var(--fs-weight-bold); letter-spacing: -.01em; margin: 0 0 var(--fs-space-1-5);
|
||||
}
|
||||
.fs-login .cbi-map-descr { color: var(--fs-dim); font-size: var(--fs-type); margin: 0 0 var(--fs-space-5); }
|
||||
.fs-login .cbi-value {
|
||||
display: block; border: 0; padding: 0 0 var(--fs-space-4); margin: 0;
|
||||
}
|
||||
.fs-login .cbi-value-title {
|
||||
display: block; text-align: start; width: auto; max-width: none; padding: 0 0 var(--fs-space-1-5);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight); letter-spacing: var(--fs-eyebrow-tracking); text-transform: uppercase; color: var(--fs-eyebrow-color);
|
||||
}
|
||||
.fs-login .cbi-value-field {
|
||||
width: 100%; margin: 0; padding: 0;
|
||||
}
|
||||
.fs-login .cbi-value-field input {
|
||||
width: 100%; margin: 0; box-sizing: border-box;
|
||||
}
|
||||
.fs-login .alert-message { margin: 0 0 var(--fs-space-3-5); border-radius: var(--fs-radius); }
|
||||
/* a column, not a block: some auth plugins add a second action (Reset), and the
|
||||
* full-width buttons below carry margin:0 — they ended up glued together */
|
||||
.fs-login .cbi-page-actions {
|
||||
display: flex; flex-direction: column; gap: var(--fs-space-2-5);
|
||||
background: none; border: 0;
|
||||
padding: 0; margin: var(--fs-space-1-5) 0 0; text-align: start;
|
||||
}
|
||||
.fs-login .cbi-page-actions .btn,
|
||||
.fs-login .cbi-page-actions input[type="submit"] {
|
||||
width: 100%; box-sizing: border-box; min-height: var(--fs-ctl-h-lg); margin: 0; border-radius: var(--fs-radius-lg);
|
||||
background: var(--fs-accent); color: var(--fs-on-accent);
|
||||
border: 0; font-weight: var(--fs-weight-bold); font-size: var(--fs-type-lg);
|
||||
}
|
||||
.fs-login .cbi-page-actions .btn:hover { filter: var(--fs-hover-lift); }
|
||||
}
|
||||
@@ -1,513 +0,0 @@
|
||||
@layer page {
|
||||
/* Every !important here fights an inline `style=` — nothing else can, an inline declaration
|
||||
* outranking every author rule in every layer. luci-mod-status's 29_ports.js writes the ports
|
||||
* grid, its tiles and their inner rows with inline declarations: `display`,
|
||||
* `grid-template-columns` and `margin-bottom` on the grid, `margin`/`min-width`/`max-width` on
|
||||
* the tile, `display` on the heads, `text-align`/`font-size` on the traffic cell. Each flag is
|
||||
* matched against the property that inline style really sets; one fighting only another
|
||||
* footstrap rule would be redundant, `page` being the last layer. No cascade layer can replace
|
||||
* the flags that remain — keep them. */
|
||||
|
||||
/* The `.cbi-title .label` pill: theme/35-alerts.css (one owner — a copy here had
|
||||
* drifted). Only the overview-specific chevron toggle stays.
|
||||
* index.js emits a span with a raw "Hide"/"Show" text node + data-style (expanded =
|
||||
* inactive, collapsed = active); data-indicator='poll-status' is unique to these
|
||||
* toggles. font-size:0 hides the word, ::after borders draw the chevron.
|
||||
*
|
||||
* The card HEADER is the disclosure control now (fs-overview.js wireDisclosure()); this pill is
|
||||
* marked aria-hidden there and stays only as its glyph, so the border and fill that made it read
|
||||
* as its own 26px button are dropped — 16px, matching the rail toggle's own chevron glyph
|
||||
* (theme/20-shell.css `.fs-railtoggle .fs-ico`), and --fs-faint rather than the pill's --fs-dim,
|
||||
* a step quieter since it is decoration rather than a target now. */
|
||||
.cbi-title .label[data-indicator="poll-status"] {
|
||||
font-size: 0;
|
||||
width: 16px;
|
||||
height: 16px;
|
||||
padding: 0;
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
background: none;
|
||||
border: 0;
|
||||
color: var(--fs-faint);
|
||||
}
|
||||
/* The glyph itself is the Appearance fold's, to the byte — one chevron for "this opens", drawn
|
||||
* in two page files because the two hosts are a stock element keyed by attribute and one of
|
||||
* ours keyed by class, which no single selector list in one layer can carry. Pinned instead:
|
||||
* tools/mirror.mjs fails the build if the copies drift (styles/pages/80-appearance.css). */
|
||||
.cbi-title .label[data-indicator="poll-status"]::after {
|
||||
/* @mirror chevron/closed */
|
||||
content: "";
|
||||
width: 7px;
|
||||
height: 7px;
|
||||
border-right: 2px solid currentColor;
|
||||
border-bottom: 2px solid currentColor;
|
||||
border-radius: 1px;
|
||||
transform: rotate(45deg); /* closed: chevron down */
|
||||
margin-top: -2px; /* optical centring of the down chevron */
|
||||
transition: transform var(--fs-dur-move);
|
||||
/* @endmirror */
|
||||
}
|
||||
.cbi-title .label[data-indicator="poll-status"][data-style="inactive"]::after {
|
||||
/* @mirror chevron/open */
|
||||
transform: rotate(-135deg); /* open: chevron up */
|
||||
margin-top: var(--fs-space-0-5);
|
||||
/* @endmirror */
|
||||
}
|
||||
|
||||
/* The header itself (fs-overview.js wireDisclosure() stamps role="button"): a hand cursor for a
|
||||
* pointer user, a focus ring for a keyboard one — the same ring every other interactive control
|
||||
* in this theme draws (theme/35-alerts.css `.cbi-title .label:focus-visible`, the pill's own
|
||||
* former ring, now the header's).
|
||||
*
|
||||
* Two selectors, not one: fs-overview.js's headerEl() reads `.cbi-title h3, :scope > h3` because
|
||||
* the wrapper itself differs by release — 25.12 renders `.cbi-title > h3`, 24.10 a bare `<h3>`
|
||||
* straight inside `.cbi-section`, no `.cbi-title` at all. `[role="button"]` is the anchor either
|
||||
* way, so a heading wireDisclosure() left untouched — one with nothing to collapse — is never
|
||||
* matched. Measured on a 24.10 FORM: without the second arm the attributes and the keyboard
|
||||
* worked but `cursor` stayed `auto`, `box-shadow` `none`, and focus drew only the UA outline.
|
||||
* On a live 24.10 the arm does not fire at all today, and that is not a fault in it: OpenWrt
|
||||
* 24.10.8 renders no hide/show control on an Overview card, so wireDisclosure() stamps nothing
|
||||
* there and 0 of the page 14 `<h3>`s carry the role (measured on owlab owrt2410). The arm
|
||||
* guards a SHAPE of markup, not a release — it is what keeps the styling with the behaviour on
|
||||
* whichever release grows the control next. */
|
||||
:is(.cbi-title h3, .cbi-section > h3)[role="button"] {
|
||||
cursor: pointer;
|
||||
border-radius: var(--fs-radius-sm);
|
||||
}
|
||||
:is(.cbi-title h3, .cbi-section > h3)[role="button"]:focus-visible {
|
||||
outline: none;
|
||||
box-shadow: var(--fs-focus-ring);
|
||||
}
|
||||
|
||||
/* Every page-scoped selector below anchors on `:where(#view)[data-page="…"]`, not a bare
|
||||
* `#view[data-page="…"]`: an id contributes (1,0,0), and this file's deepest chain (the
|
||||
* progressbar row's `.td:first-child` selector, further down) already carries the rest past
|
||||
* tools/css-metrics.mjs's ratchet on its own — `#view` on top of it measured [1,9,0], over the
|
||||
* ceiling of [1,7,0]. `:where(#view)` matches the exact same single element (an id is a valid
|
||||
* :where() argument) but contributes ZERO specificity, so nothing about which element matches
|
||||
* changes — including the `> div` case in 40-sshkeys.css, where a wider `:where(#view,
|
||||
* .fs-content)` was tried and rejected: `.fs-content` is #view's ANCESTOR, so its own `> div`
|
||||
* arm would have matched #view itself (a `<div>`, per fs-router.js's stageView()) rather than
|
||||
* #view's children — a different element, not the same one at lower specificity. Measured after:
|
||||
* [1,7,0], the ceiling now held by an unrelated selector elsewhere in the sheet. */
|
||||
|
||||
/* An empty `.cbi-section` LuCI still renders when a stock include has nothing to show: title
|
||||
* "-", the poll pill its only content, 72px tall on the live Overview (seventh there — a
|
||||
* fixture is not proof of position, docs/findings.md "An empty card with `-` as its title").
|
||||
* Real and cosmetic, so fs-overview.js's hideEmptyCard() marks it and this drops it. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section.fs-ovl-empty { display: none; }
|
||||
|
||||
/* Stock overview layout: fs-overview.js wraps the stock System / Memory / Storage
|
||||
* sections in .fs-ovl; this is the grid only — System left across both rows, Memory +
|
||||
* Storage right. Stock styling and data untouched. */
|
||||
/* the chrome already shows the page title, so the stock <h2> is a duplicate */
|
||||
/* the chrome already shows the page title, so the stock <h2> is a duplicate.
|
||||
* Scoped through .fs-content, not #view: the heading is a SIBLING of #view (a
|
||||
* dispatcher template emits it before the div), so it needs the OUTGOING page's
|
||||
* identity for the whole staging window, spared until commitStage the same way
|
||||
* fs-sheets spares a page's stylesheets — fs-router.js. */
|
||||
.fs-content[data-page="admin-status-overview"] h2[name="content"] { display: none; }
|
||||
.fs-ovl {
|
||||
display: grid;
|
||||
grid-template-columns: 1fr 1fr;
|
||||
gap: var(--fs-space-4);
|
||||
/* no align-items: the default stretch is what levels the two columns' bottom edges */
|
||||
margin-bottom: var(--fs-card-gap); /* match stock .cbi-section spacing below the grid */
|
||||
}
|
||||
/* min-width:0 so a grid item shrinks to its TRACK, not to its content's min-width
|
||||
* (auto): a long System value (model/firmware) blew the single-column track past a
|
||||
* ~344px phone and clipped. */
|
||||
.fs-ovl > .fs-ovl-sys,
|
||||
.fs-ovl > .fs-ovl-mem,
|
||||
.fs-ovl > .fs-ovl-sto { margin: 0; min-width: 0; }
|
||||
.fs-ovl > .fs-ovl-sys { grid-column: 1; grid-row: 1 / 3; }
|
||||
.fs-ovl > .fs-ovl-mem { grid-column: 2; grid-row: 1; }
|
||||
.fs-ovl > .fs-ovl-sto { grid-column: 2; grid-row: 2; }
|
||||
@container fs-view (max-width: 800px) {
|
||||
.fs-ovl { grid-template-columns: 1fr; }
|
||||
.fs-ovl > .fs-ovl-sys,
|
||||
.fs-ovl > .fs-ovl-mem,
|
||||
.fs-ovl > .fs-ovl-sto { grid-column: 1; grid-row: auto; }
|
||||
}
|
||||
|
||||
/* Stock Port status (29_ports.js) reskin — pure CSS over the stock .ifacebox markup: icon-in-a-box
|
||||
* tiles become left-aligned cards (name + link dot, speed, TX/RX).
|
||||
*
|
||||
* Every rule is scoped to `.ifacebox:has(img[src*="/port_"])` because Network and Wireless reuse
|
||||
* the same .ifacebox classes and only Port tiles carry a port_*.svg icon. Do not unscope. Link
|
||||
* state is the icon src; child order: 1 name-head, 2 body (icon+speed), 3 zone bar, 4 body
|
||||
* (traffic). */
|
||||
/* The tracks pack the row instead of leaving air beside it, and every card is the same width.
|
||||
*
|
||||
* `repeat(auto-fit, minmax(126px, 200px))` reads as "shrink toward 126 when there are many
|
||||
* ports", and a grid does not work that way: `auto-fit` picks the track COUNT from the definite
|
||||
* MAX of the track function, so the count is always `floor(width / 200)` and the floor is
|
||||
* reached only when the column itself is narrower than that. An 11-port switch in a 1190px
|
||||
* column then gets 5 tracks of 200px in three rows with 150px of air beside every one.
|
||||
*
|
||||
* `minmax(92px, 1fr)` asks it the other way round: with an indefinite max the count comes from
|
||||
* the 92px min, so the row takes as many tiles as fit and `1fr` shares the remainder equally. */
|
||||
:where(#view)[data-page="admin-status-overview"] div:has(> .ifacebox img[src*="/port_"]) {
|
||||
/* 8px, not 10: at the floor below, the gap is what decides whether an 11-port switch takes one
|
||||
* row or ten-plus-one. A 1190px column fits 11 cards of 101px with 8px between them and 10
|
||||
* of 110px with 10px — the two px come off the gutter rather than off the card, because the
|
||||
* card's own floor is a measurement (see below) and the gap is not. No inline gap to fight,
|
||||
* so no flag. */
|
||||
gap: var(--fs-space-2);
|
||||
/* The floor is the traffic figure, and it is written as one: `▲ 1024.0 PiB` is the widest
|
||||
* string luci.js's `%1024.1mB` can produce, and the figures are `nowrap`, so a card too narrow
|
||||
* for one pushes it past its own padding instead of wrapping it. Measured rather than guessed:
|
||||
* stepping a card 1px at a time until the figure fits
|
||||
* on one line and the card stops overflowing gives 94px at Normal, 80 at Compact and 109 at
|
||||
* Large, so the text scales with the density axis and the gutter is already a token — each
|
||||
* setting gets its own answer (100 / 84 / 111) instead of one number that is wrong on two of
|
||||
* them. Held by a sweep of every width from 320 to 1900 in 10px steps at all three densities
|
||||
* with 24 cards of maximal content: 0 overflowing, 0 figures wrapped, narrowest card 93px. */
|
||||
--fs-port-min: calc(76px * var(--fs-density-type) + var(--fs-space-3) * 2);
|
||||
grid-template-columns: repeat(auto-fit, minmax(var(--fs-port-min), 1fr)) !important;
|
||||
margin-bottom: 0 !important;
|
||||
}
|
||||
/* Flex-wrap, not a grid with a threshold, and that is the fix for issue #7's shifted layout.
|
||||
*
|
||||
* As `display: grid; grid-template-columns: 1fr auto`, "do those two still fit side by side?"
|
||||
* was answered by a @container threshold — a proxy for a question about the CONTENT, calibrated
|
||||
* on English: `no link` is ~45px and `нет соединения` ~100px, while the traffic figures are
|
||||
* `nowrap` by design, so on a Russian router a down port that had carried traffic needed ~193px
|
||||
* inside a 178px content box, and a grid does not wrap — the figures overflowed under the next
|
||||
* card. With the counters at zero the same card fitted.
|
||||
*
|
||||
* Flexbox asks the real question for free: the two cells sit on one row while they fit and the
|
||||
* traffic drops to its own row when they do not. */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) {
|
||||
margin: 0 !important;
|
||||
min-width: 0 !important;
|
||||
/* The cap half of the pair that sizes the tile (the 126px min is on the wrapper's tracks —
|
||||
* see the note there): 200px is where a 2-port device stops growing, so two ports do not
|
||||
* become two half-page cards. It carries a flag because stock writes `max-width:100px`
|
||||
* inline and the ImmortalWrt fork writes its own. */
|
||||
max-width: 200px !important;
|
||||
/* …and `width` too, which stock never writes but a fork does: ImmortalWrt 25.12 carries
|
||||
* `style="margin:.25em;width:100px"` instead of stock's min/max pair, so releasing only the
|
||||
* two stock properties leaves the fork's fixed width in charge and the tile draws itself
|
||||
* 100px wide inside a 200px track. Naming all three costs nothing on stock. */
|
||||
width: auto !important;
|
||||
/* …and that is only half of it: the same fork writes `align-items:center;justify-items:center` on
|
||||
* the grid CONTAINER, so a tile's `justify-self` resolves to `center` — and a centred item
|
||||
* with `width: auto` is sized fit-content rather than stretched to its track, so releasing
|
||||
* the fork's width leaves the tile as narrow as its content and the rows spill to the right.
|
||||
* Stating the self-alignment needs no flag: the fork's declarations are `*-items` on the
|
||||
* PARENT, which only supply a value when the item says `auto`, and a direct `*-self` wins on
|
||||
* the cascade proper. */
|
||||
justify-self: stretch;
|
||||
align-self: stretch;
|
||||
text-align: start;
|
||||
background: var(--fs-panel2);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
/* the horizontal half is what --fs-port-min budgets for (the wrapper rule above), so it stays
|
||||
* --fs-space-3; the vertical half is one step tighter, because a port card is four short
|
||||
* lines and every px of leading between them shows. */
|
||||
padding: var(--fs-space-1-5) var(--fs-space-3);
|
||||
/* No `container-type` here, and its absence is the fix for a page that jumped every five seconds.
|
||||
* The card carried `container-type: inline-size` for two @container queries that were deleted
|
||||
* when the flex wrap below replaced their pixel threshold, and the containment was left
|
||||
* behind with nothing asking it anything.
|
||||
*
|
||||
* It was not free: the poll rewrites these cards once a tick, and a freshly built
|
||||
* size-contained box is laid out before the containment resolves, so everything below it
|
||||
* moved by the same amount on every tick. Bisected on the reporter's router down to this one
|
||||
* declaration.
|
||||
*
|
||||
* If a future rule needs a container query here, name the container on a wrapper the poll does
|
||||
* NOT replace, never on the card itself. */
|
||||
display: flex;
|
||||
/* `flex-direction: row` is NOT redundant: base/95-luci.css paints every .ifacebox
|
||||
* `display: inline-flex; flex-direction: column`, and the grid this rule used to declare
|
||||
* made that direction moot. Switching to flex woke it up — the name, the speed and the
|
||||
* figures stacked into a column, `flex-basis: 100%` became a HEIGHT, and flex-grow grew the
|
||||
* wrong axis. Cost an hour; state the axis. */
|
||||
flex-direction: row;
|
||||
flex-wrap: wrap;
|
||||
/* row-gap 0: every row inside the card carries its own spacing (the zone bar's margins, the
|
||||
* name's line box), and a gap on top of that is what made a five-line card 19px taller than
|
||||
* its content. */
|
||||
column-gap: var(--fs-space-2); row-gap: 0;
|
||||
align-items: baseline;
|
||||
}
|
||||
/* drop the stock icon */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) img { display: none; }
|
||||
/* base/95-luci.css draws a border-bottom on EVERY .ifacebox-head; the port card carries
|
||||
* two heads (the name, child 1, and the zone-colour line, child 3), so that is two grey
|
||||
* dividers stacked around the colour line. Drop them — the colour line is the only
|
||||
* divider this card wants. Page layer beats base, no !important needed. */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) .ifacebox-head { border-bottom: 0; border-radius: 0; }
|
||||
/* Zone-colour bar (child 3): WAN red, LAN green — the stock Port-status indicator that
|
||||
* distinguishes the Internet port from the LAN ports (issue #13). Its inner .zonebadge segments
|
||||
* already carry firewall.getZoneColorStyle() inline and a `.cbi-tooltip` naming the zone, so
|
||||
* this only PLACES it: a full-width colour line on its own row between the name and the
|
||||
* speed/traffic bodies, where it reads as the card's divider. `order` puts it there — without it
|
||||
* the bodies fall in source order and the bar splits speed from traffic. No `overflow` or
|
||||
* `border-radius`: both clip the absolutely-positioned tooltip. */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) > .ifacebox-head:nth-child(3) {
|
||||
order: 1;
|
||||
flex: 0 0 100%;
|
||||
width: 100%;
|
||||
margin: var(--fs-space-0-5) 0 var(--fs-space-1);
|
||||
}
|
||||
/* The name row, with no status dot: the speed line and the zone bar already report the carrier,
|
||||
* and a `-webkit-box` lays its children out as lines, so a dot could not stay in the flow — it
|
||||
* would join the name's text and be clipped with the second line. */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) > .ifacebox-head:first-child {
|
||||
/* Its own row, and `width` rather than `flex-basis: 100%`: the two agree now that the card's
|
||||
* size containment is gone (see above), and this form says what it means without depending on
|
||||
* the card's sizing staying definite. */
|
||||
flex: 0 0 auto;
|
||||
width: 100%;
|
||||
/* Two lines of name, never three, and never a name that decides how wide every card is.
|
||||
*
|
||||
* As a flex row with the name on one `nowrap` line, the LONGEST interface name becomes the
|
||||
* minimum width of every tile on the page. Wrapping alone is not the answer either: a name
|
||||
* with no space and no hyphen to break at gets three ragged lines from `overflow-wrap:
|
||||
* anywhere` and the row grows to fit them.
|
||||
*
|
||||
* So: a `-webkit-box` clamped to two lines, the one shape that both wraps AND puts an
|
||||
* ellipsis where it stops (`text-overflow` alone only ever truncates a single line).
|
||||
* `line-clamp` is written beside the prefixed pair for the engines that have taken the
|
||||
* unprefixed property; the prefixed spelling is the one that works everywhere today and is in
|
||||
* the spec's own compat section.
|
||||
*
|
||||
* No second line is reserved: `min-height: 2lh` was tried and cost 19px of empty air in every
|
||||
* card whose name does not wrap (a 5-port device stood 126px against 107px), while the grid
|
||||
* levels the row either way. The explicit `line-height` stays — it is what makes a wrapped
|
||||
* name's two lines the theme's rhythm rather than the font's own default. */
|
||||
/* ONE LINE, cut with an ellipsis. base/95-luci.css already says `white-space: nowrap`; what
|
||||
* this adds is the pair that makes the overflow READABLE instead of clipped — and `min-width`,
|
||||
* because a nowrap box's automatic minimum size is its whole text, which would put the longest
|
||||
* interface name back in charge of how wide every card is. */
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
line-height: var(--fs-leading);
|
||||
font-size: var(--fs-type); font-weight: var(--fs-weight); color: var(--fs-text);
|
||||
}
|
||||
/* no link (*_down.svg): dim name, to match the dim speed and the faded zone bar */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]):has(img[src*="_down.svg"]) > .ifacebox-head:first-child { color: var(--fs-dim); }
|
||||
/* speed: green when linked, dim when not */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) > .ifacebox-body:nth-child(2) {
|
||||
order: 2; /* below the zone-colour line (child 3, order 1) */
|
||||
font-size: var(--fs-type); font-weight: var(--fs-weight); color: var(--fs-good); text-align: start;
|
||||
/* `flex-grow: 1` means "I take the slack", which pushes the traffic to the right edge while
|
||||
* the two share a row. `margin-left: auto` on the traffic is wrong: Chrome counts it when
|
||||
* breaking lines, so the figures take a row of their own even on a card they fit.
|
||||
*
|
||||
* The text WRAPS, and the automatic minimum size is what keeps the wrap tidy. This field used
|
||||
* to be `nowrap`, which holds for the speeds themselves (`1GbE`, `10 GbE`) and breaks on the
|
||||
* no-link label — one short word in English, three in most other languages. `нет соединения`
|
||||
* measured 127px in a card that gives it 127 and was CLIPPED, not ellipsised: the reader saw
|
||||
* `нет соедине`. A label that cannot be read is worse than a card one line taller.
|
||||
*
|
||||
* NO `min-width: 0` with it. That would let the flex line squeeze this box to 77px — the
|
||||
* width left beside the port image, which shares this box — and the label then broke mid-word
|
||||
* (`соедине` / `ния`). Left at `auto` the box keeps its min-content, which for wrapping text
|
||||
* is the longest WORD, so the label breaks between words and the short speeds, having nothing
|
||||
* to wrap at, do not move at all. `overflow-wrap` is the last resort for a language whose
|
||||
* single word is wider than the card. */
|
||||
flex: 1 1 auto; white-space: normal; overflow-wrap: break-word;
|
||||
}
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) > .ifacebox-body:nth-child(2) br { display: none; }
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]):has(img[src*="_down.svg"]) > .ifacebox-body:nth-child(2) { color: var(--fs-dim); }
|
||||
/* traffic: tx over rx, as stock's <br> leaves them — CSS cannot reorder br-separated
|
||||
* text runs. The size flag fights the inline `font-size:80%`. */
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) > .ifacebox-body:nth-child(4) {
|
||||
order: 2; /* shares the speed's row, below the zone line */
|
||||
text-align: end;
|
||||
/* Grows but never shrinks. Growing is what anchors the figures to the card's right edge on either
|
||||
* row, since `text-align: right` then has a box that reaches that edge; `margin-left: auto`
|
||||
* would do the same on a shared row but Chrome counts it when breaking lines.
|
||||
* `flex-shrink: 0` keeps the nowrap figures from being squeezed into an overflow.
|
||||
*
|
||||
* `flex-basis: 100%` is what makes the figures take a row of their OWN always, not only on a
|
||||
* card too narrow to share one: decided per card by the content, a port with zero counters
|
||||
* keeps speed and traffic side by side while the port beside it pushes them apart — two
|
||||
* cards of the same width reading as two different layouts. */
|
||||
flex: 1 0 100%;
|
||||
}
|
||||
:where(#view)[data-page="admin-status-overview"] .ifacebox:has(img[src*="/port_"]) > .ifacebox-body:nth-child(4) > .cbi-tooltip-container {
|
||||
font-family: var(--fs-font-mono);
|
||||
/* 10px at Normal, a step below the theme's --fs-type-xs (11px), and it BUYS WIDTH: this figure
|
||||
* is the widest thing a port card must fit whole, so its size sets the card's floor — one pixel
|
||||
* here is 12px off every card, measured: the floor goes 106 → 94 at Normal, 92 → 80 at Compact
|
||||
* and 119 → 109 at Large. It stays on the density axis and off the type LADDER, which has no
|
||||
* rung here, because a figure read as a pair of numbers beside a label tolerates a step body
|
||||
* text would not. */
|
||||
/* The token, not a literal: --fs-type-2xs is one step below the ladder's smallest and exists
|
||||
* for these figures (02-tokens.css says why, and rounds it where round() exists). The flag
|
||||
* fights 29_ports.js's inline `font-size:80%`. */
|
||||
font-size: var(--fs-type-2xs) !important;
|
||||
color: var(--fs-dim);
|
||||
/* the tight leading, not the body one: these are two lines of figures read as a block, and
|
||||
* --fs-leading (1.5) spent 5px of card height on the space between them. */
|
||||
line-height: var(--fs-leading-tight);
|
||||
white-space: nowrap;
|
||||
/* Fights the element's own inline `text-align:left` (29_ports.js) so the up and down lines align
|
||||
* on their right edge and the units form a column. Scoped to a @container threshold it was
|
||||
* the pixel proxy the flex wrap above replaces: the cell now reaches the card's right edge
|
||||
* on whichever row it lands, so the alignment is one answer with no width to switch at. */
|
||||
text-align: end !important;
|
||||
}
|
||||
|
||||
/* Meter rows — any stock .table row carrying a .cbi-progressbar (Memory, Storage, CPU
|
||||
* load, Network connections, …): label + value on one line, bar below. Keyed off the
|
||||
* progressbar (:has), not per-section, so it covers every such row — including a
|
||||
* third-party one. The bar itself is theme/25-progressbar.css. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)):has(.cbi-progressbar) { display: block; }
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr:has(.cbi-progressbar) {
|
||||
display: grid;
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
gap: var(--fs-space-1) var(--fs-space-2-5);
|
||||
/* Halved from 8/10. A progressbar row is a LABEL over a 10px bar — the row is already
|
||||
* two lines tall, so the outer padding was doing the work of a gap twice over and Memory
|
||||
* and Storage read as mostly empty space. The bottom stays the larger of the two: the bar
|
||||
* sits on that edge, and equal padding reads as the bar hanging low in its row. */
|
||||
padding: var(--fs-space-1) 0 var(--fs-space-1-5);
|
||||
border: 0;
|
||||
position: relative;
|
||||
}
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr:has(.cbi-progressbar):last-child { padding-bottom: var(--fs-space-0-5); }
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr:has(.cbi-progressbar) .td {
|
||||
display: block;
|
||||
/* beats base's `.td[width="33%"]` with no flag: the includes set a width
|
||||
* ATTRIBUTE, not an inline style, so a later layer wins. */
|
||||
width: auto;
|
||||
padding: 0;
|
||||
border: 0;
|
||||
}
|
||||
/* label. Undoes the key/value `white-space: nowrap` on a first column: a mount point
|
||||
* ("192.168.3.26:/volume1/… (/mnt/hdd_isync)") is one unbreakable line, so the row's
|
||||
* min-content width blew past the card and Memory/Storage stopped shrinking on a phone.
|
||||
* padding-inline-end = the gutter for the value, which is pinned over the bar's far edge
|
||||
* (::after, out of flow — nothing else reserves space for it). */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr:has(.cbi-progressbar) .td:first-child {
|
||||
grid-column: 1; grid-row: 1;
|
||||
align-self: center;
|
||||
min-width: 0;
|
||||
white-space: normal;
|
||||
/* overflow-wrap dropped — base/40-tables.css breaks every cell; the copy that stood here
|
||||
* moved nothing against 267 matching cells. */
|
||||
padding-inline-end: min(230px, 50%);
|
||||
/* colour and weight are the shared label rule at the end of this file; the size is here
|
||||
* because it is this row's geometry, not its typography */
|
||||
font-size: var(--fs-type);
|
||||
}
|
||||
|
||||
/* On a narrow card the value takes its own line — a reserve cannot be made to fit there.
|
||||
*
|
||||
* The value is out of flow (the bar's ::after, pinned over its far edge), so the only thing
|
||||
* keeping it off the label is that padding, and the two are sized by different things: the
|
||||
* padding is a fraction of the CARD, the value is however wide LuCI's formatter made it.
|
||||
* `16.66 GiB / 16.66 GiB (100%)` measures 218px against 190px of reserve on a 380px phone card,
|
||||
* so the figure printed straight through the end of the label.
|
||||
*
|
||||
* Below the threshold the label keeps the whole line and the bar drops by one --fs-type-xs line,
|
||||
* which is the band the value then sits in. `fs-view` rather than a container of its own: adding
|
||||
* `container-type` to the card would size-contain a box the port tiles deliberately keep
|
||||
* uncontained (see the note by `padding` above). */
|
||||
@container fs-view (max-width: 560px) {
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr:has(.cbi-progressbar) .td:first-child {
|
||||
padding-inline-end: 0;
|
||||
}
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr:has(.cbi-progressbar) .cbi-progressbar {
|
||||
margin-block-start: calc(var(--fs-type-xs) * var(--fs-leading));
|
||||
}
|
||||
}
|
||||
/* bar cell — spans full width on row 2 */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr:has(.cbi-progressbar) .td:nth-child(2) {
|
||||
grid-column: 1 / -1; grid-row: 2;
|
||||
}
|
||||
|
||||
/* Drop the per-row dividers theme/30-tables.css adds (.cbi-section .table .td) —
|
||||
* cleaner card. No !important: that rule is `theme`, this file is `page`, so the later
|
||||
* layer already wins.
|
||||
*
|
||||
* Keyed on the table's SHAPE rather than on the three cards the grid happens to name: a
|
||||
* key/value table is one with no header row, which is the same test the meter rows above
|
||||
* already use. Naming `.fs-ovl-mem/-sto` left System ruled at 1px per row — nine dividers down
|
||||
* a card whose two columns are a name and its value, where the alignment already says which is
|
||||
* which — and gave a third-party include of the same shape nothing at all. A DATA table
|
||||
* (`.tr.table-titles` present: DHCP leases, the wifi station list) keeps its dividers: there
|
||||
* the row is one record among many and the rule is what separates the records. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .td,
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .th,
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .tr { border-bottom: 0; }
|
||||
/* Its own rule, not a fourth line in the list above: `.cbi-value` carries no `:has()`, and a
|
||||
* selector list is not forgiving — below the browser floor the whole list would be discarded,
|
||||
* dividers and all (npm run css-floor, .claude/rules/css.md). */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .cbi-value { border-bottom: 0; }
|
||||
|
||||
/* The name in a key/value row is the QUIET half — the figure beside it is what the card is
|
||||
* read for. It came out at --fs-weight (600) in --fs-text, i.e. heavier and brighter than the
|
||||
* value it introduces, which is the ranking inverted: four bold lines down a Memory card
|
||||
* competing with the four numbers they label. --fs-dim at normal weight is what the System
|
||||
* table's first column already resolved to, so the meter cards now read as the same family.
|
||||
* Data tables are excluded by the same header-row test as the dividers above: there the first
|
||||
* column is a record's name, not a caption. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .td:first-child {
|
||||
font-weight: var(--fs-weight-normal);
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
|
||||
/* ---- the active interface box ----
|
||||
*
|
||||
* theme/45-misc.css fills `.ifacebox-head.active` with --fs-accent and inks it --fs-on-accent.
|
||||
* On a form that is one small badge; on the Overview it is a full-bleed bar of saturated colour
|
||||
* across the card — three of them at once here (IPv4 Upstream, radio0, radio1), each louder
|
||||
* than the data underneath and than the page's own controls. The state it encodes is "this
|
||||
* interface is up", which is a STATUS, so it is said in the status colour and in the text
|
||||
* rather than in a fill: --fs-good on the same --fs-panel2 every other head carries.
|
||||
*
|
||||
* Scoped to this page deliberately: the same head on Network -> Interfaces sits among many
|
||||
* boxes where the fill is doing real work telling them apart. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .ifacebox .ifacebox-head.active {
|
||||
background: var(--fs-panel2);
|
||||
color: var(--fs-good);
|
||||
font-weight: var(--fs-weight);
|
||||
}
|
||||
|
||||
/* `L.itemlist` wraps every caption in <strong>, which theme/30-tables.css leaves at 700 — so
|
||||
* inside an interface box the captions (Protocol, Address, Gateway, DNS) are the boldest text
|
||||
* on the card and the addresses they introduce are not. Same inversion as the key/value rule
|
||||
* above, same answer; the value keeps --fs-text and needs no rule of its own. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .ifacebox-body strong {
|
||||
font-weight: var(--fs-weight-normal);
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
|
||||
/* The meter's own figure, promoted to match the label it now outranks.
|
||||
*
|
||||
* theme/25-progressbar.css prints `attr(title)` above the bar at --fs-type-xs in --fs-dim,
|
||||
* which was the right pairing while the label beside it was 600 in --fs-text. With the label
|
||||
* moved down (above), a dim 11px figure left the row with nothing at full strength: on Memory
|
||||
* that is four bars whose only readable text is the caption. The number is what the card is
|
||||
* for, so it takes the body size and the body ink; the bar and the placement are untouched.
|
||||
*
|
||||
* Overview only. The same meter on Software and in the package manager sits in a form row
|
||||
* where the value is beside its own field label, not carrying the row on its own. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:not(:has(.tr.table-titles)) .cbi-progressbar::after {
|
||||
font-size: var(--fs-type);
|
||||
color: var(--fs-text);
|
||||
}
|
||||
|
||||
/* Row height in the Overview's DATA tables (DHCP leases, the wifi station list).
|
||||
*
|
||||
* theme/30-tables.css pads a data cell for a page that IS a table, where the row is the unit of
|
||||
* work and the padding is its hit target. On the Overview the same table is a card's contents,
|
||||
* read at a glance and never clicked except on its buttons, and eight leases at that height are
|
||||
* most of a screen: the DHCP card measures 740px against a System card of 440. One step down
|
||||
* the space ladder, so it follows the density axis like everything else, and only here. */
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:has(.tr.table-titles) .td,
|
||||
:where(#view)[data-page="admin-status-overview"] .cbi-section .table:has(.tr.table-titles) .th {
|
||||
padding-block: var(--fs-space-1-5);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
@layer page {
|
||||
/* Software disk-space bar -> the overview Memory/Storage meter: label + value on one
|
||||
* line, bar below (the value is the .cbi-progressbar title, lifted out by ::after).
|
||||
* Scoped by #view[data-page], NOT by :has(#disk-space-label) — 24.10 ships no such id.
|
||||
* #view, not body: the attribute lives on the view itself so the outgoing page keeps its
|
||||
* own rules for the whole staging window (fs-router.js, commitStage).
|
||||
* `:where(#view)`, not bare `#view`: zeroes the id's specificity without changing which
|
||||
* element matches — 20-overview.css, top of `@layer page`, has the full reasoning and the
|
||||
* measured numbers (tools/css-metrics.mjs's ceiling). */
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls > div:first-child { position: relative; display: block; flex: 1 1 100%; width: 100%; margin: 0 0 var(--fs-space-1-5); }
|
||||
|
||||
/* The package list's row SHAPE. #packages is a DATA table (`<table class="table" id="packages">`,
|
||||
* no .cbi-section-table class; fs-select.js tags it .fs-dt off its .tr.cbi-section-table-titles
|
||||
* header), so it takes the shared card from
|
||||
* theme/30-tables.css when measured too narrow; this only changes how a row READS, a package
|
||||
* being a name plus a few short facts, so label-left / value-right on one line beats the
|
||||
* half-width pairs a config row wants.
|
||||
*
|
||||
* No @container guard, and do not re-add one: overflow is the trigger, and fs-select.js
|
||||
* measures it. */
|
||||
/* ---- the package NAME is an identifier: do not let the column collapse under it ----
|
||||
*
|
||||
* base/40-tables.css gives every data cell `overflow-wrap: anywhere` (theme/30-tables.css
|
||||
* narrows it to `break-word` for as long as a data table is a table), and `anywhere` — unlike
|
||||
* `break-word` — also lowers the column's min-content to a single character. Version and Size
|
||||
* are `nowrap` and cannot shrink, so auto table layout takes the whole shortfall out of column
|
||||
* 1: measured with the filter on "app", the name column came out 81-101px — narrower than
|
||||
* Size (88px) — and 6 of the first 8 names rendered broken mid-word, a hyphen making it worse
|
||||
* by offering a legal break point.
|
||||
*
|
||||
* nowrap here does not mean "never wrap": it makes the overflow HONEST, which is what
|
||||
* fs-select.js's measurement needs — where the row genuinely does not fit, the table cards. It
|
||||
* is the same trap idTower() works around in fs-select.js: `anywhere` hides the overflow by
|
||||
* shredding a cell, so nothing is left for fit.overflows() to read. Verified 560-1440px: 0
|
||||
* broken names, no table overflow, and the card threshold unchanged. */
|
||||
#packages:not(.fs-stacked) .tr > .td:first-child { white-space: nowrap; }
|
||||
|
||||
/* `:not(...)` on the header rows, and it is load-bearing: this selector carries an ID, so it
|
||||
* is (1,1,0) in the PAGE layer — it beat theme/30-tables.css's
|
||||
* `.table.fs-stacked .tr.cbi-section-table-titles { display: none }` and put the column
|
||||
* header back on screen in card mode, where every cell already prints its own label. */
|
||||
#packages.fs-stacked .tr:not(.cbi-section-table-titles):not(.cbi-section-table-descr) {
|
||||
display: block; padding: var(--fs-space-3) var(--fs-space-4);
|
||||
}
|
||||
/* ---- the value is not one flex item, and space-between tears it apart ----
|
||||
*
|
||||
* A card row is label-left / value-right, which `justify-content: space-between` spreads over
|
||||
* the ::before and the cell's content. But flex makes every ELEMENT its own item, and the
|
||||
* filter on this page wraps each match in `<ins>`, so a matched name is two items and
|
||||
* space-between pushes them to opposite edges — the package name read as `luc` … 85px …
|
||||
* `i-app-acl`.
|
||||
*
|
||||
* So do not distribute the free space BETWEEN the items — hand it all to the label, and
|
||||
* everything else packs flush right in DOM order, however many elements the value is. */
|
||||
#packages.fs-stacked .td {
|
||||
display: flex; align-items: baseline; justify-content: flex-end;
|
||||
gap: 0; padding: var(--fs-space-1) 0; border: 0; text-align: end;
|
||||
/* `min-width: 0` and `width: auto` are not restated: theme/30-tables.css sets both on
|
||||
* `.table.fs-stacked .td`, which this table is one of, and switching them off here moved
|
||||
* nothing across 500 matching cells. `text-align: end` above IS this file's own — it
|
||||
* overrides that rule's `start`. */
|
||||
flex: none;
|
||||
}
|
||||
/* An auto inline-end margin is what replaces space-between: it eats the whole free line, so the
|
||||
* value packs flush against the far edge as one unbroken run. The inline-end padding keeps a gutter when the row is
|
||||
* full and the auto margin collapses to nothing (the `gap` used to do that, but a gap applies
|
||||
* between EVERY pair of items — including the two halves of a highlighted name). */
|
||||
#packages.fs-stacked .td[data-title]::before {
|
||||
content: attr(data-title); flex: 0 0 auto; text-align: start; margin-bottom: 0;
|
||||
margin-inline-end: auto; padding-inline-end: var(--fs-space-3-5);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight); letter-spacing: var(--fs-eyebrow-tracking);
|
||||
color: var(--fs-eyebrow-color); white-space: nowrap;
|
||||
}
|
||||
/* Column 4 = Description. NOT `[data-title="Description"]`, which is a translated string and
|
||||
* `tools/css-i18n.mjs` fails the build on one. It used not to match even in English: LuCI builds
|
||||
* these cells from the heading's `innerText` (ui.js, `data-title`), which is RENDERED text, and
|
||||
* `.th` was uppercased here — so the attribute said "DESCRIPTION" and the literal matched ZERO
|
||||
* elements on every router (measured). The uppercase is gone (theme/30-tables.css, issue #39) and
|
||||
* the attribute now carries the app's own case; the column index is still the right anchor.
|
||||
* Columns: 1 Package name | 2 Version | 3 Size | 4 Description | 5 actions. */
|
||||
/* `overflow-wrap` dropped: base/40-tables.css breaks every cell now and this copy moved nothing
|
||||
* against 100 matching cells. `word-break` has now gone the same way for a different reason: its
|
||||
* neutraliser in theme/30-tables.css stopped excusing carded tables, so this sat under a flag and
|
||||
* could not be read. Nothing renders differently — `break-word` is `word-break: normal` plus
|
||||
* `overflow-wrap: anywhere` and the theme already gives every stacked cell the second half;
|
||||
* measured at 390px, this cell is 322 x 103 px on either side of the change. */
|
||||
#packages.fs-stacked .td:nth-child(4) { display: block; text-align: start; }
|
||||
#packages.fs-stacked .td:nth-child(4)::before { display: block; margin-bottom: var(--fs-space-1); }
|
||||
#packages.fs-stacked .td.cbi-section-actions { justify-content: flex-end; margin-top: var(--fs-space-1-5); }
|
||||
#packages.fs-stacked .td.cbi-section-actions::before,
|
||||
#packages.fs-stacked .td:not([data-title])::before { content: none; }
|
||||
/* The "Disk space:" caption, keyed on WHAT IT SITS BESIDE rather than on `#disk-space-label`:
|
||||
* that id is 25.12+ only (25.12 emits `E('label',{'id':'disk-space-label'}, …)`, 24.10's
|
||||
* package-manager.js a bare `E('label',{}, …)`), so an id rule is dead on 24.10 and the caption
|
||||
* keeps base's 250px-wide label. The disk section is the only `label` immediately followed by a
|
||||
* `.cbi-progressbar`, which is the discriminator theme/90-responsive.css already uses for the
|
||||
* same element.
|
||||
*
|
||||
* Not `:has(:where(+ .cbi-progressbar))`: a leading combinator makes it a RELATIVE selector, and
|
||||
* only `:has()` accepts one — `:where()` takes a plain complex-selector list, so wrapping it
|
||||
* there makes the whole rule invalid and the browser drops it, which stylelint and css-metrics
|
||||
* both parse happily. */
|
||||
:where(#view)[data-page="admin-system-package-manager"] label:has(+ .cbi-progressbar) {
|
||||
display: block; margin: 0; font-size: var(--fs-type); font-weight: var(--fs-weight); color: var(--fs-dim);
|
||||
}
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
@layer page {
|
||||
/* SSH-Keys renders its whole view as a single bare <div> in #view with no .cbi-section wrapper, so
|
||||
* its text sits frameless over the wallpaper while every other page gets an opaque card. There
|
||||
* is no section markup to hook, so that lone wrapper is given the same card (the values are
|
||||
* theme/30-tables.css's `.cbi-section`).
|
||||
*
|
||||
* Scoped to this page on purpose: a general "card any bare #view > div" was tried and reverted —
|
||||
* it also wrapped whole tabbed views (Startup). Other bare-view pages get their own entry
|
||||
* here.
|
||||
*
|
||||
* `:where(#view)`, not bare `#view`: zeroes the id's specificity while still matching the exact
|
||||
* same element, so `> div` still means "child of #view" — 20-overview.css, top of
|
||||
* `@layer page`, has the full reasoning, including why a wider `:where(#view, .fs-content)`
|
||||
* was rejected precisely because of this `>` combinator. */
|
||||
:where(#view)[data-page="admin-system-admin-sshkeys"] > div {
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
padding: var(--fs-space-4);
|
||||
}
|
||||
|
||||
/* An authorized_keys entry is a ~400-char base64 blob: the one dynlist that must not
|
||||
* take theme/60-inputs.css's 440px cap. Must live in `page` — in `base` it was dead,
|
||||
* since a layer beats specificity and theme's plain `.cbi-dynlist` capped it anyway. */
|
||||
:where(#view)[data-page="admin-system-admin-sshkeys"] .cbi-dynlist {
|
||||
max-width: none;
|
||||
}
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
@layer page {
|
||||
/* DHCP leases. The .leases/.leases6 tables (JS-tagged .fs-dt) carry 7-8 mono columns, and the
|
||||
* theme's general rule lets any data cell break to fit, which splits an IPv4 or a MAC over two
|
||||
* lines. So: every cell on ONE line, and only the long opaque columns (DUID, the IPv6 list, the
|
||||
* hostname) may wrap.
|
||||
*
|
||||
* Do not re-add a card-stack copy here at a container threshold of its own: the nowrap IS this
|
||||
* table's ~736px floor, and a floor is what makes a table OVERFLOW when the room runs out —
|
||||
* fs-select.js measures that and sets .fs-stacked, so the threshold is discovered and the card
|
||||
* lives once, in theme/30-tables.css. `:not(.fs-stacked)` is the whole guard: once carded, the
|
||||
* cells must wrap again.
|
||||
*
|
||||
* `.lases` is not a typo here — it is upstream's spelling for the IPv4 table on 24.10
|
||||
* (`class="table lases"`), corrected to `leases` on 25.12+. Dropping it made this whole file
|
||||
* dead on 24.10: measured there with the theme active, every one of the five cells computed
|
||||
* `white-space: normal` — issue #7's exact symptom. Both spellings are matched here. */
|
||||
#view table.fs-dt:is(.leases, .lases, .leases6):not(.fs-stacked) .td { white-space: nowrap; }
|
||||
/* ---- never match a `data-title` VALUE: it is a translated, render-dependent string ----
|
||||
*
|
||||
* LuCI fills `data-title` from the column HEADING, so on a localised router the value is the
|
||||
* translation and an English literal in a selector never matches — the rule is dead in ~40
|
||||
* languages while looking alive here, which is how issue #7 survived.
|
||||
*
|
||||
* Worse, for tables whose rows LuCI builds from the heading's `innerText` the value is what the
|
||||
* heading RENDERS, so any transform the theme puts on `.th` rewrites the string the theme's own
|
||||
* CSS matches on. That is not hypothetical: `.th` carried `text-transform: uppercase` until
|
||||
* issue #39, and every such rule matched nothing on any router in any language.
|
||||
*
|
||||
* Anchor on the COLUMN instead: `tools/css-i18n.mjs` fails the build on any `[data-title="…"]`
|
||||
* value match, so this cannot come back. */
|
||||
|
||||
/* The long opaque columns, which may wrap. overflow-wrap:anywhere (not word-break) takes the
|
||||
* natural breaks first — the hyphens in a hostname — and only splits mid-token when nothing else
|
||||
* fits.
|
||||
*
|
||||
* ---- count from the END, never from the start ----
|
||||
*
|
||||
* The leading column is optional on 25.12+: `40_dhcp.js` opens both tables with an Interface
|
||||
* column only where the router serves DHCP through odhcpd, so every `:nth-child()` shifts by one
|
||||
* on exactly those routers and is invisible on the others. The TRAILING columns are identical
|
||||
* either way, so `:nth-last-child()` cannot shift.
|
||||
*
|
||||
* 25.12+ .leases [Interface] Hostname IPv4 MAC DUID IAID Remaining Static
|
||||
* -7 -6 -5 -4 -3 -2 -1
|
||||
* .leases6 [Interface] Hostname IPv6 DUID IAID Remaining Static
|
||||
* -6 -5 -4 -3 -2 -1
|
||||
* 24.10 .lases Hostname IPv4 MAC Remaining Static (no DUID/IAID column at all)
|
||||
* -5 -4 -3 -2 -1
|
||||
* .leases6 Host IPv6 DUID Remaining Static
|
||||
* -5 -4 -3 -2 -1
|
||||
*
|
||||
* so the hostname, the IPv6 list and DUID may wrap, while IPv4/MAC/IAID and the two short
|
||||
* trailing columns keep the nowrap above. BOTH tables are split on column COUNT, never on the
|
||||
* release and never on the class name: a one-character upstream fix to `lases` would otherwise
|
||||
* hand the 24.10 table the 25.12 column plan and silently un-fix issue #7. base/95-luci.css
|
||||
* states that as the rule for release-conditioned styling.
|
||||
*
|
||||
* The count test is wrapped in `:where()` so it costs NOTHING: `:has()` otherwise takes its
|
||||
* argument's specificity, and `.tr.table-titles > :nth-child(6)` alone pushed the selector to
|
||||
* [1,8,1], past the sheet's [1,7,0] ceiling. */
|
||||
#view table.fs-dt:is(.leases, .lases):has(:where(.tr.table-titles > :nth-child(6))):not(.fs-stacked)
|
||||
.td:is(:nth-last-child(7), :nth-last-child(4)),
|
||||
#view table.fs-dt.leases6:has(:where(.tr.table-titles > :nth-child(6))):not(.fs-stacked)
|
||||
.td:is(:nth-last-child(6), :nth-last-child(5), :nth-last-child(4)),
|
||||
#view table.fs-dt:is(.leases, .lases):not(:has(:where(.tr.table-titles > :nth-child(6)))):not(.fs-stacked)
|
||||
.td:nth-last-child(5),
|
||||
#view table.fs-dt.leases6:not(:has(:where(.tr.table-titles > :nth-child(6)))):not(.fs-stacked)
|
||||
.td:is(:nth-last-child(5), :nth-last-child(4), :nth-last-child(3)) {
|
||||
/* `white-space` is the whole rule now: it is what re-permits wrapping for these columns
|
||||
* against the nowrap above — and the nowrap is also what keeps IPv4/MAC unbroken, so the
|
||||
* column plan does not rest on overflow-wrap at all. The break itself is base's default for
|
||||
* every cell (base/40-tables.css); the copy that stood here moved nothing against 164 cells. */
|
||||
white-space: normal;
|
||||
}
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
@layer page {
|
||||
/* Associated stations (Overview and Network -> Wireless render the same `.assoclist` table).
|
||||
*
|
||||
* No `white-space: nowrap` on the MAC column any more, though one stood here while
|
||||
* `overflow-wrap: anywhere` split `48:E1:5C:9F:26:20` at whatever character landed on the edge
|
||||
* of a ~103px column, every time (issue #5). A MAC has no break opportunity in it — a colon is
|
||||
* not one — so the honest floor theme/30-tables.css gives a data table keeps the whole address
|
||||
* in one piece, for every table that shows one rather than for this one.
|
||||
*
|
||||
* Do not nowrap the Signal and Rate columns either: that makes the modulation string
|
||||
* ("229 Mbit/s, 20 MHz, HE-MCS 9, HE-NSS 2") an unbreakable ~300px block that eats the row and
|
||||
* crushes the Network column. A wide cell that CAN break is the lesser evil, and that is what
|
||||
* rung 3 of fs-select.js's remedy ladder chooses when it has to choose: the widest breakable
|
||||
* column gives way, never the identity column. */
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
@layer page {
|
||||
/* The filter bar, which LuCI writes as a run of inline text. Both log views build one —
|
||||
* `tools/views.js` (LogreadBox: the System Log and every third-party page built on it) and
|
||||
* `view/status/dmesg.js` (the Kernel Log) — emitting bare `<div style="margin-bottom:10px">`
|
||||
* rows of label/control pairs with nothing around a pair. Inline flow then breaks wherever the
|
||||
* line runs out, and on a phone that is between a label and the control it names — or inside
|
||||
* the label itself.
|
||||
*
|
||||
* One rule of layout, two tiers, no per-field exceptions. The rows are flex, so a wrap can only
|
||||
* fall BETWEEN items and a label is one unbreakable item; a field may shrink to share the line.
|
||||
*
|
||||
* Scoped by SHAPE: `data-page` differs between the two logs and a third-party box has neither,
|
||||
* while both wrap their rows in `#content_syslog` and a filter row is exactly one that opens
|
||||
* with a `<label>` — the scroll-to-end button's row and the log itself do not.
|
||||
*
|
||||
* Only the ROW gap is ours: the inline `margin: 0 5px` LuCI writes on the labels stays as the
|
||||
* horizontal spacing, so nothing here has to fight an inline style. */
|
||||
#content_syslog > div:has(> label) {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
row-gap: var(--fs-space-2);
|
||||
}
|
||||
#content_syslog > div:has(> label) > label { white-space: nowrap; }
|
||||
#content_syslog > div:has(> label) > :is(select, input) {
|
||||
/* shrink, never grow. `max-width` is not the same lever as `min-width` and both are needed:
|
||||
* one lets a flex item go below its content, the other clamps a `<select>` that carries the
|
||||
* theme's own 210px width — measured at 360px, where both selects hung 3px past the view. */
|
||||
flex: 0 1 auto;
|
||||
min-width: 0;
|
||||
max-width: 100%;
|
||||
}
|
||||
|
||||
/* THE TWO TIERS ARE DISJOINT CONTAINER QUERIES, not a base rule and an override: each states one
|
||||
* layout in full, so neither can win or lose against the other by source order — the trap the
|
||||
* first version of this file fell into, where a later generalisation silently out-specified two
|
||||
* rules that were meant to override it. */
|
||||
@container fs-view (width > 560px) {
|
||||
/* room for a filter and a half at least: the free-text filter takes what the named fields
|
||||
* leave. `input:not([type])` IS that filter, in both views: every other input under
|
||||
* `#content_syslog` states a type (`checkbox` for the four inverts and the sort flag, `number`
|
||||
* for Max rows and for the Kernel Log's boot-time range), and both views leave the text one
|
||||
* untyped — so nothing here keys on an id or has to know how many fields a row holds. */
|
||||
#content_syslog > div:has(> label) > input:not([type]) { flex: 1 1 12rem; }
|
||||
}
|
||||
@container fs-view (width <= 560px) {
|
||||
/* One field per line, its labels on the line above it. Wrapping alone fills each line greedily,
|
||||
* so a leading label rides the end of the previous line while the field it belongs to opens the
|
||||
* next — and no flex rule can bind a label to the field that follows it. A full-width basis
|
||||
* can: the field always starts a line, so whatever labels precede it sit together above it.
|
||||
* It costs one line per filter on a phone and holds for every row of both views without any
|
||||
* of them being named. A checkbox is not a field and keeps its 16px. */
|
||||
#content_syslog > div:has(> label) > :is(select, input:not([type="checkbox"])) {
|
||||
flex-basis: 100%;
|
||||
}
|
||||
}
|
||||
|
||||
/* System Log / Kernel Log: the whole log is a readonly `<textarea id="syslog">` in a bare div, not
|
||||
* in a .cbi-value-field. Stock bootstrap pairs its generic `input, textarea { width: 210px }`
|
||||
* with `#syslog { width: 100% }` and wins on specificity — but this theme's generic field box
|
||||
* lives in the `theme` layer, and a layer beats specificity, so the same pair in `base` loses and
|
||||
* the log rendered as a 210px column (measured on 25.12). The rule is absorbed here, above the
|
||||
* generic's layer. Mono at the data tables' size, `pre` because log lines are lines, and a
|
||||
* vertical-only resize grip — a sideways grip would just re-create the squeeze. */
|
||||
#syslog {
|
||||
width: 100%;
|
||||
min-height: 500px;
|
||||
color: var(--fs-text);
|
||||
margin-bottom: var(--fs-space-4);
|
||||
font-family: var(--fs-font-mono);
|
||||
font-size: var(--fs-type);
|
||||
line-height: var(--fs-leading);
|
||||
white-space: pre;
|
||||
resize: vertical;
|
||||
}
|
||||
}
|
||||
@@ -1,224 +0,0 @@
|
||||
@layer page {
|
||||
/* The Appearance controls, appended to System -> System by fs-appearance.js.
|
||||
*
|
||||
* This was a popover on <body>, capped to the viewport because eighteen axes plus an upload
|
||||
* panel do not fit a floating card on a phone in landscape. As part of a page none of that
|
||||
* applies: the sections are ordinary .cbi-section cards, the width is the content column's and
|
||||
* the scroll is the document's — so the placement, the max-height clamp, the fade-in and the
|
||||
* [hidden] pair a floating card needed are all gone.
|
||||
*
|
||||
* What is left in the theme's own namespace — the `.fs-ap-*` folds, sections, previews and
|
||||
* version line below — lives in the page layer rather than the theme layer, because this is
|
||||
* the only page that draws it: an axis control is not chrome. */
|
||||
|
||||
.fs-ap { display: flex; flex-direction: column; gap: var(--fs-space-5); }
|
||||
/* The page note (fs-appearance.js). Only the outer margins: `.alert-message p` carries
|
||||
* --fs-space-1 top and bottom, which at the box's own edges adds to the panel's padding and
|
||||
* makes a two-sentence note look loose against every other alert on the theme. */
|
||||
.fs-ap-note p:first-child { margin-top: 0; }
|
||||
.fs-ap-note p:last-child { margin-bottom: 0; }
|
||||
/* Grouping headings INSIDE the tab pane, not cards: the pane is already inside the stock
|
||||
* .cbi-section card, and a second border around each group is a box in a box. A hairline above
|
||||
* each group does the same job — except for the first, which sits under the tab strip. */
|
||||
/* the heading row. On a plain group it holds the title; on a FOLDED one the whole row is the
|
||||
* disclosure button (fs-appearance.js) — full width, so the target is the heading rather than a
|
||||
* chevron nobody can hit on a phone. */
|
||||
/* the heading row spans the section on its own now that the rows stack */
|
||||
button.fs-ap-fold {
|
||||
display: flex; align-items: center; justify-content: space-between; gap: var(--fs-space-3);
|
||||
inline-size: 100%; padding: 0; margin: 0;
|
||||
background: none; border: 0; cursor: pointer; text-align: start; color: inherit;
|
||||
}
|
||||
button.fs-ap-fold:hover h4 { color: var(--fs-accent); }
|
||||
button.fs-ap-fold:focus-visible { outline: none; box-shadow: var(--fs-focus-ring-solo); border-radius: var(--fs-radius-sm); }
|
||||
/* The chevron: the same box with a two-border ::after that the overview's card toggles use
|
||||
* (styles/pages/20-overview.css) — one
|
||||
* chevron for "this panel opens", drawn here and there rather than an SVG in one place and
|
||||
* borders in the other, with the glyph pinned as @mirror chevron/* so the copies cannot drift.
|
||||
*
|
||||
* It turns on the SAME attribute that tells a screen reader the state, so the two cannot
|
||||
* disagree. Rotated with `transform` rather than the individual `rotate` property, because that
|
||||
* is what the overview's copy does and the pair must look identical mid-animation. */
|
||||
.fs-ap-chev {
|
||||
flex: 0 0 auto; inline-size: 26px; block-size: 26px;
|
||||
display: inline-flex; align-items: center; justify-content: center;
|
||||
color: var(--fs-dim); border-radius: var(--fs-radius-sm);
|
||||
}
|
||||
.fs-ap-chev::after {
|
||||
/* @mirror chevron/closed */
|
||||
content: "";
|
||||
width: 7px;
|
||||
height: 7px;
|
||||
border-right: 2px solid currentColor;
|
||||
border-bottom: 2px solid currentColor;
|
||||
border-radius: 1px;
|
||||
transform: rotate(45deg); /* closed: chevron down */
|
||||
margin-top: -2px; /* optical centring of the down chevron */
|
||||
transition: transform var(--fs-dur-move);
|
||||
/* @endmirror */
|
||||
}
|
||||
button.fs-ap-fold[aria-expanded="true"] .fs-ap-chev::after {
|
||||
/* @mirror chevron/open */
|
||||
transform: rotate(-135deg); /* open: chevron up */
|
||||
margin-top: var(--fs-space-0-5);
|
||||
/* @endmirror */
|
||||
}
|
||||
button.fs-ap-fold:hover .fs-ap-chev { color: var(--fs-accent); }
|
||||
/* Stock `.cbi-value` rows stack one per line and carry their own hairline, so a folded group needs
|
||||
* no layout of its own — it lays its rows out exactly like an unfolded section by doing nothing. */
|
||||
/* `hidden` is what keeps a closed group out of the tab order and the a11y tree, and
|
||||
* base/10-reset.css is what makes the attribute win over a class's `display` — for every
|
||||
* element, not just this one, so there is nothing to restate here. */
|
||||
/* the second heading inside the Colours fold — Surfaces shares the fold, not the heading. It
|
||||
* wears the SAME .fs-ap-head h4 as every other section title now; a third heading style on one
|
||||
* page (h4, folded h4, uppercase eyebrow h5) was a third of the raggedness. Only the space
|
||||
* above it is its own. */
|
||||
.fs-ap-sub { margin-top: var(--fs-space-4); }
|
||||
.fs-ap-head h4 {
|
||||
margin: 0;
|
||||
font-size: var(--fs-type); font-weight: var(--fs-weight-bold); color: var(--fs-text);
|
||||
}
|
||||
.fs-ap-section + .fs-ap-section { padding-top: var(--fs-space-4); border-top: var(--fs-hairline); }
|
||||
/* The rows are stock `.cbi-value` and this page states no layout for them at all: caption column,
|
||||
* field column and the hairline between rows come from base/30-forms.css and theme/60-inputs.css,
|
||||
* the rules every other LuCI form is drawn by. What stood here was a responsive two-column grid
|
||||
* of stacked cards with an uppercase eyebrow above each control: it fitted a floating popover,
|
||||
* and beside General Settings / Language and Style it made the theme's own tab the one page in
|
||||
* LuCI that did not look like LuCI. Deleting that grid is the change — do not restate a layout
|
||||
* for these rows. */
|
||||
/* The accordion switch is meaningless in the top layout — its sections are hover dropdowns,
|
||||
* already exclusive. Hidden HERE, not by a branch in the JS: the page is built once, so a branch
|
||||
* froze the control to whatever layout it loaded in and the live toggle could never change it. */
|
||||
:root[data-layout="top"] .fs-ap-submenus { display: none; }
|
||||
|
||||
/* Save-as-default / Reset row: two equal buttons, no status text — the Save button's own
|
||||
* label/disabled state is the status. They take their look from .btn / .cbi-button-action
|
||||
* (base + theme/55-buttons.css); a disabled .cbi-button-action already greys via base. */
|
||||
/* Buttons take the width of their own label, which is what every button on every other LuCI page
|
||||
* does — they were `flex: 1 1 9em` and stretched to fill the field, so three of them made one
|
||||
* long bar and "Choose SVG"/"Remove" each ran half the card. `wrap` keeps a narrow card honest:
|
||||
* an item that cannot fit moves to the next line instead of hanging past the edge, which on a
|
||||
* flex row is silent. */
|
||||
.fs-ap-actrow { display: flex; flex-wrap: wrap; gap: var(--fs-space-2); }
|
||||
/* Save and the two resets differ by one word and sit in one row, which is the shape a
|
||||
* destructive click lands on by accident. The gap says they are two groups; both resets also
|
||||
* ask for a second click. Zero-width, so it costs no height when the row wraps on a phone. */
|
||||
.fs-ap-actgap { flex: 0 0 var(--fs-space-4); }
|
||||
.fs-ap-actrow .btn { font-size: var(--fs-type); padding: var(--fs-space-2) var(--fs-space-2-5); cursor: pointer; }
|
||||
.fs-ap-actrow .btn:disabled { cursor: default; }
|
||||
/* the primed Reset (second click confirms) reads as the destructive action it is */
|
||||
.fs-ap-armed { color: var(--fs-on-danger); background: var(--fs-danger); border-color: transparent; }
|
||||
/* Save's only visible failure line (a rejected save rpc — usually a stale session) — shown in
|
||||
* place of the absent status text, hidden until a save actually fails. */
|
||||
.fs-ap-err { margin-top: var(--fs-space-2); font-size: var(--fs-type-xs); line-height: 1.35; color: var(--fs-danger); }
|
||||
|
||||
/* ---- the colour axes ----
|
||||
* One row is a swatch, a hex field and the button back to the palette's own colour. */
|
||||
/* the same ceiling every other stretching control in a form row takes (02-tokens.css), so the
|
||||
* swatch + hex + Palette button end where the selects and the sliders end */
|
||||
.fs-colorctl { display: flex; flex-direction: column; gap: var(--fs-space-1-5); max-width: var(--fs-field-max); }
|
||||
.fs-color-row { display: flex; align-items: center; gap: var(--fs-space-2); }
|
||||
/* The native colour swatch. type="color" is drawn by the browser and cannot be restyled beyond
|
||||
* its box, so the box is what is styled: the inner well is stripped to the frame's edge on both
|
||||
* engines (WebKit nests two elements, Firefox one) or it paints a white margin inside our
|
||||
* border. Fixed 34px square so it lines up with the field beside it at every density. */
|
||||
input[type="color"].fs-color-swatch {
|
||||
flex: 0 0 auto; inline-size: 34px; block-size: 34px; padding: 0; cursor: pointer;
|
||||
background: none; border: var(--fs-hairline); border-radius: var(--fs-radius-sm);
|
||||
}
|
||||
input[type="color"].fs-color-swatch::-webkit-color-swatch-wrapper { padding: 0; }
|
||||
input[type="color"].fs-color-swatch::-webkit-color-swatch { border: 0; border-radius: calc(var(--fs-radius-sm) - 1px); }
|
||||
input[type="color"].fs-color-swatch::-moz-color-swatch { border: 0; border-radius: calc(var(--fs-radius-sm) - 1px); }
|
||||
/* the hex field is a VALUE, so it is mono and tabular like every other value in the theme —
|
||||
* and #0969da is exactly the kind of string a proportional face makes hard to read back */
|
||||
input[type="text"].fs-color-hex {
|
||||
flex: 1 1 auto; min-inline-size: 0;
|
||||
font-family: var(--fs-font-mono); font-size: var(--fs-type-xs); font-variant-numeric: tabular-nums;
|
||||
text-transform: lowercase;
|
||||
}
|
||||
.fs-color-clear { flex: 0 0 auto; font-size: var(--fs-type-xs); padding: var(--fs-space-1-5) var(--fs-space-2); cursor: pointer; }
|
||||
.fs-color-clear:disabled { cursor: default; }
|
||||
|
||||
/* What the chosen colour COSTS, measured live against the surface it is read on (fs-widgets'
|
||||
* contrastRatio). It is a readout, not a validation: the theme derives readable ink over a fill
|
||||
* but never silently corrects a colour the admin asked for, so this says the number and grades
|
||||
* it. Three grades, three colours — and the failing one is --fs-danger, which the admin may have
|
||||
* just recoloured, which is exactly the honest outcome. */
|
||||
/* It is LuCI's own help-text line now — `.cbi-value-description`, styled in base/95-luci.css,
|
||||
* which is where a sentence under a field belongs on every other page. What stays here is the
|
||||
* only thing stock has no opinion about: the GRADE's colour, and the tabular figures that keep
|
||||
* the ratio from jittering as it updates. */
|
||||
.fs-color-contrast { font-variant-numeric: tabular-nums; }
|
||||
.fs-contrast-aa { color: var(--fs-good); }
|
||||
.fs-contrast-aa-large { color: var(--fs-warn); }
|
||||
.fs-contrast-low { color: var(--fs-danger); }
|
||||
|
||||
/* THE PRESET CHIPS' rules were here — a wrapping row of pills, each painted in the accent it
|
||||
* would set, with ink derived from that colour's own lightness. The control is gone from
|
||||
* fs-appearance.js: it was the one thing on the page that looked like nothing else in LuCI, it
|
||||
* started at the card's edge instead of at the field column, and everything it did the Accent
|
||||
* row does with any colour rather than eight. */
|
||||
|
||||
/* The uploaded image's preview and the two buttons under it, both in an ordinary
|
||||
* `.cbi-value-field`. The preview is a thumbnail, not a banner: capped to the same field ceiling
|
||||
* as every other stretching control and to a fixed height, so the row keeps one shape whatever
|
||||
* the image's aspect is — full width makes an SVG tile look like a letterboxed photograph. */
|
||||
.fs-ap-bgprev {
|
||||
display: block; width: 100%; max-width: var(--fs-field-max); height: 84px; object-fit: cover;
|
||||
border: var(--fs-hairline); border-radius: var(--fs-radius);
|
||||
/* the preview follows the buttons in the field, so the gap belongs ABOVE it */
|
||||
margin-top: var(--fs-space-2);
|
||||
}
|
||||
.fs-ap-bgrow { display: flex; flex-wrap: wrap; gap: var(--fs-space-2); }
|
||||
.fs-ap-bgrow .btn { font-size: var(--fs-type); padding: var(--fs-space-2) var(--fs-space-2-5); cursor: pointer; }
|
||||
.fs-ap-bgrow .btn:disabled { cursor: default; }
|
||||
/* The JS hides a row that does not apply to the chosen wallpaper, the empty preview and a
|
||||
* not-yet-uploaded Remove with `el.hidden`; base/10-reset.css makes that attribute beat the
|
||||
* `display` a class sets, so none of it needs restating here any more. */
|
||||
/* Under the File wallpaper only the photo Dim is relevant — the router-identity Tint colours the
|
||||
* canvas the photo covers, so hide the Tint hue AND its strength there (fs-ap-tint marks both). */
|
||||
:root[data-wallpaper="file"] .fs-ap-tint { display: none; }
|
||||
/* and the strength is a multiplier on a chroma WE choose, so it only means anything in hue mode:
|
||||
* with the tint off there is nothing to scale, and on a hex canvas the colour is the one the
|
||||
* admin entered. (0,3,0) out-ranks the stock row's own display. Not named after Density: that is
|
||||
* the UI-density select four rows above, and one name for two rows is how the label itself went
|
||||
* wrong. */
|
||||
:root:not([data-tint="hue"]) .fs-ap-tintstr { display: none; }
|
||||
|
||||
/* the version line at the foot of the page */
|
||||
.fs-ap-footer {
|
||||
display: flex; flex-direction: column; gap: var(--fs-space-2);
|
||||
margin-top: var(--fs-space-0-5); padding-top: var(--fs-space-2-5); border-top: var(--fs-hairline);
|
||||
}
|
||||
.fs-ap-verrow { display: flex; align-items: center; justify-content: space-between; gap: var(--fs-space-2-5); }
|
||||
/* links to the project repo — reads as muted text until hovered */
|
||||
.fs-ap-version { position: relative; font-size: var(--fs-type-xs); color: var(--fs-dim); font-variant-numeric: tabular-nums; text-decoration: none; }
|
||||
.fs-ap-version:hover { color: var(--fs-accent); text-decoration: underline; }
|
||||
/* the link's own box was 84x17 (owrt2512/390x844, Appearance tab), under the 24px floor of
|
||||
* WCAG 2.2 SC 2.5.8 on height. Same fix as `.cbi-checkbox > label[for]::before` in
|
||||
* theme/60-inputs.css: an invisible, absolutely-positioned overlay grows the hit box to
|
||||
* 88x25 without moving the text or growing `.fs-ap-verrow`, since the overlay is out of flow. */
|
||||
.fs-ap-version::before { content: ""; position: absolute; inset: -4px -2px; }
|
||||
|
||||
/* The line that names the missing catalogue package. Same weight as the version beside it —
|
||||
* it is a fact about this router, not a warning: nothing is broken, one package is absent.
|
||||
* Wraps, because the package name is 24 characters and the column is narrow at 390px. */
|
||||
.fs-ap-i18n {
|
||||
flex-wrap: wrap;
|
||||
font-size: var(--fs-type-xs);
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
/* the chip is base/20-typography.css's `code`; only the size follows the line it sits in, which
|
||||
* is a step smaller than body text */
|
||||
.fs-ap-i18n code { font-size: inherit; }
|
||||
|
||||
/* No rules here for a segmented control or a range slider of our own: the page draws its enums
|
||||
* with `ui.Select` and its numbers with `ui.RangeSlider`, which this theme already styles for
|
||||
* every other LuCI form. Two copies of a slider, one of them ours, was the thing to delete. */
|
||||
|
||||
/* No rules here for a hue slider either: the control is gone from fs-widgets' colorControl, two
|
||||
* controls for one value reading as two settings, and the half that could not reach a grey was
|
||||
* the slider. The axis still stores a hue and 03-palettes.css still rotates by one, so a saved
|
||||
* value goes on painting — but CSS for a control nobody renders is dead CSS in our own
|
||||
* namespace, which `npm run css-orphans` exists to keep out. */
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
@layer page {
|
||||
/* Processes: the PID column, which must not split. No `white-space: nowrap` here any more — the
|
||||
* floor is general: theme/30-tables.css gives a data table `overflow-wrap: break-word` for as
|
||||
* long as it is a table, so every column keeps the width of its own widest unbreakable token,
|
||||
* and a PID is one token. (With `anywhere` on every cell instead, `384` rendered as "38/4" and
|
||||
* `4810` as "481/0" — 23 of 26 rows, measured at 1228px against a Russian catalogue: issue #32,
|
||||
* and issue #5 before it.) The one per-page rule that survives (pages/30-software.css) does so
|
||||
* because a hyphen IS a legal break opportunity and `break-word` will use it.
|
||||
*
|
||||
* The measurement that replaced the nowrap, on the router at 720px: the Command column reports
|
||||
* 353px of need against 126px of width, the table asks for 963px in 688px of room, and the
|
||||
* ladder marks exactly one column breakable — leaving the PID whole without a rule of its
|
||||
* own. */
|
||||
}
|
||||
@@ -1,204 +0,0 @@
|
||||
@layer theme {
|
||||
/* ---- the chrome's floor: pin what a foreign rule can reach by INHERITANCE ----
|
||||
*
|
||||
* fs-sheets.js fences the chrome out of a third-party selector, so nothing foreign MATCHES a
|
||||
* chrome element. Inheritance is the way in a fence cannot close: a rule on `html` or `body` is
|
||||
* an ancestor, and excluding it is meaningless. Measured against a hostile flagged rule on
|
||||
* `html`: font-style reached 166 of the menu's 169 elements, word-spacing and text-align 157,
|
||||
* letter-spacing and text-transform 156, cursor 46 — while font-family, color, font-size,
|
||||
* line-height and font-weight reached none,
|
||||
* because the chrome already states those. The fix is to state the rest too.
|
||||
*
|
||||
* Inheritance is not a cascade competitor: it supplies a value only when no declaration matches
|
||||
* the element, so any declaration of ours — unflagged, at zero specificity — beats an inherited
|
||||
* `!important`. Hence no `!important` here.
|
||||
*
|
||||
* It keys off `[data-fs-chrome]`, the mark a chrome root carries in the markup (header.ut), not
|
||||
* off `.fs-sidebar`: the chrome is not one element, and a pin naming the menu leaves the skip
|
||||
* link and the search overlay inheriting straight from `html`. The fence (fs-sheets.js) reads
|
||||
* the same mark, so the two halves of zone 1's defence cannot cover different sets of elements,
|
||||
* and `npm run chrome-fence` derives the mark from the markup and holds both to it.
|
||||
*
|
||||
* It goes on the ROOT alone, and says so in the SELECTOR (`:not([data-fs-chrome] *)`) rather
|
||||
* than trusting whoever adds the next marker to have read this: the markers live in a template
|
||||
* with conditional blocks, so "is this one inside that one" is not a question a text scanner can
|
||||
* answer, and CSS can. Pinning descendants too is worse than useless — a direct declaration
|
||||
* beats an inherited one even when the inherited one is ours, so `.fs-label` loses the `nowrap`
|
||||
* it inherits and `text-align` is forced from `start` to `left` on 302 elements, which alone
|
||||
* breaks every RTL language LuCI ships. Hence `text-align: start`, never `left`.
|
||||
*
|
||||
* `:where()` keeps it at 0,0,0 so every existing chrome rule outranks it: the pin is a floor,
|
||||
* never a ceiling. Only inherited properties belong here. */
|
||||
:where([data-fs-chrome]:not([data-fs-chrome] *)) {
|
||||
font-style: normal;
|
||||
font-variant: normal;
|
||||
letter-spacing: normal;
|
||||
word-spacing: normal;
|
||||
text-transform: none;
|
||||
text-indent: 0;
|
||||
text-align: start;
|
||||
cursor: auto;
|
||||
}
|
||||
|
||||
/* Shared chrome — brand, logo, wordmark, logout, indicators. Same in both layouts;
|
||||
* only their PLACEMENT differs. Written twice once (here and under `.fs-topnav`) and
|
||||
* the copies had drifted: 32 vs 30px logo, 11 vs 10px brand gap, 10 vs 8px indicator
|
||||
* gap. The top-bar values won. A layout file may set placement on these (flex, order,
|
||||
* the rail collapse) — never their look. */
|
||||
|
||||
.fs-brand {
|
||||
display: flex; align-items: center; gap: var(--fs-space-2-5);
|
||||
color: var(--fs-text); font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
.fs-logo {
|
||||
width: var(--fs-btn-size); height: var(--fs-btn-size); border-radius: var(--fs-radius);
|
||||
/* No accent fill — a bordered box, same look as the square buttons in the right
|
||||
* cluster (.fs-logout, .fs-themerow: 1px var(--fs-border)). The glyph is the OpenWrt
|
||||
* favicon mark (brand.ut), baked-colour, so color/currentColor is unused here. */
|
||||
border: var(--fs-hairline);
|
||||
display: flex; align-items: center; justify-content: center;
|
||||
flex: 0 0 auto;
|
||||
}
|
||||
.fs-logo svg { width: 20px; height: 20px; }
|
||||
/* The OpenWrt ring flips with the theme mode like the SVG favicon does under
|
||||
* prefers-color-scheme — dark ring on the light UI, light ring on dark. The cyan arcs
|
||||
* stay baked (read on both). */
|
||||
.fs-logo-ring { fill: #002b49; }
|
||||
:root[data-darkmode="true"] .fs-logo-ring { fill: #e6f4fb; }
|
||||
|
||||
/* 700, not 800: the theme ships no faces, so 800 is whatever the reader's Manrope or system
|
||||
* stack has — 700 for most of them, synthesised for the rest. It already resolved to 700 back
|
||||
* when the 18 KB face was bundled and dropped for drawing six elements. Say so. */
|
||||
.fs-wordmark { font-size: var(--fs-type-lg); font-weight: var(--fs-weight-bold); letter-spacing: -.01em; }
|
||||
|
||||
/* Skip link — the first tab stop: a keyboard/SR user jumps the whole menu instead of
|
||||
* tabbing through every section on every page. Off-screen until focused, never
|
||||
* display:none / visibility:hidden — that removes it from the tab order, which is the
|
||||
* one thing it exists for. Sits above everything, incl. an open popover. */
|
||||
.fs-skip {
|
||||
position: fixed; top: 8px; inset-inline-start: 8px; z-index: var(--fs-z-dropdown);
|
||||
padding: var(--fs-space-2-5) var(--fs-space-4); border-radius: var(--fs-radius);
|
||||
background: var(--fs-accent); color: var(--fs-on-accent);
|
||||
font-weight: var(--fs-weight-bold); font-size: var(--fs-type); text-decoration: none;
|
||||
box-shadow: var(--fs-shadow-pop);
|
||||
}
|
||||
/* Clipped, not translated off-screen: --fs-shadow-pop is offset 12px / blur 34px, so a
|
||||
* box parked at -68px still bled ~16px of DROP SHADOW into the viewport and smudged the
|
||||
* top-left corner of every page. clip-path clips the shadow too. Never display:none /
|
||||
* visibility:hidden — see above. */
|
||||
.fs-skip:not(:focus) {
|
||||
clip-path: inset(50%);
|
||||
width: 1px; height: 1px;
|
||||
padding: 0; overflow: hidden; white-space: nowrap;
|
||||
}
|
||||
.fs-skip:focus {
|
||||
outline: 2px solid var(--fs-panel); outline-offset: 2px;
|
||||
}
|
||||
/* Visually hidden but PRESENT in the a11y tree — for the document <h1> and the live
|
||||
* region. hidden/display:none/visibility:hidden take the element out of the a11y tree
|
||||
* too: the h1 would fix no heading outline and the live region would never announce.
|
||||
* Clipping leaves a node readable to assistive tech while occupying no space.
|
||||
* nowrap: a long title clipped into a 1px column is read out line by line by some SRs. */
|
||||
.fs-sr {
|
||||
position: absolute;
|
||||
clip-path: inset(50%);
|
||||
width: 1px; height: 1px;
|
||||
margin: -1px; padding: 0;
|
||||
overflow: hidden; white-space: nowrap;
|
||||
}
|
||||
|
||||
/* the skip link's target <main> carries tabindex="-1" so the browser actually MOVES
|
||||
* focus there (Safari/Chrome refuse on a non-focusable target: they scroll but leave
|
||||
* focus in the menu) — but it must not then ring the whole page. */
|
||||
#maincontent:focus { outline: none; }
|
||||
|
||||
.fs-logout { display: flex; align-items: center; color: var(--fs-dim); }
|
||||
.fs-logout:hover { color: var(--fs-danger); }
|
||||
|
||||
.fs-indicators { display: flex; align-items: center; gap: var(--fs-space-2); }
|
||||
|
||||
/* The 34px square icon button (.fs-themerow / .fs-logout collapsed) is NOT declared
|
||||
* here: it only exists where the chrome is a bar or a rail, and those blocks
|
||||
* (20-shell.css, 50-toplayout.css) already give it its border, surface and size — an
|
||||
* unconditional copy here was a second definition they had to re-state anyway. */
|
||||
|
||||
/* Density steps for the main menu once it is a horizontal row —
|
||||
* fs-chrome.js (fitTabStrips) adds .fs-dense1/2 when the row would wrap (and strips them
|
||||
* in the vertical sidebar, so no media guard is needed). Padding is trimmed hard
|
||||
* first, the font only at the d2 floor. */
|
||||
.fs-sidebar ul.nav.fs-dense1 > li > a { padding: var(--fs-space-1) var(--fs-space-2); }
|
||||
.fs-sidebar ul.nav.fs-dense2 > li > a { padding: var(--fs-space-1) var(--fs-space-1-5); font-size: var(--fs-type); }
|
||||
|
||||
/* Menu primitives, once for both layouts (both render the menu as `ul.nav > li > a`):
|
||||
* the 19px line-height, `display: block` on the items and the `position: relative`
|
||||
* every submenu popup anchors to — all three used to be inherited from a navbar rule
|
||||
* set the theme no longer carries. */
|
||||
ul.nav { position: relative; margin: 0; list-style: none; }
|
||||
ul.nav > li { display: block; }
|
||||
ul.nav a { line-height: 19px; text-decoration: none; }
|
||||
|
||||
/* `.dropdown-menu` is emitted by nobody here — not by this theme, whose menu is a plain nested
|
||||
* `ul`, and not by luci-base. It stays styled under the coverage contract: it is theme
|
||||
* vocabulary (stock luci-theme-bootstrap carries 14 rules for it), so a third-party luci-app-*
|
||||
* is entitled to emit it and expect a themed result. Each item anchors its own nested popup,
|
||||
* hence position: relative.
|
||||
*
|
||||
* This comment used to claim ui.js emits it for the split Save & Apply button. It does not —
|
||||
* that button is a `.cbi-dropdown`, a different widget. */
|
||||
.dropdown-menu li { display: block; position: relative; }
|
||||
/* wins over `ul.nav a` above: the popup sets its own denser rhythm */
|
||||
ul.nav .dropdown-menu a, .dropdown-menu a { line-height: 18px; }
|
||||
|
||||
/* Menu hover / active — one look, every layout. One markup (`ul.nav > li > a` + a
|
||||
* nested `ul`) serves the main list, the submenu (accordion / bar dropdown / rail
|
||||
* flyout), the mode menu and the Appearance row, so there are no per-layout copies to
|
||||
* keep in step. */
|
||||
.fs-sidebar ul.nav > li > a:hover,
|
||||
.fs-sidebar ul.nav ul a:hover,
|
||||
.fs-themerow:hover {
|
||||
background: var(--fs-panel2); color: var(--fs-text); opacity: 1;
|
||||
}
|
||||
.fs-sidebar ul.nav > li > a.active,
|
||||
.fs-sidebar ul.nav ul a.active,
|
||||
.fs-themerow[aria-expanded="true"],
|
||||
.fs-modemenu li.active a {
|
||||
background: var(--fs-accent-soft); color: var(--fs-accent);
|
||||
}
|
||||
/* ---- the fill marks the PAGE, and a category is not a page ----
|
||||
*
|
||||
* `li.active` is set on the SECTION containing the current page as well as on the page's own
|
||||
* row, so `li.active > a` hands the same accent plate to both — two identical plates, one above
|
||||
* the other, on System -> System (issue #37): measured before this rule, the open category and
|
||||
* the current leaf carried the same fill, the same ink and the same 13px/600, differing in 2px
|
||||
* of padding.
|
||||
*
|
||||
* The markup already says which is which: menu-footstrap.js puts `aria-current="page"` on the
|
||||
* LEAF alone, a section header being a disclosure control rather than a link to where you are.
|
||||
* So the plate stays with the page and the ancestor keeps the accent INK, while an ancestor
|
||||
* that is also the page is matched by `a.active` above and keeps the plate.
|
||||
*
|
||||
* Unscoped, like the rule above it: the accordion, the bar's dropdown and the rail's flyout are
|
||||
* one markup. */
|
||||
.fs-sidebar ul.nav > li.active > a:not(.active) { color: var(--fs-accent); }
|
||||
|
||||
/* Keyboard focus for the chrome controls, which otherwise have only the UA default.
|
||||
* --fs-focus-ring-solo, not --fs-focus-ring: none of these flips a border on focus, so the ring
|
||||
* is the entire indicator, and the tinted ring measures 1.15-1.29:1 against the sidebar — i.e.
|
||||
* tabbing the whole menu shows nothing at 3:1 (the two-ring contract in 02-tokens.css). */
|
||||
.fs-railtoggle:focus-visible,
|
||||
.fs-themerow:focus-visible,
|
||||
.fs-logout:focus-visible,
|
||||
.fs-sidebar ul.nav a:focus-visible {
|
||||
outline: none;
|
||||
box-shadow: var(--fs-focus-ring-solo);
|
||||
}
|
||||
|
||||
/* The page-wide accent signals no widget rule covers, all following the palette:
|
||||
* ::selection the UA default (opaque blue) ignores palette and dark mode
|
||||
* caret-color inherits from :root into every field, in one declaration
|
||||
* accent-color the theme's own checkboxes are appearance:none drawings and never see it,
|
||||
* but a third-party app's native checkbox/radio/progress does */
|
||||
::selection { background: var(--fs-accent); color: var(--fs-on-accent); }
|
||||
:root { caret-color: var(--fs-accent); accent-color: var(--fs-accent); }
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
@layer theme {
|
||||
/* Wallpaper axis, value `pattern`: an SVG the admin uploads, tiled behind the content and
|
||||
* recoloured by the theme, so the same file reads correctly in light and dark and under any
|
||||
* palette without being edited.
|
||||
*
|
||||
* A dedicated element rather than a `background-image`, because recolouring a rasterised image
|
||||
* takes `mask-image` — the SVG supplies the alpha, the element the colour — and a mask applies
|
||||
* to the element's whole rendering, children included, so it can never go on .fs-shell or
|
||||
* <body>. Hence .fs-pattern, emitted as the first child of <body> by header.ut and sysauth.ut
|
||||
* (the login page has no .fs-shell), whose only job is to be masked.
|
||||
*
|
||||
* z-index: -1 with a transparent body, because inside the root stacking context the paint order
|
||||
* is html's background, then negative-z children, then every block background: the layer sits
|
||||
* above the canvas and below the content, but body's own opaque --fs-bg would bury it. The
|
||||
* canvas therefore moves up to :root for this axis and body goes transparent; .fs-main and the
|
||||
* footer paint their own --fs-bg and follow for the same reason. The sidebar is deliberately
|
||||
* not excluded —
|
||||
* the bar is translucent and the pattern showing behind it is what makes the page read as one
|
||||
* sheet.
|
||||
*
|
||||
* Cards sit on opaque --fs-panel, so the pattern shows through the gaps only. */
|
||||
.fs-pattern { display: none; }
|
||||
|
||||
:root[data-wallpaper="pattern"] { background-color: var(--fs-bg); }
|
||||
:root[data-wallpaper="pattern"] body,
|
||||
:root[data-wallpaper="pattern"] .fs-main { background-color: transparent; }
|
||||
:root[data-wallpaper="pattern"] footer.fs-footer { background: transparent; }
|
||||
|
||||
/* `fixed`, so the pattern is one calm backdrop the page scrolls under rather than a strip that
|
||||
* slides with every table — the same argument the File photo's background-attachment makes.
|
||||
* --fs-pattern-url is `none` until something is uploaded (head.ut / fs-prefs.js), so the axis
|
||||
* selected with no file is a bare canvas rather than a broken tile. */
|
||||
:root[data-wallpaper="pattern"] .fs-pattern {
|
||||
display: block;
|
||||
position: fixed;
|
||||
inset: 0;
|
||||
z-index: -1;
|
||||
pointer-events: none;
|
||||
opacity: var(--fs-pattern-strength);
|
||||
}
|
||||
/* THEME INK (the default). The file's own colours are discarded and only its alpha is used, so
|
||||
* an opaque background inside the SVG would mask as a solid sheet — which is exactly why the
|
||||
* admin can switch to the file's own colours below. Line art on transparency is the shape this
|
||||
* mode is for. */
|
||||
:root[data-wallpaper="pattern"]:not([data-pattern-ink="original"]) .fs-pattern {
|
||||
background-color: var(--fs-text);
|
||||
-webkit-mask-image: var(--fs-pattern-url);
|
||||
mask-image: var(--fs-pattern-url);
|
||||
-webkit-mask-repeat: repeat;
|
||||
mask-repeat: repeat;
|
||||
-webkit-mask-size: var(--fs-pattern-size) auto;
|
||||
mask-size: var(--fs-pattern-size) auto;
|
||||
}
|
||||
/* THE FILE'S OWN COLOURS: an ordinary tiled background, no mask. For artwork that carries its
|
||||
* own palette and would be flattened to one colour by the mask. */
|
||||
:root[data-wallpaper="pattern"][data-pattern-ink="original"] .fs-pattern {
|
||||
background-image: var(--fs-pattern-url);
|
||||
background-repeat: repeat;
|
||||
background-size: var(--fs-pattern-size) auto;
|
||||
}
|
||||
|
||||
/* No wash layer behind #view: the pattern shows through the gaps between the cards at
|
||||
* full strength. Every block that carries text paints an opaque --fs-panel of its own,
|
||||
* so nothing has to be dimmed globally. */
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
@layer theme {
|
||||
/* The uploaded photo, the Wallpaper axis's `file` value. The bytes are router-side and shared,
|
||||
* and the served file is referenced by CSS `url()`, never inlined (uhttpd has no gzip). A photo
|
||||
* carries no bakeable opacity, so a scrim is mandatory for legibility: --fs-photo-scrim, a wash
|
||||
* derived from --fs-bg so it follows palette, mode and tint (03-palettes.css), painted as the
|
||||
* TOP background layer over the photo on the SAME element. That keeps it between image and
|
||||
* content with no ::before
|
||||
* and no z-index, and no backdrop-filter — a blur on a full-viewport surface is the most
|
||||
* expensive paint there is on a phone GPU, the scrim already carries the readability, and
|
||||
* reduced transparency turns the scrim opaque anyway (95-a11y-media.css).
|
||||
*
|
||||
* One-element rule, like the pattern: .fs-shell where there is chrome, the bare <body> on the
|
||||
* login page. Content blocks paint their own opaque --fs-panel and float above the scrim, so it
|
||||
* only has to carry the little text sitting directly on the canvas. --fs-login-bg-url is `none`
|
||||
* until a photo is uploaded. */
|
||||
:root[data-wallpaper="file"] :is(.fs-shell, body:not(:has(.fs-shell))) {
|
||||
background-image: linear-gradient(var(--fs-photo-scrim), var(--fs-photo-scrim)), var(--fs-login-bg-url);
|
||||
background-position: center;
|
||||
background-size: cover;
|
||||
background-repeat: no-repeat;
|
||||
/* fixed, so the photo is one calm backdrop the page scrolls under, not a strip that slides
|
||||
* with every table. */
|
||||
background-attachment: fixed;
|
||||
}
|
||||
/* .fs-main's opaque --fs-bg would cover the shell's single background layer — make it transparent
|
||||
* so the photo+scrim shows through the whole content area (15-wallpaper.css does the same for
|
||||
* the pattern). */
|
||||
:root[data-wallpaper="file"] .fs-main { background-color: transparent; }
|
||||
:root[data-wallpaper="file"] footer.fs-footer { background: transparent; }
|
||||
}
|
||||
@@ -1,794 +0,0 @@
|
||||
@layer theme {
|
||||
/* FOOTSTRAP SHELL — layout + chrome over styles/base.
|
||||
* Markup: ucode/template/themes/footstrap/header.ut · spec: docs/chrome.md */
|
||||
|
||||
body {
|
||||
padding: 0;
|
||||
background-color: var(--fs-bg);
|
||||
font-family: var(--fs-font-sans);
|
||||
}
|
||||
/* placement only — the look lives in 10-chrome.css */
|
||||
.fs-brand { flex: 1 1 auto; min-width: 0; }
|
||||
/* A hostname is user-supplied and can outgrow any bar or column. `overflow-wrap: anywhere`
|
||||
* wraps it mid-word only when no better break exists (unlike word-break: break-all, a
|
||||
* normal hostname still breaks at its dots), and it lets the flex item's min-content size
|
||||
* shrink — which is what stops a long name pushing the menu out of the bar. It used to be
|
||||
* nowrap + ellipsis, which truncated the one string that identifies the router. */
|
||||
/* And a ceiling on the LINES, the width cap alone bounding the wrong axis: measured in the top
|
||||
* bar at 1280px, 8 characters give the ordinary 46px bar, 63 (the kernel's nodename limit) give
|
||||
* 73px, and a 4000-character hostname gave a 4273px tall bar. Three lines is past every real
|
||||
* hostname and still a bar. `-webkit-line-clamp` is the only cross-engine spelling today and
|
||||
* needs its two companions, where a max-height would slice a line in half. */
|
||||
.fs-wordmark {
|
||||
overflow-wrap: anywhere; min-width: 0;
|
||||
display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 3; overflow: hidden;
|
||||
}
|
||||
/* collapse the sidebar to an icon rail. The toggle only EXISTS in the vertical sidebar,
|
||||
* so its `display` is declared there, not here, or it would just be shadowed. */
|
||||
.fs-railtoggle {
|
||||
align-items: center; justify-content: center;
|
||||
width: calc(28px * var(--fs-density-box)); height: calc(28px * var(--fs-density-box));
|
||||
padding: 0; flex: 0 0 auto;
|
||||
border: 1px solid transparent; border-radius: var(--fs-radius-sm);
|
||||
background: transparent; color: var(--fs-faint); cursor: pointer;
|
||||
transition: background var(--fs-dur), border-color var(--fs-dur), color var(--fs-dur);
|
||||
}
|
||||
.fs-railtoggle:hover { color: var(--fs-text); background: var(--fs-panel2); border-color: var(--fs-border); }
|
||||
.fs-railtoggle .fs-ico { width: 16px; height: 16px; transition: transform var(--fs-dur-move); }
|
||||
.fs-sidebar ul.nav,
|
||||
.fs-sidebar #modemenu {
|
||||
list-style: none;
|
||||
margin: 0; padding: 0;
|
||||
display: flex;
|
||||
}
|
||||
.fs-sidebar ul.nav > li > a .fs-label { flex: 1 1 auto; }
|
||||
/* collapse chevron for sections with children */
|
||||
.fs-chevron {
|
||||
width: 14px; height: 14px; flex: 0 0 auto;
|
||||
color: var(--fs-dim);
|
||||
transition: rotate var(--fs-dur-move);
|
||||
}
|
||||
/* `rotate`, not `transform: rotate()`: the INDIVIDUAL transform properties compose across
|
||||
* rules, so the RTL mirror below can set `scale` without either rule having to restate the
|
||||
* other's value. The fixed order is translate -> rotate -> scale, so a mirrored chevron still
|
||||
* points down when it opens. */
|
||||
.fs-sidebar ul.nav > li.open > a .fs-chevron { rotate: 90deg; }
|
||||
/* ---- the two chevrons are DIRECTION, and direction is what mirrors ----
|
||||
* A disclosure marker and the rail's collapse arrow both point along the reading axis, so with
|
||||
* the document flipped (head.ut stamps dir) both point back at themselves. Everything else in
|
||||
* the chrome mirrors from the logical properties; these two are glyphs and need the transform. */
|
||||
:root[dir="rtl"] .fs-chevron,
|
||||
:root[dir="rtl"] .fs-railtoggle .fs-ico { scale: -1 1; }
|
||||
.fs-sidebar ul.nav > li.has-sub > a { cursor: pointer; }
|
||||
.fs-sidebar ul.nav ul {
|
||||
list-style: none;
|
||||
}
|
||||
/* .fs-logout's display/align/colour are shared chrome (10-chrome.css) — do not restate
|
||||
* them; only its LAYOUT (square button vs full-width row) belongs to a layout block. */
|
||||
|
||||
|
||||
/* ---- the bar: the default chrome, and the only copy of it ----
|
||||
*
|
||||
* The chrome is a bar unless something says otherwise: the TOP layout at every width, and the
|
||||
* SIDEBAR layout collapsed onto a phone. The vertical sidebar is the exception, written once
|
||||
* below as a single guarded override.
|
||||
*
|
||||
* This way round because the bar is needed when
|
||||
* (viewport <= 767px) OR (:root[data-layout="top"])
|
||||
* and CSS cannot OR a media query with an attribute selector in one selector, so writing the
|
||||
* bar under both guards means writing it twice — 55 of ~75 declarations identical, i.e. free to
|
||||
* drift. Inverted, each of the three chrome states is stated exactly once.
|
||||
*
|
||||
* The override wins on SPECIFICITY, never on source order:
|
||||
* :root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar (0,4,0) beats .fs-sidebar (0,1,0) */
|
||||
.fs-shell {
|
||||
display: flex; flex-direction: column;
|
||||
/* ---- `svh`, not `dvh`, and that is the phone's whole problem ----
|
||||
*
|
||||
* `dvh` tracks the viewport as browser UI comes and goes, and on iOS the URL bar slides
|
||||
* continuously WHILE THE USER SCROLLS, so a shell keyed on `dvh` is re-laid-out on every
|
||||
* frame of that animation — the shaking reported from an iPhone. `svh` is the small viewport
|
||||
* height, the value with the browser UI shown, and it does not move while the UI does. It is
|
||||
* also the right value here: this is a floor, so the shell must be at least one screenful
|
||||
* tall with the bar visible, and when the bar hides the page is free to be taller.
|
||||
*
|
||||
* The whole file follows that rule: a height that must not change under the reader uses
|
||||
* `svh`. `dvh` is for a thing that should GROW as the UI retracts. */
|
||||
min-height: 100svh; width: 100%;
|
||||
}
|
||||
.fs-sidebar {
|
||||
display: flex;
|
||||
width: 100%; height: auto;
|
||||
position: sticky; top: 0; z-index: var(--fs-z-sticky);
|
||||
flex-direction: row; flex-wrap: wrap; align-items: center;
|
||||
gap: var(--fs-space-2-5); padding: var(--fs-space-2-5) var(--fs-space-4);
|
||||
background: var(--fs-bar-bg);
|
||||
border-inline-end: 0; border-bottom: var(--fs-hairline);
|
||||
/* the submenu popups anchor to this bar and must escape it */
|
||||
overflow: visible;
|
||||
}
|
||||
/* A hostname can be enormous, and three things must be true at once:
|
||||
* flex: 0 1 auto + min-width: 0 — the brand may SHRINK (0 0 auto lets it push the menu and
|
||||
* the right cluster out of the bar);
|
||||
* max-width — it must also be CAPPED: the bar is flex-wrap, so instead of squeezing the brand
|
||||
* flexbox wraps the other items away and lets it sit alone on a 600px line;
|
||||
* and the bar grows in height (min-height, 50-toplayout.css) to hold the extra line.
|
||||
* 30ch tracks the text, not the viewport: a wide screen licenses more MENU, not a wider
|
||||
* hostname. */
|
||||
.fs-brandrow { flex: 0 1 auto; order: 1; min-width: 0; max-width: min(100%, 30ch); padding: 0; }
|
||||
/* the bar has no section caption, no column to collapse, and its height follows its
|
||||
* content — so the flex filler has nothing to fill */
|
||||
.fs-navlabel, .fs-spacer, .fs-railtoggle, .fs-modemenu { display: none; }
|
||||
|
||||
/* the menu on its own full-width row beneath the brand. The DESKTOP bar lifts it back
|
||||
* onto the brand's row whenever it fits — MEASURED, not a breakpoint
|
||||
* (fs-chrome.js fitChrome adds .fs-bar-stack when it does NOT fit). */
|
||||
.fs-sidebar ul.nav {
|
||||
order: 3; flex: 1 1 100%;
|
||||
flex-direction: row; flex-wrap: wrap; align-items: center; gap: var(--fs-space-0-5);
|
||||
}
|
||||
/* The dropdown hangs off its OWN item, in every bar state (issue #19): `position: static` plus a
|
||||
* panel pinned at `left: 16px` anchors it to the bar's edge rather than to its trigger, so a
|
||||
* sidebar layout collapsed onto a bar opened a hover panel at the left edge while its trigger
|
||||
* sat mid-bar — measured at 760px, the item at x=253 and the panel at x=32. Travelling to the
|
||||
* panel leaves the <li>, nothing bridges the diagonal, and
|
||||
* the CSS hover closes it, so no submenu entry could be reached. A phone never shows it:
|
||||
* `hover: none` disables the hover rule outright. */
|
||||
.fs-sidebar ul.nav > li.has-sub { position: relative; }
|
||||
.fs-sidebar ul.nav > li > a {
|
||||
display: flex; align-items: center;
|
||||
padding: var(--fs-space-1-5) var(--fs-space-3); border-radius: var(--fs-radius);
|
||||
color: var(--fs-dim);
|
||||
font-size: var(--fs-type); font-weight: var(--fs-weight); white-space: nowrap;
|
||||
}
|
||||
/* a bar item is its label: no icon, no chevron */
|
||||
.fs-sidebar ul.nav > li > a .fs-ico,
|
||||
.fs-sidebar ul.nav > li > a .fs-chevron { display: none; }
|
||||
|
||||
/* submenu = a popup card under its own item: sized to its content rather than stretched
|
||||
* across the bar, and capped to the viewport so a long label wraps instead of overflowing.
|
||||
* `left: 0` = the item's left edge (the <li> above is the containing block); an item near
|
||||
* the right edge is nudged back inside by menu-footstrap.js clampDropdown, in every bar
|
||||
* state — the JS gate is the same question this rule asks, not a layout test. */
|
||||
.fs-sidebar ul.nav ul,
|
||||
.fs-sidebar ul.nav > li.open > ul {
|
||||
display: none;
|
||||
position: absolute; inset-inline: 0 auto; top: calc(100% + 8px); z-index: var(--fs-z-flyout);
|
||||
width: max-content; min-width: 200px; max-width: calc(100vw - 32px);
|
||||
margin: 0; padding: var(--fs-space-2);
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg); box-shadow: var(--fs-shadow-pop);
|
||||
}
|
||||
/* an invisible bridge across the 8px gap, so travelling from the item down into the panel
|
||||
* does not drop the hover and close it. Belongs to the BAR, not to one layout: the hover
|
||||
* rule below is unguarded, so every state that can open a panel on hover needs it. */
|
||||
.fs-sidebar ul.nav > li.has-sub > ul::before {
|
||||
content: ""; position: absolute; inset-inline: 0; top: -10px; height: 10px;
|
||||
}
|
||||
/* hover only on a real pointer: a tap leaves :hover stuck on mobile browsers, which
|
||||
* would block tap-to-close */
|
||||
@media (hover: hover) {
|
||||
.fs-sidebar ul.nav > li.has-sub:hover > ul { display: block; }
|
||||
}
|
||||
.fs-sidebar ul.nav > li.has-sub.open > ul { display: block; }
|
||||
/* a submenu link is the same link in every layout — only its PADDING differs (denser
|
||||
* inside a popup than in the accordion), which is all the vertical override restates. */
|
||||
.fs-sidebar ul.nav ul a {
|
||||
display: block; padding: var(--fs-space-2) var(--fs-space-3); border-radius: var(--fs-radius-sm);
|
||||
color: var(--fs-dim); font-size: var(--fs-type); font-weight: var(--fs-weight);
|
||||
}
|
||||
|
||||
/* right cluster: the poll pill, then Appearance and Log out as square icon buttons.
|
||||
* LuCI's #indicators (poll "Refreshing", unsaved changes) collapses when empty, so it
|
||||
* only shows when there is something to report. */
|
||||
.fs-sidebar #indicators {
|
||||
display: flex; flex-wrap: wrap; gap: var(--fs-space-1-5);
|
||||
order: 2; margin-inline-start: auto; padding: 0;
|
||||
}
|
||||
|
||||
.fs-themerow {
|
||||
display: flex; align-items: center; justify-content: center;
|
||||
flex: 0 0 auto; order: 2; margin-inline-start: auto;
|
||||
/* see the :not(:empty) rule below — two auto margins would SPLIT the free space between
|
||||
* them instead of pushing one cluster to the bar's far edge */
|
||||
width: var(--fs-btn-size); height: var(--fs-btn-size); padding: 0;
|
||||
border: var(--fs-hairline); border-radius: var(--fs-radius);
|
||||
background: var(--fs-bar-ctl-bg); color: var(--fs-dim);
|
||||
font: inherit; font-weight: var(--fs-weight); font-size: var(--fs-type); line-height: 1.1;
|
||||
text-align: start; cursor: pointer;
|
||||
transition: background var(--fs-dur), border-color var(--fs-dur), color var(--fs-dur);
|
||||
}
|
||||
/* ---- when the right cluster runs out of room: .fs-ind-compact, then .fs-bar-actrow ----
|
||||
*
|
||||
* Both are set by fs-chrome.js (fitCluster) by measurement, and both belong to the BAR rather
|
||||
* than to a layout: the top layout is a bar at every width and the sidebar layout becomes one on
|
||||
* a phone. Under a data-layout="top" guard they miss the common case — a phone in the default
|
||||
* sidebar layout, whose bar then shows the full pills with Log out wrapped alone onto a second
|
||||
* row at the left edge.
|
||||
*
|
||||
* Step 1, .fs-ind-compact: the pills lose their prose and become icon squares matching the other
|
||||
* cluster controls, which frees ~200px and on the top layout is often enough to keep the MENU on
|
||||
* the brand's row as well.
|
||||
* Step 2, .fs-bar-actrow: the cluster still does not fit, so the brand row takes the full width
|
||||
* and the whole cluster moves down together, keeping the right edge for free from the auto
|
||||
* inline-start margin above. max-width must be released along with the flex basis, or the 30ch
|
||||
* cap leaves the brand short of the row it was just given and the cluster rides back up. */
|
||||
.fs-sidebar.fs-bar-actrow .fs-brandrow { flex: 1 1 100%; max-width: 100%; }
|
||||
|
||||
/* the poll pill: label off, masked glyph on. Static green arrows, grey when the poll is paused —
|
||||
* the same --fs-icon-refresh as the rail, and the same reason it does not spin (a permanently
|
||||
* spinning glyph makes an idle router look busy, and a moving target cannot be clicked). */
|
||||
.fs-sidebar.fs-ind-compact #indicators [data-indicator="poll-status"] {
|
||||
width: var(--fs-btn-size); padding: 0; font-size: 0; justify-content: center; position: relative;
|
||||
}
|
||||
.fs-sidebar.fs-ind-compact #indicators [data-indicator="poll-status"]::before {
|
||||
content: ""; width: var(--fs-icon-refresh-sz); height: var(--fs-icon-refresh-sz);
|
||||
background: var(--fs-good);
|
||||
/* @mirror poll-glyph/mask */
|
||||
-webkit-mask: var(--fs-icon-refresh) center / var(--fs-icon-refresh-sz) no-repeat;
|
||||
mask: var(--fs-icon-refresh) center / var(--fs-icon-refresh-sz) no-repeat;
|
||||
/* @endmirror */
|
||||
}
|
||||
.fs-sidebar.fs-ind-compact #indicators [data-indicator="poll-status"]:not([data-style="active"])::before {
|
||||
background: var(--fs-dim);
|
||||
}
|
||||
/* every OTHER indicator collapses to the same box and shows the badge fs-chrome.js lifted out of
|
||||
* its label — the count, or a dot when there is no number — exactly as the collapsed rail does.
|
||||
* min-width rather than width: three digits must not be clipped, and here there is room to grow. */
|
||||
.fs-sidebar.fs-ind-compact #indicators [data-indicator]:not([data-indicator="poll-status"]) {
|
||||
min-width: var(--fs-btn-size); padding: 0 var(--fs-space-1); font-size: 0; justify-content: center;
|
||||
}
|
||||
.fs-sidebar.fs-ind-compact #indicators [data-indicator]:not([data-indicator="poll-status"])::after {
|
||||
/* @mirror ind-badge/paint */
|
||||
content: attr(data-fs-badge);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-weight-bold); font-variant-numeric: tabular-nums;
|
||||
/* @endmirror */
|
||||
}
|
||||
|
||||
/* Exactly ONE member of the far-edge cluster may carry an auto inline-start margin, and it must be the
|
||||
* FIRST one actually rendered. #indicators is earlier in the DOM, so when the poll pill
|
||||
* shows IT opens the gap and .fs-themerow's auto must stand down — otherwise flexbox
|
||||
* SPLITS the free space between the two and the pill drifts away from the buttons.
|
||||
* .fs-themerow keeps its own auto for when the pill is empty and collapsed. */
|
||||
.fs-sidebar #indicators:not(:empty) ~ .fs-themerow { margin-inline-start: 0; }
|
||||
/* …and there are TWO .fs-themerow buttons now (Search, then Appearance), so the same split
|
||||
* would happen between THEM whenever the pill is collapsed: the second one stands down too. */
|
||||
.fs-themerow ~ .fs-themerow { margin-inline-start: 0; }
|
||||
.fs-logout {
|
||||
flex: 0 0 auto; order: 2; justify-content: center;
|
||||
width: var(--fs-btn-size); height: var(--fs-btn-size); padding: 0;
|
||||
border: var(--fs-hairline); border-radius: var(--fs-radius);
|
||||
background: var(--fs-bar-ctl-bg);
|
||||
}
|
||||
/* on a square button the BORDER carries the state — the fill and the ink come from the
|
||||
* shared hover/active groups in 10-chrome.css */
|
||||
.fs-themerow:hover,
|
||||
.fs-themerow[aria-expanded="true"] { border-color: var(--fs-accent); }
|
||||
.fs-logout:hover { border-color: var(--fs-danger); }
|
||||
.fs-themerow .fs-label, .fs-logout .fs-label { display: none; }
|
||||
.fs-themerow .fs-ico,
|
||||
.fs-logout .fs-ico { width: 18px; height: 18px; flex: 0 0 auto; }
|
||||
.fs-sidebar ul.nav .fs-ico { flex: 0 0 auto; }
|
||||
|
||||
/* ---- the vertical sidebar: the single override, the only thing that is not a bar ----
|
||||
* Guarded positively (never write a `:not([data-layout=…])` guard). Everything the bar declared
|
||||
* above must be answered here, which is what makes it checkable.
|
||||
*
|
||||
* When it applies is not "viewport >= 768px": what matters is how much room is left for the
|
||||
* CONTENT once the sidebar takes its cut, and that cut is not constant — 224px expanded, 68px as
|
||||
* a rail — so the two give way at different widths, which one breakpoint cannot express.
|
||||
* `data-narrow` is set by fs-chrome.js (fitShell) when the content column would fall below
|
||||
* --fs-content-min, measured from the sidebar's ACTUAL cut.
|
||||
*
|
||||
* `min-width: 521px` is not a second guess but a floor keeping the chrome correct with JS
|
||||
* DISABLED, where no data-narrow is ever written: below 521 no cut leaves 500px anyway, so it
|
||||
* states the measurement's conclusion in advance. */
|
||||
@media (min-width: 521px) {
|
||||
/* Scroll model for the desktop sidebar layout: the shell is pinned to the viewport and the
|
||||
* CONTENT column scrolls inside itself, so the sidebar is a STATIC element that stays put —
|
||||
* never position:sticky. That is the fix for issue #7: a sticky sidebar is a composited GPU
|
||||
* layer, and with overflow:visible (needed so the rail flyouts escape sideways) every hover
|
||||
* repaint left a 1px seam of the flyout at the layer's edge until a full repaint cleared it.
|
||||
* A static sidebar is not a layer, so there is nothing to leave stale, and it drops the
|
||||
* z-index juggling too: sticky always makes a stacking context, while a static sidebar makes
|
||||
* none, so the flyouts resolve --fs-z-flyout in the root stacking context. Confined to the
|
||||
* desktop sidebar; the top layout and the phone bar keep window scrolling. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-shell {
|
||||
flex-direction: row; height: 100svh; overflow: hidden;
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-main {
|
||||
height: 100svh; overflow-y: auto;
|
||||
/* `contain: paint`, the fix for issue #12: .fs-shell is height:100svh with overflow:hidden and
|
||||
* .fs-main is its own overflow:auto scroller, so Chrome never grows the document past the
|
||||
* viewport — but Firefox propagates ~158px of an out-of-flow descendant's scrollable
|
||||
* overflow past both overflow ancestors up to the initial containing block, painting a
|
||||
* second, whole-page scrollbar beside .fs-main's own (measured on the Overview, where the
|
||||
* .fs-ovl grid makes the column ~2800px tall: html.scrollHeight 1058 against a 900px
|
||||
* viewport, and 900 once contained). overflow:hidden does not stop it: it hides the extra
|
||||
* scrollbar while the document still scrolls those 158px, dragging the fixed sidebar
|
||||
* off-screen. Paint containment makes .fs-main the containing block for that descendant
|
||||
* and clips it. LuCI modals are position:fixed on <body>, not inside .fs-main, so the new
|
||||
* containing block does not re-base them. No-op in Chrome. */
|
||||
contain: paint;
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar {
|
||||
width: var(--fs-sidebar-w); height: 100svh;
|
||||
flex: 0 0 auto;
|
||||
position: static;
|
||||
flex-direction: column; flex-wrap: nowrap; align-items: normal;
|
||||
gap: normal; padding: var(--fs-space-5) var(--fs-space-3-5);
|
||||
background: var(--fs-panel);
|
||||
border-inline-end: var(--fs-hairline); border-bottom: 0;
|
||||
box-shadow: none;
|
||||
/* `overflow: auto`, not overflow-y alone: the bar sets `overflow: visible` for its
|
||||
* popups, and a lone overflow-y here would leave overflow-x visible — which the
|
||||
* spec forces back to auto anyway. Say both. */
|
||||
overflow: auto;
|
||||
z-index: auto;
|
||||
}
|
||||
/* the column is already 224px wide — that IS the cap, so the bar's 30ch one must go
|
||||
* or the brand is capped twice, at the wrong value */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-brandrow {
|
||||
display: flex; align-items: center; gap: var(--fs-space-1-5);
|
||||
flex: 0 0 auto; order: 0; min-width: auto; max-width: none; padding: 0 var(--fs-space-1) var(--fs-space-5) var(--fs-space-2);
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-navlabel {
|
||||
display: block;
|
||||
color: var(--fs-dim);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-weight-bold); letter-spacing: .1em;
|
||||
text-transform: uppercase;
|
||||
padding: var(--fs-space-1-5) var(--fs-space-2-5) var(--fs-space-2);
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-spacer { display: block; flex: 1 1 auto; min-height: 12px; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-railtoggle { display: inline-flex; }
|
||||
/* :not(:empty):not(.single) in the SHOW rule, not a separate hide pair: the bar's base
|
||||
* rule (top of this file) already hides .fs-modemenu, so an empty/single-mode strip
|
||||
* simply never opts in. The hide pair existed twice (here and 50-toplayout.css),
|
||||
* byte-identical and unpinned — the drift shape @mirror exists for, folded instead. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-modemenu:not(:empty):not(.single) { display: flex; margin-top: var(--fs-space-1); }
|
||||
|
||||
/* vertical main nav */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar #modemenu {
|
||||
order: 0; flex: 0 1 auto;
|
||||
flex-direction: column; flex-wrap: nowrap; align-items: normal; gap: var(--fs-space-0-5);
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li.has-sub { position: relative; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li > a {
|
||||
display: flex; align-items: center; gap: var(--fs-space-3);
|
||||
padding: var(--fs-space-2-5) var(--fs-space-3);
|
||||
/* Bold is the root level's own signal, and the one the type scale can promise:
|
||||
* `--fs-weight-bold` has a face everywhere, while `--fs-weight-normal` has none of its own
|
||||
* — so lightening the CHILDREN instead looks like hierarchy on a system stack and like
|
||||
* nothing at all on a router whose admin installed a 600/700 subset. Only the accordion is
|
||||
* deep enough to need the distinction. */
|
||||
font-size: var(--fs-type); font-weight: var(--fs-weight-bold); white-space: normal;
|
||||
line-height: 1.1;
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li > a .fs-ico { display: block; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li > a .fs-chevron { display: block; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav .fs-ico,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-themerow .fs-ico,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-logout .fs-ico { width: 17px; height: 17px; }
|
||||
|
||||
/* nested submenu -> an inline accordion, not a popup */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav ul {
|
||||
display: none;
|
||||
/* the bar anchors this panel under itself (absolute + top/left); an accordion is
|
||||
* just the next block in the column, so the offsets must go back to auto or they
|
||||
* linger in the computed style */
|
||||
position: static; top: auto; inset-inline: auto; z-index: auto;
|
||||
width: auto; min-width: 0; max-width: none;
|
||||
flex-direction: column; gap: var(--fs-space-0-5);
|
||||
margin: 0 0 0 var(--fs-space-7); padding: 0;
|
||||
background: none;
|
||||
border: 0; border-radius: 0; box-shadow: none;
|
||||
overflow: hidden;
|
||||
}
|
||||
/* and the bar's hover bridge goes with the popup. The panel is static here, so the
|
||||
* bridge's containing block falls back to the <li> — an invisible 10px strip sitting
|
||||
* ABOVE the section, i.e. over the previous menu item, swallowing its clicks. The rail
|
||||
* (below) is a popup again but flies its panel out sideways, and brings its own
|
||||
* horizontal bridge (li.has-sub::after). */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li.has-sub > ul::before { content: none; }
|
||||
/* ---- the open section is a group, and has to look like one ----
|
||||
*
|
||||
* An indent alone does not say where a long section ends: after ten children the next root
|
||||
* category reads as an eleventh child (issue #37). A hairline down the group's reading edge
|
||||
* draws that boundary and the wider bottom margin separates the last child from the next
|
||||
* category.
|
||||
*
|
||||
* No `:not([data-rail="true"])` guard: in the rail this same `ul` becomes a flyout card,
|
||||
* whose rule below restates `border` and `margin` as shorthands at higher specificity, so
|
||||
* neither declaration here survives into it. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li.open > ul {
|
||||
display: flex;
|
||||
margin: var(--fs-space-1) 0 var(--fs-space-3) var(--fs-space-7);
|
||||
padding-inline-start: var(--fs-space-1);
|
||||
border-inline-start: var(--fs-hairline);
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav > li.has-sub.open > ul { display: flex; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar ul.nav ul a { padding: var(--fs-space-2) var(--fs-space-3); }
|
||||
|
||||
/* the Appearance trigger and Log out are full-width text rows down here */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-themerow,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-logout {
|
||||
order: 0; margin-inline-start: 0;
|
||||
width: 100%; height: auto;
|
||||
justify-content: normal;
|
||||
gap: var(--fs-space-3); padding: var(--fs-space-2-5) var(--fs-space-3);
|
||||
border: 0; border-radius: var(--fs-radius);
|
||||
background: transparent;
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-themerow { text-align: start; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-logout { font-weight: var(--fs-weight); font-size: var(--fs-type); }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-logout:hover { background: var(--fs-panel2); border-color: transparent; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-themerow:hover,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-themerow[aria-expanded="true"] { border-color: transparent; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-themerow .fs-label,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-logout .fs-label { display: block; flex: 1 1 auto; }
|
||||
|
||||
/* the poll pill sits in the sidebar footer, above Appearance */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar #indicators {
|
||||
order: 0; margin-inline-start: 0;
|
||||
flex-wrap: wrap; gap: var(--fs-space-1-5);
|
||||
padding: 0 var(--fs-space-1-5) var(--fs-space-1);
|
||||
}
|
||||
/* In the column the indicator is not one of a row of buttons but one of a stack of
|
||||
* ROWS — Appearance and Log out below it run the sidebar's full width. A pill floating
|
||||
* at 87px in a 195px column read as a stray chip; give it its neighbours' width. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar #indicators .label,
|
||||
:root[data-layout="sidebar"]:not([data-narrow]) .fs-sidebar #indicators [data-indicator] {
|
||||
flex: 1 1 100%;
|
||||
justify-content: center;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* THE APPEARANCE CONTROLS USED TO LIVE HERE, as a popover on <body> plus the segmented and
|
||||
* slider controls it was built from. They are a PAGE now (System -> Appearance) and their CSS
|
||||
* moved with them, to styles/pages/80-appearance.css — a page's styles belong in the page layer,
|
||||
* and the shell no longer draws any of it. */
|
||||
|
||||
/* ---- collapsed sidebar (icon rail) ----
|
||||
* <html data-rail="true">, persisted in localStorage and re-applied before paint by head.ut.
|
||||
* Labels collapse and a section's submenu becomes a flyout anchored right of its icon, opened on
|
||||
* hover or on focus — which is what a tap on the section link produces on touch.
|
||||
*
|
||||
* The guard must be exactly the vertical sidebar's: same media floor, same :not([data-narrow]).
|
||||
* It once said `min-width: 768px` against the vertical block's 521, and between the two the
|
||||
* vertical rules applied without the rail ones, so the sidebar sprang back to its full 224px —
|
||||
* it EXPANDED as the window shrank — while the JS measurement was subtracting the rail's 68px.
|
||||
* The rail is a MODE of the vertical sidebar and can never be visible under conditions the
|
||||
* vertical sidebar is not. */
|
||||
@media (min-width: 521px) {
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar {
|
||||
width: var(--fs-rail-w); padding: var(--fs-space-5) var(--fs-space-2-5);
|
||||
/* the default `overflow-y: auto` computes overflow-x to `auto` as well,
|
||||
* which would clip the flyouts; the rail is short enough not to scroll */
|
||||
overflow: visible;
|
||||
/* NO z-index / no sticky: the sidebar is a static element (see the scroll-model note
|
||||
* above), so it is not a composited layer and its overflow:visible flyouts leave no
|
||||
* stale seam (issue #7). The flyouts still cover the content on their own --fs-z-flyout
|
||||
* in the root stacking context. */
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-brandrow { flex-direction: column; gap: var(--fs-space-2-5); padding: 0 0 var(--fs-space-5); }
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-brand { flex: 0 0 auto; justify-content: center; }
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-railtoggle .fs-ico { rotate: 180deg; }
|
||||
|
||||
/* only the rail's own labels collapse — a `.fs-label` also exists on every
|
||||
* submenu link, and those live inside the flyout where they must stay */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-wordmark,
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-navlabel,
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-modemenu,
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li > a > .fs-label,
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-themerow > .fs-label,
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-logout > .fs-label,
|
||||
/* The chevron is an affordance for a section you can UNFOLD; a rail item has no label and no
|
||||
* accordion — its children fly out sideways — so it says nothing and crowds the icon.
|
||||
*
|
||||
* The selector must be this long: the vertical override turns the chevron back on at
|
||||
* (0,6,3), so a plainer `.fs-sidebar .fs-chevron` here is only (0,6,0) and loses. Match its
|
||||
* shape and add the rail attribute: (0,7,3). */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li > a .fs-chevron { display: none; }
|
||||
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li > a,
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-themerow,
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-logout {
|
||||
justify-content: center; gap: 0; padding: var(--fs-space-2-5) 0;
|
||||
}
|
||||
|
||||
/* leaf sections have no flyout — show their name as a tooltip bubble */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li:not(.has-sub) > a::after {
|
||||
content: attr(data-label);
|
||||
position: absolute; inset-inline-start: 100%; top: 50%; transform: translateY(-50%);
|
||||
margin-inline-start: var(--fs-space-2-5); z-index: var(--fs-z-flyout);
|
||||
padding: var(--fs-space-1-5) var(--fs-space-2-5); border-radius: var(--fs-radius-sm);
|
||||
background: var(--fs-panel); border: var(--fs-hairline);
|
||||
box-shadow: var(--fs-shadow-pop);
|
||||
color: var(--fs-text); font-size: var(--fs-type); font-weight: var(--fs-weight); white-space: nowrap;
|
||||
opacity: 0; pointer-events: none; transition: opacity var(--fs-dur);
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li:not(.has-sub) > a:hover::after { opacity: 1; }
|
||||
|
||||
/* the flyout: opened by hover on a mouse, or by .open which the menu JS toggles on tap
|
||||
* (exclusively — menu-footstrap.js flyoutMode). The hover rule is gated on a real
|
||||
* pointer: mobile browsers leave :hover stuck on the tapped element, which would block
|
||||
* tap-to-close. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li.has-sub > ul {
|
||||
display: none;
|
||||
position: absolute; inset-inline-start: 100%; top: -8px; margin: 0; margin-inline-start: var(--fs-space-2-5);
|
||||
min-width: 196px; padding: var(--fs-space-2); z-index: var(--fs-z-flyout);
|
||||
background: var(--fs-panel); border: var(--fs-hairline); border-radius: var(--fs-radius-lg);
|
||||
box-shadow: var(--fs-shadow-pop);
|
||||
animation: fs-fade var(--fs-dur);
|
||||
}
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li.has-sub.open > ul { display: flex; }
|
||||
@media (hover: hover) {
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li.has-sub:hover > ul { display: flex; }
|
||||
}
|
||||
/* The flyout's heading, so the collapsed icon still names its section.
|
||||
*
|
||||
* It must UNDO the bar's hover bridge (issue #22): this same ::before is the bar's invisible
|
||||
* 10px hover bridge above the panel, so re-pointing `content` at the title while leaving
|
||||
* `position`, `inset` and `height` in force renders the heading as a 10px-tall absolute box
|
||||
* above the flyout, clipped in half by the panel's own overflow. The rail brings its own
|
||||
* bridge as `li.has-sub::after`. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li > ul[data-title]::before {
|
||||
content: attr(data-title);
|
||||
position: static; inset: auto; height: auto;
|
||||
padding: var(--fs-space-1) var(--fs-space-3) var(--fs-space-2);
|
||||
color: var(--fs-eyebrow-color); font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight);
|
||||
letter-spacing: var(--fs-eyebrow-tracking); text-transform: uppercase;
|
||||
}
|
||||
/* bridge the 10px gap so the pointer can travel icon -> flyout without a hover drop */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar ul.nav > li.has-sub::after {
|
||||
content: ""; position: absolute; inset-inline-start: 100%; top: 0;
|
||||
width: 12px; height: 100%;
|
||||
}
|
||||
|
||||
/* Collapsed rail: swap the "Refreshing" word for a green refresh glyph — a masked SVG tinted
|
||||
* with --fs-good, so it follows the palette. Only poll-status becomes an icon; other
|
||||
* indicators keep their pill.
|
||||
*
|
||||
* These two must carry the FULL guard, not the [data-rail] half alone: head.ut stamps
|
||||
* data-rail from localStorage pre-paint while data-narrow is written later by an async
|
||||
* module, so on a narrow phone a rail user has every other rail rule excluded by the floor
|
||||
* while these two match — the pill paints as a bare green glyph inside the phone bar until
|
||||
* the modules land, permanently if they fail.
|
||||
*
|
||||
* The box is --fs-ctl-h-sm rather than --fs-btn-size: one step under the bar's compact pill,
|
||||
* the rail being a column of icons rather than a row of equal squares. A literal here would
|
||||
* silently opt out of the Density axis. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar #indicators [data-indicator="poll-status"] {
|
||||
font-size: 0; width: var(--fs-ctl-h-sm); height: var(--fs-ctl-h-sm); padding: 0;
|
||||
border: 0; box-shadow: none; background: var(--fs-good);
|
||||
/* @mirror poll-glyph/mask */
|
||||
-webkit-mask: var(--fs-icon-refresh) center / var(--fs-icon-refresh-sz) no-repeat;
|
||||
mask: var(--fs-icon-refresh) center / var(--fs-icon-refresh-sz) no-repeat;
|
||||
/* @endmirror */
|
||||
/* STATIC, deliberately. A spinner promises something you are WAITING for; this is a
|
||||
* poll running quietly in the background forever, and a permanently spinning glyph
|
||||
* makes an idle router look busy. The spin also broke the click that pauses the poll —
|
||||
* a target that never stops moving cannot be hit. */
|
||||
}
|
||||
|
||||
/* paused: the same glyph gone quiet. Without this the rail kept saying GREEN while the poll
|
||||
* was stopped — the one thing the indicator exists to tell you, and it was lying. (The pill
|
||||
* gets this for free: its --fs-good only applies to [data-style="active"].) */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] .fs-sidebar #indicators [data-indicator="poll-status"]:not([data-style="active"]) {
|
||||
background: var(--fs-dim);
|
||||
}
|
||||
|
||||
/* Every other indicator — "Unsaved Changes: N" and whatever a third-party app shows. Its label
|
||||
* is prose and the rail is 68px: that pill wants 86px, wraps onto three lines and hangs 34px
|
||||
* past the rail's edge over the content (issue #14). The pill is not ours to shorten, so it
|
||||
* becomes a square in the poll glyph's box showing the COUNT alone, lifted into
|
||||
* data-fs-badge by fs-chrome.js because a text node cannot be reached by a selector.
|
||||
* `font-size: 0` kills the prose without removing it: the label stays in the DOM for a
|
||||
* screen reader and in the `title` for the pointer.
|
||||
*
|
||||
* What the badge says is decided in the JS, so this stays one rule per box: as two CSS rules
|
||||
* it needs an extra attribute and a `:not()` to tell them apart, which pushes the sheet's
|
||||
* widest selector past the css-metrics ratchet.
|
||||
*
|
||||
* `.fs-sidebar` is deliberately absent: #indicators is an id. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] #indicators [data-indicator]:not([data-indicator="poll-status"]) {
|
||||
/* min-width, not width: the count is unbounded (a big config can queue three digits) and
|
||||
* a fixed box would clip it. It grows from the poll glyph's square and stops at the
|
||||
* rail's inner width. */
|
||||
font-size: 0; min-width: var(--fs-ctl-h-sm); max-width: 100%; height: var(--fs-ctl-h-sm);
|
||||
box-sizing: border-box; padding: 0 var(--fs-space-1); overflow: hidden;
|
||||
display: inline-flex; align-items: center; justify-content: center;
|
||||
}
|
||||
/* The top bar's compact step paints the same badge (the .fs-ind-compact rule above, whose
|
||||
* copy of this paint is mirror-pinned to it) and CANNOT share this rule: that one applies at
|
||||
* every width, while this one must stay inside the 521px floor —
|
||||
* below it a rail user has data-rail stamped pre-paint but data-narrow not yet written, so a
|
||||
* merged rule would strip the phone bar's indicator to a bare digit until the modules land. */
|
||||
:root[data-layout="sidebar"]:not([data-narrow])[data-rail="true"] #indicators [data-indicator]:not([data-indicator="poll-status"])::after {
|
||||
/* @mirror ind-badge/paint */
|
||||
content: attr(data-fs-badge);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-weight-bold); font-variant-numeric: tabular-nums;
|
||||
/* @endmirror */
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------- main column ---------- */
|
||||
.fs-main {
|
||||
flex: 1 1 auto;
|
||||
min-width: 0;
|
||||
display: flex; flex-direction: column;
|
||||
background: var(--fs-bg);
|
||||
overflow-x: clip;
|
||||
}
|
||||
.fs-sidebar #indicators:empty { display: none; }
|
||||
.fs-indicators { flex-wrap: wrap; }
|
||||
.fs-content { padding: var(--fs-space-5) var(--fs-content-pad); flex: 1 1 auto; width: 100%; max-width: var(--fs-content-max); margin: 0 auto; }
|
||||
|
||||
/* ---- the staging area a client navigation renders into ----
|
||||
* fs-router.js renders the incoming page into a second `#view` inside this wrapper, first in
|
||||
* tree order, and moves its children into the live one when the render completes, so the page on
|
||||
* screen is never emptied while the next one loads.
|
||||
*
|
||||
* Hidden but LAID OUT, and the three declarations are not interchangeable. `visibility: hidden`
|
||||
* takes it off the screen while keeping the box: several views size themselves from the element
|
||||
* they render into, and `display: none` would hand them a zero width they keep for the life of
|
||||
* the instance. `height: 0` stops the page under it from moving, and `overflow: clip` keeps the
|
||||
* content overflowing that zero height from painting — `clip` rather than `hidden`, since a
|
||||
* scroll container would be a new scrollport in the middle of the content column. */
|
||||
.fs-staging { visibility: hidden; height: 0; overflow: clip; }
|
||||
|
||||
/* ---- and the hairline that says a slow navigation is under way ----
|
||||
* Shown only once a navigation outlives 150 ms (fs-router.js), so a warm click never flashes it.
|
||||
*
|
||||
* Fixed, at the top of the viewport, and a child of <body> — all three load-bearing. In the
|
||||
* content column it is a flex item of `.fs-main`, and a column flex container shrinks its 2px to
|
||||
* zero (measured: height 0 in the sidebar layout, and with `margin-bottom: -2px` the content
|
||||
* painted over what was left); and it cannot live inside `.fs-shell` either, that box carrying
|
||||
* `contain: paint`, which
|
||||
* makes a fixed descendant position against the shell and be clipped by it. The top of the
|
||||
* viewport is also where a browser puts its own progress.
|
||||
*
|
||||
* `transform` and `opacity` only, both composited, so this cannot cost the render it is
|
||||
* reporting on. Reduced motion keeps the bar and drops its animation. */
|
||||
#fs-nav-progress {
|
||||
position: fixed; inset-inline: 0; top: 0;
|
||||
height: 2px;
|
||||
background: var(--fs-accent);
|
||||
transform: scaleX(0); transform-origin: left center;
|
||||
opacity: 0; pointer-events: none;
|
||||
z-index: var(--fs-z-tooltip);
|
||||
}
|
||||
:root[dir="rtl"] #fs-nav-progress { transform-origin: right center; }
|
||||
#fs-nav-progress[data-state="active"] {
|
||||
opacity: 1;
|
||||
transform: scaleX(.8);
|
||||
transition: transform 2s cubic-bezier(.1, .7, .1, 1), opacity 120ms linear;
|
||||
}
|
||||
#fs-nav-progress[data-state="done"] {
|
||||
opacity: 0;
|
||||
transform: scaleX(1);
|
||||
transition: transform 120ms ease-out, opacity 300ms linear 100ms;
|
||||
}
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
#fs-nav-progress[data-state="active"],
|
||||
#fs-nav-progress[data-state="done"] { transition: none; transform: scaleX(1); }
|
||||
}
|
||||
|
||||
/* ---------- footer ----------
|
||||
* Bare `footer`, not `footer.fs-footer`: the theme owns footer paint outright (absorbed
|
||||
* from base, which keeps only the flex skeleton), so a third-party view emitting its own
|
||||
* <footer> stays themed too. */
|
||||
footer {
|
||||
padding: var(--fs-space-3-5) var(--fs-content-pad); border-top: var(--fs-hairline);
|
||||
color: var(--fs-dim); font-size: var(--fs-type); background: var(--fs-bg);
|
||||
/* Centre the flex LINE, not just the text: base makes the footer a flex container
|
||||
* (base/50-chrome.css) and declares no `justify-content`, so the initial `flex-start` packs
|
||||
* the single <span> at the start and leaves text-align nothing to centre, the span
|
||||
* shrinking to its content. */
|
||||
justify-content: center;
|
||||
text-align: center;
|
||||
/* And space the lines, because the two links become adjacent TARGETS the moment the line wraps.
|
||||
* The footer is one sentence carrying the LuCI link and the OpenWrt link; at the width where
|
||||
* it breaks they land on consecutive lines, and with the inherited leading that is 16px
|
||||
* between their centres — inside the 24px envelope WCAG 2.2 SC 2.5.8 requires around a
|
||||
* target smaller than 24x24, which an inline link always is. Found by tools/live-audit.mjs on
|
||||
* CI's runner and not on the stands: the wrap width depends on text metrics, so the same
|
||||
* 568px viewport breaks the line there and not here. 26px, not 24: the criterion is that the
|
||||
* two circles must not meet, so 24 is the boundary rather than a pass.
|
||||
*
|
||||
* A FLOOR, not a fixed number, and not a bare ratio either: `--fs-type` follows the Density
|
||||
* axis, so a plain `26px` would be the one leading in this file that ignores it, while a
|
||||
* unitless `2` follows the axis straight back under 24px at Compact (11.7px x 2 = 23.4) —
|
||||
* where the wrap this rule exists for is most likely. `max()` is both: 26px at the default
|
||||
* and at Compact, 29.9px at Large. */
|
||||
line-height: max(26px, calc(var(--fs-type) * 2));
|
||||
}
|
||||
footer a { color: var(--fs-dim); }
|
||||
footer a:hover { color: var(--fs-accent); }
|
||||
|
||||
/* the phone bar is the base above; only the content gutter is width-driven */
|
||||
@media (max-width: 767px) {
|
||||
.fs-content { padding: var(--fs-space-4); }
|
||||
}
|
||||
|
||||
|
||||
/* Notifications — ui.addNotification prepends .alert-message as the first child of
|
||||
* #maincontent (.fs-main). Order it above the content and give it card spacing. */
|
||||
.fs-main > .alert-message {
|
||||
order: 1; margin: var(--fs-space-4) auto 0;
|
||||
width: calc(100% - var(--fs-content-pad) * 2);
|
||||
max-width: calc(var(--fs-content-max) - var(--fs-content-pad) * 2);
|
||||
}
|
||||
.fs-main > .fs-content { order: 2; }
|
||||
.fs-main > .fs-footer { order: 3; }
|
||||
|
||||
@media (max-width: 767px) {
|
||||
/* width:auto, not the base width above: that calc subtracts the DESKTOP gutter
|
||||
* (--fs-content-pad, 28px a side) while .fs-content's own gutter is 16px here — the
|
||||
* alert came out 24px narrower than the content and hugged the left (measured at 700px:
|
||||
* insets 16/40 where the content sits 16/16). auto + the side margins matches the
|
||||
* content column exactly at any width in this tier. */
|
||||
.fs-main > .alert-message { margin: var(--fs-space-3) var(--fs-space-4) 0; width: auto; }
|
||||
}
|
||||
|
||||
/* Phone: alerts (e.g. the sysupgrade banner, injected by ui.addNotification as a
|
||||
* `.fs-main > .alert-message` — a SIBLING of #view, not a child) lay their action buttons
|
||||
* in a nowrap flex row, so on a ~344px screen the trailing Dismiss button was shoved past
|
||||
* the panel and clipped by .fs-main's overflow-x: clip. Scoped to .fs-main so it covers
|
||||
* those top-level alerts and any inside #view. */
|
||||
@media (max-width: 767px) {
|
||||
.fs-main .alert-message { flex-wrap: wrap; }
|
||||
.fs-main .alert-message > * { min-width: 0; margin-inline-start: 0; }
|
||||
/* the action row is a nested flex that stayed nowrap, so the first button's label got
|
||||
* clipped when Dismiss sat beside it. Wrap the inner rows; let labels break. */
|
||||
.fs-main .alert-message div { flex-wrap: wrap; min-width: 0; }
|
||||
.fs-main .alert-message .btn,
|
||||
.fs-main .alert-message button { white-space: normal; max-width: 100%; }
|
||||
}
|
||||
|
||||
/* poll-status ("Refreshing") — subtle, not a loud accent chip */
|
||||
.fs-indicators .label,
|
||||
.fs-indicators [data-indicator],
|
||||
#indicators .label,
|
||||
#indicators [data-indicator] {
|
||||
/* An indicator sits in a ROW of controls — in the bar, followed by Search and Log out — so it
|
||||
* must look like one of them or the cluster reads as three unrelated things. The same
|
||||
* --fs-btn-size height (a box sized by its font's line-box comes out 28px, visibly the odd
|
||||
* one out) and the same --fs-radius corner, not --fs-radius-pill: a capsule beside two
|
||||
* rounded squares announces itself as a different kind of object, which it is not. Width
|
||||
* stays the content's. */
|
||||
display: inline-flex; align-items: center;
|
||||
min-height: var(--fs-btn-size);
|
||||
text-transform: none;
|
||||
font-weight: var(--fs-weight); font-size: var(--fs-type);
|
||||
/* the bar's control surface, not the panel: this pill sits in the same row as the square
|
||||
* buttons and wears what they wear. Verified on the live DOM rather than by reading —
|
||||
* ui.js emits the indicator as a bare `<span data-indicator=…>` with NO class, so a rule
|
||||
* written against `.label` (as one here briefly was) matches nothing at all. */
|
||||
background: var(--fs-bar-ctl-bg); background-image: none;
|
||||
border: var(--fs-hairline);
|
||||
color: var(--fs-dim);
|
||||
border-radius: var(--fs-radius); padding: 0 var(--fs-space-3); box-shadow: none;
|
||||
}
|
||||
.fs-indicators [data-indicator][data-style="active"],
|
||||
#indicators [data-indicator][data-style="active"] { color: var(--fs-good); }
|
||||
/* nothing else gives a clickable indicator a pointer cursor (base's `header
|
||||
* [data-indicator]` rule carries geometry only, and this theme emits no <header> at all),
|
||||
* so "Refreshing" showed a text caret. */
|
||||
.fs-indicators [data-indicator][data-clickable],
|
||||
#indicators [data-indicator][data-clickable] { cursor: pointer; }
|
||||
/* fs-chrome.js promotes a clickable indicator to role="button" with Enter and Space, so
|
||||
* it is a control now and takes the control ring the buttons beside it take (55-buttons.css)
|
||||
* rather than the UA outline it was left with. `:focus-visible`, not `:focus`: a pointer press
|
||||
* on the pill should not draw a ring, the same rule every other control here follows. */
|
||||
.fs-indicators [data-indicator][data-clickable]:focus-visible,
|
||||
#indicators [data-indicator][data-clickable]:focus-visible {
|
||||
outline: none;
|
||||
border-color: var(--fs-accent);
|
||||
box-shadow: var(--fs-focus-ring);
|
||||
}
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
@layer theme {
|
||||
/* One thin meter for every .cbi-progressbar (overview Memory/Storage/Network, Software
|
||||
* disk space, package manager …): slim rounded track, accent fill, and the LuCI title
|
||||
* value floated just above the bar's right edge (mono/dim) instead of stuffed inside a fat
|
||||
* pill. No per-page overrides. */
|
||||
.cbi-progressbar {
|
||||
position: relative;
|
||||
height: 10px;
|
||||
background: var(--fs-track);
|
||||
border: 0;
|
||||
border-radius: var(--fs-radius-pill);
|
||||
overflow: visible;
|
||||
min-width: 120px;
|
||||
margin: 0;
|
||||
}
|
||||
.cbi-progressbar > div {
|
||||
height: 100%;
|
||||
background: var(--fs-accent);
|
||||
border-radius: var(--fs-radius-pill);
|
||||
transition: width var(--fs-dur-fill);
|
||||
}
|
||||
/* Colour carries the reading too, not length alone: `data-fs-level` is set from JS
|
||||
* (menu-footstrap-common.js, FS_METER_WARN/FS_METER_DANGER — 80/92%, a decision, not a
|
||||
* measurement) on every poll tick. Solid tokens, matching the accent fill above — no
|
||||
* color-mix, so no static twin is owed to 04-nocolormix.css. */
|
||||
.cbi-progressbar[data-fs-level="warn"] > div {
|
||||
background: var(--fs-warn);
|
||||
}
|
||||
.cbi-progressbar[data-fs-level="danger"] > div {
|
||||
background: var(--fs-danger);
|
||||
}
|
||||
.cbi-progressbar::after {
|
||||
content: attr(title);
|
||||
/* the gap is a scale step, not a literal 4: every other gap in the theme scales with the
|
||||
* density axis and this one sat outside it. Identical at the default density. */
|
||||
position: absolute; inset-inline: auto 0; bottom: calc(100% + var(--fs-space-1)); top: auto;
|
||||
font-family: var(--fs-font-mono); font-size: var(--fs-type-xs); font-weight: var(--fs-weight-normal);
|
||||
color: var(--fs-dim); white-space: nowrap; text-shadow: none;
|
||||
}
|
||||
|
||||
/* The value sits BESIDE the bar wherever the bar already shares its line with a name.
|
||||
*
|
||||
* The default above puts it over the bar's far edge, which assumes the Overview's shape: the
|
||||
* meter owns a full-width line and its name sits on the line above, so the value lands at the
|
||||
* far end of that name's line and the two read as one row. Two shapes are not that, and CSS
|
||||
* cannot ask whether a row carries its own label, so each is named:
|
||||
*
|
||||
* `.cbi-value-field > .cbi-progressbar` the meter IS the field of a CBI form row, where the
|
||||
* value otherwise lands against the row divider rather than beside its own bar
|
||||
* `.table:has(.tr.table-titles) .td …` a meter COLUMN in a multi-column data table, where
|
||||
* the floated value lands on the row divider too
|
||||
*
|
||||
* Both want the same geometry and differ in one number, so the geometry is written once and
|
||||
* `--fs-meter-value` is the knob: a form row holds `-140.0 dBm`, half again as wide as a table
|
||||
* cell's `100% (1.2 GiB)`. The Overview and the package manager keep the value above the bar,
|
||||
* their meters being neither shape. */
|
||||
/* ONE RULE PER SHAPE, not one selector list for both, and the split is not cosmetic: the table
|
||||
* half needs `:has()`, and an engine that cannot parse a selector discards the WHOLE rule —
|
||||
* siblings included. Grouped, the form row (which needs nothing new) lost its placement on such
|
||||
* an engine along with the cell that was unreachable there anyway. The declarations they share
|
||||
* are @mirror-pinned instead, so the two copies cannot drift. */
|
||||
.cbi-value-field > .cbi-progressbar {
|
||||
/* @mirror meter/beside */
|
||||
margin-inline-end: var(--fs-meter-value);
|
||||
/* @endmirror */
|
||||
--fs-meter-value: calc(var(--fs-space-10) * 2);
|
||||
}
|
||||
.cbi-value-field > .cbi-progressbar::after {
|
||||
/* @mirror meter/beside-value */
|
||||
inset-inline: calc(100% + var(--fs-space-2)) auto; bottom: auto; top: 50%;
|
||||
transform: translateY(-50%);
|
||||
/* @endmirror */
|
||||
}
|
||||
.cbi-section .table:has(.tr.table-titles) .td .cbi-progressbar {
|
||||
/* @mirror meter/beside */
|
||||
margin-inline-end: var(--fs-meter-value);
|
||||
/* @endmirror */
|
||||
--fs-meter-value: var(--fs-space-10);
|
||||
/* narrower than this it stops reading as a meter at all; the column gives up the rest. */
|
||||
min-width: 60px;
|
||||
}
|
||||
.cbi-section .table:has(.tr.table-titles) .td .cbi-progressbar::after {
|
||||
/* @mirror meter/beside-value */
|
||||
inset-inline: calc(100% + var(--fs-space-2)) auto; bottom: auto; top: 50%;
|
||||
transform: translateY(-50%);
|
||||
/* @endmirror */
|
||||
}
|
||||
|
||||
/* …and back above the bar once that column becomes a card.
|
||||
*
|
||||
* The rule above puts the value beside the bar because a table column shares its row with other
|
||||
* columns. A carded row is not that: `.fs-stacked` gives each cell half the card, so "beside"
|
||||
* is outside the cell and the value runs across the neighbouring column and over the label
|
||||
* above it (reported twice from a phone, at every density).
|
||||
*
|
||||
* So the card puts it back over the bar's far edge and buys it a line: the bar takes a top
|
||||
* margin of one --fs-type-xs line, so the value sits between the label and the bar instead of
|
||||
* on either. 6-9px of overlap before, none after.
|
||||
*
|
||||
* The selector carries `:has(.tr.table-titles)` for specificity alone — that is what the
|
||||
* beside-rule above matches on, and `:has()` counts its argument, which makes it (0,6,0), so a
|
||||
* plainer selector here loses (measured: `margin-inline-end` still 40px). The title row is
|
||||
* still in the DOM when the table is carded; the card only hides it. */
|
||||
.cbi-section .table.fs-stacked:has(.tr.table-titles) .td .cbi-progressbar {
|
||||
margin-inline-end: 0;
|
||||
margin-block-start: calc(var(--fs-type-xs) * var(--fs-leading));
|
||||
}
|
||||
.cbi-section .table.fs-stacked:has(.tr.table-titles) .td .cbi-progressbar::after {
|
||||
inset-inline: auto 0;
|
||||
bottom: calc(100% + var(--fs-space-1));
|
||||
top: auto;
|
||||
transform: none;
|
||||
}
|
||||
|
||||
/* Progressbar rows in a section table (luci-app-cpu-status): keep the native label | bar
|
||||
* row, just centre the cells vertically. */
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table) .tr:has(.cbi-progressbar) .td { vertical-align: middle; }
|
||||
}
|
||||
@@ -1,834 +0,0 @@
|
||||
@layer theme {
|
||||
/* ---------- panels / cards (cbi) ---------- */
|
||||
.cbi-section, .cbi-map > .cbi-section-node, fieldset.cbi-section, .panel {
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
}
|
||||
.cbi-section { padding: var(--fs-card-pad); margin-bottom: var(--fs-card-gap); }
|
||||
/* a bare <legend>; the ones inside a .cbi-section are covered below. The ink is the heading
|
||||
* ramp's (45-misc.css) — legend is kept out of that group so this rule stays its one owner;
|
||||
* no line-height here: base's `fieldset legend` sets 1 and every real legend sits in a
|
||||
* fieldset, so stating leading here would silently repaint them all through the layer. */
|
||||
legend { font-size: var(--fs-type-lg); font-weight: var(--fs-weight-bold); color: var(--fs-text); }
|
||||
|
||||
/* overview (luci-mod-status) DOM:
|
||||
* .cbi-section > .cbi-title>h3 + div > table.table (.tr/.td) */
|
||||
|
||||
/* section title + collapse control */
|
||||
.cbi-section > .cbi-title { margin-bottom: var(--fs-space-3); }
|
||||
.cbi-section > .cbi-title h3,
|
||||
.cbi-section > h3:first-child,
|
||||
.cbi-section > legend {
|
||||
font-size: var(--fs-type-lg); font-weight: var(--fs-weight-bold); color: var(--fs-text);
|
||||
margin: 0; padding: 0; border: 0;
|
||||
}
|
||||
/* A bare section title (no .cbi-title wrapper) sat flush against the content below it —
|
||||
* on System → System the "System Properties" h3 touched the tab strip. Give it the same
|
||||
* 12px the .cbi-title wrapper already carries above. Excludes .cbi-title h3: that variant
|
||||
* gets its gap from the wrapper's own margin-bottom, so flagging the inner h3 too would
|
||||
* double it. */
|
||||
.cbi-section > h3:first-child,
|
||||
.cbi-section > legend { margin-bottom: var(--fs-space-3); }
|
||||
|
||||
/* A second heading inside the same card — the one that follows a table rather than opening the
|
||||
* section — has no air at all: on Status -> Overview the stock includes stack `table + h3 +
|
||||
* table` inside one .cbi-section, and the heading reads as another row of the table above it.
|
||||
* The rule above cannot cover it, `:first-child` being what excludes the one that opens the
|
||||
* card. The two values are the ladder's own: a heading is separated from what came before by
|
||||
* more than from what it introduces. */
|
||||
.cbi-section .table + h3 { margin-top: var(--fs-space-5); }
|
||||
.cbi-section h3 + .table { margin-top: var(--fs-space-3); }
|
||||
|
||||
/* ---- tables in cards ----
|
||||
* Discriminator: a key/value include (System, Memory) has NO id; a data table has one
|
||||
* (status_leases) or the JS tag .fs-dt. Key/value is not itself a card — no frame, no clip;
|
||||
* a data table keeps the `.table` frame below. Nested (`.table .table`, `.cbi-value .table`)
|
||||
* and the config-diff dialog (`.cbi-modal .table`) go with key/value. */
|
||||
.cbi-section .table:not([id]):not(.fs-dt),
|
||||
.cbi-section-node .table:not([id]):not(.fs-dt),
|
||||
.cbi-modal .table, .table .table, .cbi-value .table {
|
||||
border: 0; border-radius: 0; overflow: visible; background: none;
|
||||
}
|
||||
.cbi-section .table { margin: 0; width: 100%; }
|
||||
/* A data table straight in #view (no section: package-manager, Startup) misses the width above,
|
||||
* so it sized to preferred width and overflowed the content column — which base already fixes
|
||||
* for EVERY `.table` (`width: 100%`, base/40-tables.css), and has for as long as both rules have
|
||||
* existed. Switched off against the 24 tables that match it across eight pages: no computed
|
||||
* style moved, so the rule only restated a value one layer down. Removed. */
|
||||
/* Config-table fields fill their cell — moved from base with the generic field box in
|
||||
* theme/60-inputs.css (in base these beat its 210px in-layer; left behind they would lose
|
||||
* to it by layer), together with the numeric-cell refinement below them. */
|
||||
.table.cbi-section-table input[type="password"],
|
||||
.table.cbi-section-table input[type="text"],
|
||||
.table.cbi-section-table textarea,
|
||||
.table.cbi-section-table select,
|
||||
.table.cbi-section-table .cbi-select {
|
||||
width: 100%;
|
||||
min-width: auto;
|
||||
}
|
||||
.table.cbi-section-table .td.cbi-section-table-cell select,
|
||||
.table.cbi-section-table .td.cbi-section-table-cell .cbi-select { width: inherit; }
|
||||
/* The filter row (form.js renderHeaderRows) is the one place a field cannot claim the width it
|
||||
* wants: it lives in a table HEADER cell, so the column is as wide as the DATA under it. The
|
||||
* rule above makes it fill that cell; what does not fit is the TEXT, LuCI writing the
|
||||
* placeholder as `Filter ` plus the column title, so a long translated title is sliced
|
||||
* mid-glyph (issue #12). The flag column is the worse half: form.js writes `width: 30px` inline
|
||||
* there, of which the theme's padding ate 24, leaving less than one glyph.
|
||||
*
|
||||
* A denser box and denser type buy back ~20px per column; the ellipsis changes the FAILURE, a
|
||||
* placeholder too long for its column now ending instead of being cut through a letter. Nothing
|
||||
* is lost to it — the column title says the same word directly above. No !important, so the
|
||||
* inline 30px still stands: it is upstream's sizing for a one-character field. */
|
||||
.table.cbi-section-table .cbi-section-filter {
|
||||
padding: var(--fs-space-1) var(--fs-space-1-5);
|
||||
font-size: var(--fs-type-xs);
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
/* width:100% cannot shrink a table below min-content — one long unbreakable value holds the
|
||||
* floor. Breaking values reflows it into the column instead of scrolling, and that break is the
|
||||
* DEFAULT for every cell (base/40-tables.css), so a copy here would say nothing the cascade does
|
||||
* not.
|
||||
*
|
||||
* A rule on this property is back a few lines down, and it is the INVERSE rather than a copy: a
|
||||
* data table gets `break-word` while it is still a table, so its columns keep a floor and an
|
||||
* overflow can be seen. Read that block before touching either. DHCP leases need finer control
|
||||
* (only DUID/IPv6 may break) and get it from `white-space: nowrap`: pages/50-leases.css. */
|
||||
.cbi-section .table .td,
|
||||
.cbi-section .table .th {
|
||||
padding: var(--fs-space-2-5) var(--fs-space-4) var(--fs-space-2-5) 0;
|
||||
border: 0; border-bottom: var(--fs-hairline);
|
||||
line-height: 1.45; vertical-align: middle;
|
||||
text-align: start;
|
||||
}
|
||||
/* Row actions hug the far edge. Base says so too but loses to the `text-align: start` above (an
|
||||
* earlier layer), so restate it. `.cbi-section-table-cell` is the discriminator:
|
||||
* form.TableSection's action cells carry it (firewall zones, port forwards); the hand-built
|
||||
* ones of Wireless (`.td.middle`) and DHCP leases do not, and stay left. */
|
||||
.cbi-section .table .td.cbi-section-table-cell.cbi-section-actions { text-align: end; }
|
||||
.cbi-section .table .tr:last-child .td { border-bottom: 0; }
|
||||
/* Case is the app's, not the theme's: `text-transform: uppercase` stood here and printed LuCI's
|
||||
* own `IPv4 address` as `IPV4 ADDRESS`, which reads as a typo in a column heading rather than as
|
||||
* a style (issue #39). Everything else that made these read as headings — the smaller size, the
|
||||
* weight, the faint ink, the tracking — stays. Four rules carry the same decision: the title row
|
||||
* below, the card label (mirrored into theme/65-dropdown.css) and the alert's table in
|
||||
* theme/35-alerts.css. */
|
||||
.cbi-section .table .th {
|
||||
color: var(--fs-eyebrow-color); font-weight: var(--fs-eyebrow-weight); font-size: var(--fs-type-xs);
|
||||
letter-spacing: var(--fs-eyebrow-tracking);
|
||||
}
|
||||
|
||||
/* --- DATA tables ([id] or JS-tagged .fs-dt): leases, wifi, processes, routes … ---
|
||||
* Symmetric padding so cells clear the table's own contour (below).
|
||||
*
|
||||
* `:is([id], .fs-dt)` is one discriminator at ONE specificity: written as two selector lists the
|
||||
* two names for "data table" land at different weights — `.cbi-section .table[id] .td` (0,4,0)
|
||||
* against `table.fs-dt .td` (0,2,1), the latter losing to the key/value default (0,3,0) — so a
|
||||
* table known only by the JS tag keeps the flush-left padding, with no mono face, no row hover
|
||||
* and no header rule. Status -> Routing emits exactly that shape. */
|
||||
.cbi-section .table:is([id], .fs-dt) .td,
|
||||
.cbi-section .table:is([id], .fs-dt) .th,
|
||||
table.fs-dt .td, table.fs-dt .th { padding: var(--fs-space-2-5) var(--fs-space-3); }
|
||||
.cbi-section .table:is([id], .fs-dt) .td { font-family: var(--fs-font-mono); font-size: var(--fs-type); color: var(--fs-text); }
|
||||
|
||||
/* ---- the floor, and it belongs to the one tier a measurement reads ----
|
||||
*
|
||||
* `base/40-tables.css` breaks every value `anywhere`, the one break value that also lowers the
|
||||
* cell's min-content contribution — to a single character. That is what keeps a table nobody
|
||||
* measures inside its card, and it is also a LIE told to the engine: with no floor, auto table
|
||||
* layout is free to starve a column and the browser answers "it fits", truthfully and uselessly.
|
||||
*
|
||||
* So the floor goes back exactly where it is READ: a data table, while it is still a table.
|
||||
* `break-word` breaks the same values in the same places — the two differ only in whether the
|
||||
* break counts towards min-content (css-text-3 §5.4) — so nothing about the rendering changes;
|
||||
* what changes is that the column can no longer be starved below it, and an overflow becomes
|
||||
* visible to `fit.overflows()`.
|
||||
*
|
||||
* `:not(.fs-stacked)` is the whole guard, and it is the state the fitter measures in (it strips
|
||||
* the class first, fs-fit rule 1). Once carded, every cell has the row to itself.
|
||||
*
|
||||
* base/40-tables.css is deliberately NOT touched: `break-word` there was tried and recorded as a
|
||||
* failure (a table stayed 355px wide in a 346px column, and .fs-main clips), a tier with no card
|
||||
* and no scroll having nowhere to put the overflow. */
|
||||
.table.fs-dt:not(.fs-stacked) .td { overflow-wrap: break-word; }
|
||||
/* …and the ONE column the fitter decided may be shredded rather than card the whole table. Written
|
||||
* by fs-select.js on the cells of a single column, stripped before every measurement. (0,5,0) — it
|
||||
* beats the floor above on specificity, not on source order. */
|
||||
.table.fs-dt:not(.fs-stacked) .td.fs-td-break { overflow-wrap: anywhere; }
|
||||
|
||||
/* ---- and the one flag, because the view writes its shredding inline ----
|
||||
*
|
||||
* `luci-mod-status`'s processes.js emits `E('span', {'style': 'word-break: break-word'}, …)`.
|
||||
* `word-break: break-word` is the deprecated alias defined as "`word-break: normal` plus
|
||||
* `overflow-wrap: anywhere`" (css-text-3 §5.1), so it lowers the cell's min-content to a single
|
||||
* character from an INLINE declaration no cascade layer can outrank: measured at 720px, the
|
||||
* Command column sat at 126px against a widest token of 353px and forcing the column's
|
||||
* `overflow-wrap` any of three ways changed nothing, the floor being erased inside the span.
|
||||
* Neutralised, the same table asks for 963px in 688px of room, which is the truth.
|
||||
*
|
||||
* This re-times the view's intent rather than overruling it: the column may still shred, but
|
||||
* when the fitter marks it (`.fs-td-break`, one rung before carding) rather than always. Buttons
|
||||
* and inputs are excluded — base gives them `break-all` deliberately, and a control label is not
|
||||
* a value being read.
|
||||
*
|
||||
* The `!important` is the sanctioned kind: it fights an inline `style=`, the one adversary a
|
||||
* layer cannot reach.
|
||||
*
|
||||
* A CARD IS NOT EXEMPT, though `:not(.fs-stacked)` stood here. The inline alias damages the
|
||||
* MEASUREMENT, and a carded table is not measured — but it is not the only adversary. LuCI's
|
||||
* luci-mod-dashboard ships `.Dashboard … .devices-info .tr .td:first-child { word-break:
|
||||
* break-all }` in view/dashboard/css/custom.css with no layer around it, and `break-all` splits a
|
||||
* token that would have fitted: measured at 390px, `t3e-syp.home.iot` over six lines and the
|
||||
* caption `HOSTNAME` cut as `HOSTNA`/`ME`. A card's own breaking is unchanged — `.td` below keeps
|
||||
* `overflow-wrap: anywhere`, so a token too long for the line still breaks. */
|
||||
.table.fs-dt .td,
|
||||
.table.fs-dt .td :not(button):not(.btn):not(input):not(select):not(textarea) {
|
||||
word-break: normal !important;
|
||||
}
|
||||
|
||||
/* Whether a table cards, breaks one column or scrolls is MEASURED (fs-select.js), at any width. */
|
||||
|
||||
/* ---- the header row stays while the rows go past ----
|
||||
*
|
||||
* Processes renders 114 rows and Connections a few hundred: past the first screenful the column
|
||||
* headings are gone and every value is an unlabelled string of digits. The card view solves that
|
||||
* by printing the heading above each value; a table that FITS had no equivalent.
|
||||
*
|
||||
* On the CELLS, not the row: `position: sticky` needs a box with a background, and in the
|
||||
* separated border model a row's background does not travel with a sticky cell — the heading
|
||||
* would float over the rows with the values showing through. So each `.th` sticks and carries
|
||||
* the header's own fill.
|
||||
*
|
||||
* What it sticks TO depends on which box scrolls. In the vertical sidebar `.fs-main` is its own
|
||||
* scroller and nothing overlaps its top edge, so the offset is 0. In the bar layouts the
|
||||
* DOCUMENT scrolls under a sticky bar whose height is not `--fs-bar-h` — it grows when the brand
|
||||
* wraps, when the menu takes a row or when the cluster does, all decided by measurement — so
|
||||
* fs-chrome.js publishes `--fs-bar-live` and this reads it, with the designed height as the
|
||||
* fallback for the frame before the chrome has been fitted.
|
||||
*
|
||||
* And a dialog is neither, which is why every one of these selectors names its root. The roots
|
||||
* ride in `:where()` so they cost nothing: spelled out they weigh (1,9,0) against the (1,7,0)
|
||||
* ceiling tools/css-metrics.mjs enforces, while the cell rule that has to win is (0,6,0). */
|
||||
:where(:root[data-layout="sidebar"]:not([data-narrow]) #view, #modal_overlay)
|
||||
.table.fs-dt:not(.fs-stacked) .tr.table-titles .th {
|
||||
position: sticky; top: 0; z-index: 1;
|
||||
background: var(--fs-panel2);
|
||||
}
|
||||
:where(:root[data-layout="top"] #view, :root[data-narrow] #view)
|
||||
.table.fs-dt:not(.fs-stacked) .tr.table-titles .th {
|
||||
position: sticky; top: var(--fs-bar-live, var(--fs-bar-h)); z-index: 1;
|
||||
background: var(--fs-panel2);
|
||||
}
|
||||
|
||||
/* ---- a measurement must not throw the reader ----
|
||||
*
|
||||
* `fitTables()` decides a data table's tier by taking its marks OFF and asking the engine
|
||||
* (fs-fit rule 1), and the reading forces layout, so for that pass the document really is laid
|
||||
* out with a table several screens taller than the one on screen.
|
||||
*
|
||||
* Scroll anchoring turns that into a visible bug: the browser keeps the node under the reader
|
||||
* still by adjusting the offset, and re-picks that node whenever the offset changes for any
|
||||
* other reason — which, while the user scrolls, is every frame. The pick can land inside a table
|
||||
* in the un-stacked state the fitter is about to undo, and the next frame the engine faithfully
|
||||
* corrects the offset by the difference. Measured on the Overview at 390x844 with the poll
|
||||
* driving real re-renders: 18 movements nobody asked for in 1500 frames, the worst 1877px,
|
||||
* always a pair.
|
||||
*
|
||||
* So the tables the fitter re-stamps are declared ineligible as anchors — and only they, because
|
||||
* every other node staying eligible is what keeps the good half of anchoring working. NOT on the
|
||||
* scroll container, which is the answer that suggests itself and is worse: with
|
||||
* `html, body, #maincontent { overflow-anchor: none }` the same run still moved 12 times, up to
|
||||
* 788px, having thrown that compensation away as well. */
|
||||
.table.fs-dt { overflow-anchor: none; }
|
||||
|
||||
.cbi-section .table:is([id], .fs-dt) .tr:not(.table-titles):not(.placeholder):hover .td { background: var(--fs-panel2); }
|
||||
.cbi-section .table:is([id], .fs-dt) .tr.table-titles .th { border-bottom-color: var(--fs-border); }
|
||||
/* Contour around the whole data table. A real <table> needs border-collapse:separate or the
|
||||
* radius is silently dropped. Scoped to #view too: Startup renders a .table.fs-dt in a bare
|
||||
* #view wrapper with no section, and drew frameless under a section-scoped selector. */
|
||||
.cbi-section .table[id], #view .table[id],
|
||||
.cbi-section .table.fs-dt, .cbi-section table.fs-dt, table.fs-dt {
|
||||
border-collapse: separate; border-spacing: 0;
|
||||
border: var(--fs-hairline); border-radius: var(--fs-radius-lg);
|
||||
/* EXPLICIT, not an omission: the generic `.table` rule below still says `overflow: hidden`
|
||||
* — which clipped the last column of a wide table — and not repeating it here does not
|
||||
* stop it applying, which is what kept the bug alive. The corner cells (below) round the
|
||||
* frame instead, and long values wrap so the table shrinks to fit. */
|
||||
overflow: visible;
|
||||
}
|
||||
/* The frame is overflow:visible, so nothing clips the square corner cells to its radius and
|
||||
* they poked past it. Round the four OUTER cells — the frame's corners, not a per-row pill.
|
||||
* `#view .table[id]` is listed because the frame rule draws the border there too.
|
||||
*
|
||||
* `:is(.tr.table-titles, .thead)` because a header is any of the shapes fs-select.js adopts:
|
||||
* `.tr.table-titles` is the bare-th-row markup, `.thead` covers a real `<thead>` whether it
|
||||
* holds its `<th>`s directly (E()-built, no `<tr>`) or through one — adoptMarkup() never adds
|
||||
* `.tr` to that inner row, so a class-only selector has to reach the `.th` by descent, not by
|
||||
* child. Without `.thead` the header kept its square top corners under any real `<thead>`: the
|
||||
* DHCP and Wi-Fi dashboard tables measured a first/last `.th` radius of 0 against the frame's
|
||||
* 12px. */
|
||||
.cbi-section .table[id] :is(.tr.table-titles, .thead) .th:first-child,
|
||||
#view .table[id] :is(.tr.table-titles, .thead) .th:first-child,
|
||||
table.fs-dt :is(.tr.table-titles, .thead) .th:first-child { border-top-left-radius: var(--fs-radius-lg); }
|
||||
.cbi-section .table[id] :is(.tr.table-titles, .thead) .th:last-child,
|
||||
#view .table[id] :is(.tr.table-titles, .thead) .th:last-child,
|
||||
table.fs-dt :is(.tr.table-titles, .thead) .th:last-child { border-top-right-radius: var(--fs-radius-lg); }
|
||||
.cbi-section .table[id] .tr:last-child .td:first-child,
|
||||
#view .table[id] .tr:last-child .td:first-child,
|
||||
table.fs-dt .tr:last-child .td:first-child { border-bottom-left-radius: var(--fs-radius-lg); }
|
||||
.cbi-section .table[id] .tr:last-child .td:last-child,
|
||||
#view .table[id] .tr:last-child .td:last-child,
|
||||
table.fs-dt .tr:last-child .td:last-child { border-bottom-right-radius: var(--fs-radius-lg); }
|
||||
/* Empty table: L.ui.Table adds a single-cell .tr.placeholder. Spanning it across the table is
|
||||
* base's job (base/40-tables.css); what is left here is the FRAMED table's own flavour — the
|
||||
* plate reads as prose, left-aligned like the rows it stands in for, and carries the frame's
|
||||
* bottom corners so the rounding does not cut across it. */
|
||||
.cbi-section .table[id] .tr.placeholder .td,
|
||||
#view .table[id] .tr.placeholder .td,
|
||||
table.fs-dt .tr.placeholder .td {
|
||||
/* the framed flavour pads its cells `--fs-space-2-5` a side (above), and that shorthand is in
|
||||
* THIS layer, so it overrides base's placeholder padding and made the plate 4px taller than
|
||||
* the row reserved for it — measured on Wireless as 67px inside 63px, printing below the
|
||||
* frame's bottom border. Put base's number back for this one cell. */
|
||||
padding-block: var(--fs-space-2);
|
||||
text-align: start;
|
||||
color: var(--fs-dim); font-family: var(--fs-font-sans);
|
||||
border-radius: 0 0 var(--fs-radius-lg) var(--fs-radius-lg);
|
||||
}
|
||||
|
||||
/* --- KEY/VALUE tables: System, Memory ---
|
||||
* "no id" is not enough: form.TableSection/GridSection also render `.table.cbi-section-table`
|
||||
* with no id, where a 40%/nowrap first column starves the data columns. So exclude it and .fs-dt
|
||||
* explicitly.
|
||||
*
|
||||
* Also exclude the realtime graph legend: `[style*="table-layout"]` is the one no-id `.table`
|
||||
* LuCI hands an inline `table-layout:fixed`, where a 40% first column would only starve the
|
||||
* other five. A DDNS-style multi-column status table is not excluded and keeps the key/value
|
||||
* first column. */
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt):not(:has(.tr.table-titles)):not([style*="table-layout"]) .td:first-child {
|
||||
color: var(--fs-dim); font-weight: var(--fs-weight); width: 40%; white-space: nowrap;
|
||||
}
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt):not(:has(.tr.table-titles)):not([style*="table-layout"]) .td:last-child:not(:first-child) {
|
||||
font-family: var(--fs-font-mono); color: var(--fs-text); text-align: end;
|
||||
}
|
||||
/* Below ~560px of container width the 40%/nowrap column above starves the value: measured on
|
||||
* System -> System at 390px content width, Firmware Version wrapped onto 5 lines and Kernel
|
||||
* Version/Architecture onto 2 each, most of the 130px label column sitting empty. Stack it like
|
||||
* the other card idioms in this file — label as an eyebrow above its value — instead of holding
|
||||
* a fixed-fraction column at any width. A width win, not a height one: measured on the gallery's
|
||||
* key/value specimen (a 340px .cbi-map, docs/gallery.html), stacking cost the card +44.9% height
|
||||
* (202.6 -> 293.5px) for the value column widening x1.67 (183.6 -> 306px) and Firmware Version's
|
||||
* line count dropping from two to one. (The five lines above are the live 390px page, where the
|
||||
* value is longer than the specimen carries — the shape is the same, the count is not.)
|
||||
*
|
||||
* 560 is the second threshold named on fs-content; the config table's card (theme/65-dropdown.css)
|
||||
* is the first, at 960, for a row full of widgets that bake in a layout width. This one holds two
|
||||
* plain text cells, so it can stay two-column down to a narrower width before the label needs the
|
||||
* row to itself.
|
||||
*
|
||||
* `:first-child:first-child` / `:last-child:last-child` double the tail pseudo-class to outrank
|
||||
* the two rules above at identical specificity otherwise — the `.hidden.hidden` idiom
|
||||
* (theme/60-inputs.css) — rather than win on source order, which the next edit to either rule
|
||||
* could invert.
|
||||
*
|
||||
* The value's right-flush alignment above is a two-column device: with the label gone from the
|
||||
* row, right-flushing floats the value away from its own caption. Left-aligned instead, so the
|
||||
* card reads top-to-bottom as caption then value, matching every other stacked cell in this file. */
|
||||
@container fs-content (max-width: 560px) {
|
||||
/* Stacked, the row's own `.td, .th` rule above (line 97) still spends a FULL cell padding
|
||||
* on each half of the pair — 10px top + 10px bottom on the caption, the same on the value,
|
||||
* plus a hairline under EACH — 40px of padding-block and two dividers for one caption/value
|
||||
* pair, so the gap inside a pair (caption to its own value) equalled the gap between pairs
|
||||
* and the pair read as two rows, not one. Same fix as the meter row's
|
||||
* (pages/20-overview.css): move the rhythm off the CELLS onto the ROW. `--fs-space-1 0
|
||||
* --fs-space-1-5` — 4px + 6px, a quarter of the 40px it replaces — is the pair's own outer
|
||||
* padding, and the hairline moves with it so a stack outside the Overview page (which zeroes
|
||||
* it separately) draws ONE divider per pair instead of one under the caption as well. With
|
||||
* the cells at `padding: 0`, caption and value sit flush against each other — nothing between
|
||||
* them but line-height — and the record boundary is the one line the reader can see. */
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt):not(:has(.tr.table-titles)):not([style*="table-layout"]) .tr {
|
||||
display: block;
|
||||
padding: var(--fs-space-1) 0 var(--fs-space-1-5);
|
||||
border: 0;
|
||||
border-bottom: var(--fs-hairline);
|
||||
}
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt):not(:has(.tr.table-titles)):not([style*="table-layout"]) .tr:last-child {
|
||||
border-bottom: 0;
|
||||
}
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt):not(:has(.tr.table-titles)):not([style*="table-layout"]) .td:first-child:first-child {
|
||||
display: block; width: auto; white-space: normal;
|
||||
padding: 0; border: 0;
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight);
|
||||
letter-spacing: var(--fs-eyebrow-tracking); color: var(--fs-eyebrow-color);
|
||||
text-transform: uppercase;
|
||||
}
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt):not(:has(.tr.table-titles)):not([style*="table-layout"]) .td:last-child:last-child:not(:first-child) {
|
||||
display: block; width: auto; text-align: start;
|
||||
padding: 0; border: 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* --- the realtime graph legend (status/realtime/*) ---
|
||||
* The one no-id `.table` LuCI renders with inline `table-layout:fixed;width:100%` and six cells
|
||||
* per row. `fixed` splits the row into six equal columns, so on a phone each is ~1/6 of the
|
||||
* content width and the labels overflow onto the value beside them. Stock luci-theme-bootstrap
|
||||
* folds the six cells into label/value PAIRS on a narrow screen; do the same. `display:flex` on
|
||||
* the row takes the cells out of the fixed table layout, so the inline `table-layout` no longer
|
||||
* bites. Keyed on that inline attribute so only this legend is touched. */
|
||||
@media (max-width: 767px) {
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt)[style*="table-layout"] .tr {
|
||||
display: flex; flex-wrap: wrap;
|
||||
}
|
||||
.cbi-section .table:not([id]):not(.cbi-section-table):not(.fs-dt)[style*="table-layout"] .td {
|
||||
flex: 1 1 50%; min-width: 0; width: auto;
|
||||
}
|
||||
}
|
||||
|
||||
/* remove double card when a section nests a table-only include */
|
||||
.cbi-section .cbi-section { border: 0; box-shadow: none; padding: 0; margin: 0; background: transparent; }
|
||||
|
||||
/* generic links/labels inside cards */
|
||||
.cbi-section .ifacebox, .cbi-section .zonebadge { border-radius: var(--fs-radius); }
|
||||
/* moved from base with the generic field box (same layer arithmetic as the cell rules above) */
|
||||
.zonebadge input { width: 6em; }
|
||||
/* The device/MAC badge inside the Network status box kept base's flat 4px, reading as square
|
||||
* against the card's --fs-radius corners (issue #5.4). Scoped to the status box: the small
|
||||
* firewall zone .ifacebadge chips want to stay tight. Follows the Rounding axis via the token. */
|
||||
.network-status-table .ifacebox-body .ifacebadge { border-radius: var(--fs-radius); }
|
||||
/* …and the head has to round WITH the box: it sits inside the box's 1px border and carries the
|
||||
* zone colour as an inline background, so its own corners are what you see, and a 3px head
|
||||
* inside a 10px box cuts straight through the rounding with the zone colour spilling past the
|
||||
* corner (issue #7). Minus the 1px border it is inset by; max() because the Rounding axis goes
|
||||
* down to 0, where a bare subtraction is negative — an invalid declaration, silently dropped. */
|
||||
.cbi-section .ifacebox > .ifacebox-head {
|
||||
--fs-head-radius: max(0px, calc(var(--fs-radius) - 1px));
|
||||
border-radius: var(--fs-head-radius) var(--fs-head-radius) 0 0;
|
||||
}
|
||||
|
||||
/* Inactive tab panes. Base's [data-tab-title] rule sets height:0/overflow:hidden, collapsing only
|
||||
* the CONTENT box — padding, border and margin still draw empty bars, and a pane left in flow
|
||||
* inflates scrollHeight (Interfaces scrolled ~585px past the footer, Network -> DNS another
|
||||
* ~750px). Zeroing the box does both jobs, and hiding the pane with `display: none` on top of
|
||||
* that buys nothing (Interfaces scrollHeight 1039 either way).
|
||||
*
|
||||
* It is `visibility`, not `display: none`, because a display:none pane has no width and a view
|
||||
* is entitled to measure one: stock channel_analysis.js builds its channel axis from
|
||||
* `graph.offsetWidth` once, in a rAF, so a pane that starts inactive reads 0 and the 5GHz graph
|
||||
* stays a collapsed blob for the life of the page. `visibility: hidden` keeps the pane laid out
|
||||
* at full width while still taking it out of the a11y tree and the tab order, and
|
||||
* height:0 + overflow:hidden keep it out of the scroll.
|
||||
*
|
||||
* `position: relative` is what makes that overflow hold: an absolutely positioned descendant is
|
||||
* clipped only by an overflow ancestor in its own containing-block chain, and a collapsed pane of
|
||||
* ordinary markup has none — the theme supplies them itself, the toggle switch parking its real
|
||||
* checkbox at `position: absolute` (theme/60-inputs.css). Measured: DHCP and DNS scrolled 1841px
|
||||
* against 1110px of content on 24.10 and 1925 vs 1439 on 25.12, i.e. ~500-700px of empty page
|
||||
* under the footer (issue #10).
|
||||
*
|
||||
* Hence any [data-tab-title], not just .cbi-section ones. */
|
||||
[data-tab-title]:not([data-tab-active="true"]) {
|
||||
visibility: hidden;
|
||||
position: relative;
|
||||
height: 0;
|
||||
overflow: hidden;
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
border: 0;
|
||||
}
|
||||
/* 6%, not 12%. The list inside is bold --fs-danger on a tint OF --fs-danger, so the tint
|
||||
* eats its own contrast: 12% measured 4.4:1 (axe-core). At 6% every palette clears 4.5
|
||||
* (4.87 / 4.95 / 5.28 / 6.09) and the box still reads red. */
|
||||
.cbi-section-error { border-color: var(--fs-danger); background: color-mix(in srgb, var(--fs-danger) 6%, var(--fs-panel)); color: var(--fs-text); }
|
||||
.cbi-section-error ul li { color: var(--fs-danger); }
|
||||
|
||||
/* denser data tables (dhcp static leases, section-tables) */
|
||||
.cbi-section-table .th, .cbi-section-table .td,
|
||||
/* The `::before` is the GridSection name CELL on 24.10, where form.js renders none and base
|
||||
* generates the column from `data-title` (base/95-luci.css). It is not a `.th`/`.td`, so every
|
||||
* cell rule below has to name it too, or the column it draws lines up with nothing. Listing
|
||||
* `.tr::before` unqualified is safe: base names exactly the rows that get one, and a
|
||||
* pseudo-element whose content is `none` generates no box. */
|
||||
.table.cbi-section-table .th, .table.cbi-section-table .td,
|
||||
.table.cbi-section-table .tr::before { padding: var(--fs-space-2) var(--fs-space-3) var(--fs-space-2) 0; }
|
||||
/* The zero padding-left above is right only INSIDE a card, where the .cbi-section supplies that
|
||||
* gutter itself. Outside one it is wrong — Status -> Firewall renders `.table.cbi-section-table`
|
||||
* in a bare <div>, so the table draws its own frame and the header text ends up glued to that
|
||||
* frame's rounded corner (issue #7). A table carrying its own frame pads its own cells. */
|
||||
.table.cbi-section-table:not(.cbi-section *):not(.cbi-section-node *) .th,
|
||||
.table.cbi-section-table:not(.cbi-section *):not(.cbi-section-node *) .td { padding: var(--fs-space-2-5) var(--fs-space-3); }
|
||||
.cbi-section-table .tr.cbi-section-table-titles .th,
|
||||
.cbi-section-table .tr.table-titles .th { font-size: var(--fs-type-xs); letter-spacing: var(--fs-eyebrow-tracking); line-height: 1.25; }
|
||||
|
||||
/* Standalone data tables (Startup, Processes, Routes) -> rounded card. Inside a CBI section
|
||||
* the section already IS the card, so the frame is stripped there (above): no double border. */
|
||||
.table {
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
overflow: hidden;
|
||||
background: var(--fs-panel);
|
||||
}
|
||||
/* Separators go on the CELLS, not on the rows, and that is not a preference: the frame above needs
|
||||
* `border-collapse: separate` (a collapsed table silently drops the radius), and in the separated
|
||||
* model a row's border is not painted at all — on the .tr these rules paint nothing, and what
|
||||
* draws the lines is base's per-cell `border-top`, which also runs along the table's top edge
|
||||
* across the frame's rounded corners (issue #7). base no longer sets it, and the lines are
|
||||
* declared here, where they paint. Remove one and the other is not a fallback.
|
||||
*
|
||||
* `:not(:last-child)` lives IN the body-row selector: a trailing bottom border draws a straight
|
||||
* line the full width and pokes past the frame's rounded bottom corners. */
|
||||
.table .tr.table-titles > .th,
|
||||
.table .tr.cbi-section-table-titles > .th,
|
||||
.table .tr.cbi-section-table-titles::before { border-bottom: var(--fs-hairline); }
|
||||
.table .tr:not(.table-titles):not(.cbi-section-table-titles):not(:last-child) > .td,
|
||||
.table .tr.cbi-section-table-row:not(:last-child)::before { border-bottom: var(--fs-hairline); }
|
||||
/* Because the separator above is a per-CELL border, an app that nudges one cell with
|
||||
* `position: relative; top: …` (luci-mod-dashboard's `.devices-info .td:nth-child(3)`) drags
|
||||
* that cell's border-bottom out of line with its row neighbours — a step, not a slanted line,
|
||||
* since each cell paints its own hairline. Bootstrap never shows this because its rows are
|
||||
* `border-collapse: collapse`, with no per-cell border to displace. The app's rule lands in the
|
||||
* same fenced `theme` layer (fs-sheets.js), so an ID root outranks its 7 classes on specificity
|
||||
* alone and needs no `!important`; `top` AND `bottom`, not just `top: 0`, so this also cancels
|
||||
* a `bottom` offset and leaves `position: relative` itself untouched for any
|
||||
* absolutely-positioned descendant. `top`/`bottom`, not the `inset-block` shorthand: the sheet
|
||||
* has never used a logical inset property before and `css-floor` has no support decision for
|
||||
* one, where the physical pair is already on the floor. Measured: offset .td top -3px -> 0, its
|
||||
* border-bottom back level with its neighbours'. */
|
||||
:is(#view, #modal_overlay) .fs-dt .td { top: auto; bottom: auto; }
|
||||
/* descendant combinator (not >) so a real <table>'s browser-inserted <tbody> is covered
|
||||
* too — one rule themes every data table, div- or table-based. */
|
||||
.table .tr.table-titles, .table .tr.cbi-section-table-titles {
|
||||
background: transparent; /* drop the base panel2 header bar — match the dashboard's faint-label + underline look */
|
||||
}
|
||||
.table .tr.table-titles .th, .table .tr.cbi-section-table-titles .th,
|
||||
.table .tr.cbi-section-table-titles::before {
|
||||
color: var(--fs-eyebrow-color); font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight);
|
||||
letter-spacing: var(--fs-eyebrow-tracking);
|
||||
background: transparent;
|
||||
}
|
||||
/* The row's NAME, which must read the same on both releases: 25.12 renders a real
|
||||
* `.td.cbi-section-table-titles`, 24.10 base's `::before`. Both are a LABEL, not a value, so
|
||||
* both take the UI face — the surrounding value cells are mono, and base makes this one bold, so
|
||||
* with no 700 mono face shipped every rule name is drawn in synthetic bold mono, smearing the
|
||||
* grid on the one string in the row that is a name. Specificity (0,3,0), not source order, is
|
||||
* what beats the (0,1,0) mono rule. */
|
||||
.table.cbi-section-table .td.cbi-section-table-titles,
|
||||
.table.cbi-section-table .tr.cbi-section-table-row::before {
|
||||
font-family: var(--fs-font-sans); font-weight: var(--fs-weight-bold); color: var(--fs-text);
|
||||
}
|
||||
.table .tr:not(.table-titles):not(.cbi-section-table-titles) {
|
||||
transition: background var(--fs-dur);
|
||||
}
|
||||
/* Row hover ONLY on real data/config tables. A plain layout `.table` — Diagnostics is one
|
||||
* <tr> of input+button spanning the whole card, with no header row, so fs-select never tags
|
||||
* it .fs-dt — lit the ENTIRE block on hover (issue #5.3), and a data table's placeholder row
|
||||
* ("no active leases") lit up too (issue #5.2, plus :not(.placeholder) above). Data tables
|
||||
* hover per-cell above; config tables (.cbi-section-table, never .fs-dt) hover data rows here. */
|
||||
/* :not(.placeholder) — a config table's "This section contains no values yet" row carries
|
||||
* .cbi-section-table-row too, so it lit up under the pointer exactly as the data tables' did
|
||||
* before the rule above excluded theirs (issue #15: reported on UPnP, but every empty
|
||||
* GridSection had it — firewall's NAT rules, IP sets, static routes). A hover cue promises a
|
||||
* row you can act on; there is no row. */
|
||||
.table.cbi-section-table .tr.cbi-section-table-row:not(.placeholder):hover { background: var(--fs-panel2); }
|
||||
/* keep section/modal tables flush (no forced hover-card look) */
|
||||
.cbi-section .table > .tr, .cbi-modal .table > .tr { border-radius: 0; }
|
||||
|
||||
/* .fs-dt is set by fs-select.js on a #view .table that has a header row and is NOT a
|
||||
* .cbi-section-table — replacing a live `:has(.tr.table-titles):not(.cbi-section-table)`
|
||||
* the style engine re-evaluated on every mutation of these polled tables (processes,
|
||||
* routes, leases). */
|
||||
|
||||
/* ---- the card stack: one copy, every data table, no @container threshold ----
|
||||
*
|
||||
* Three @container thresholds meant two copies of these declarations, CSS being unable to share
|
||||
* a block across thresholds — 55 duplicated declarations, free to drift. All three really asked
|
||||
* "does it OVERFLOW?", which the browser can compute: fs-select.js measures it and sets
|
||||
* .fs-stacked, so every table finds its own width, a third-party app's included. Only the
|
||||
* judgement a measurement cannot make survives, in fs-select.js: "too cramped to be a table".
|
||||
*
|
||||
* A config table (.cbi-section-table) is deliberately not here and keeps its @container
|
||||
* (theme/65-dropdown.css): its rows hold widgets that bake in a width from the layout they were
|
||||
* rendered in, so un-collapsing one to read it CHANGES what is read — the firewall zone table
|
||||
* then claimed 1747px where it needs 1190px. Do not "finish the job" by measuring it.
|
||||
*
|
||||
* Shape = stock LuCI's phone layout: label ABOVE its value, cell = half the row. Label:value on
|
||||
* one line with the value right-flushed costs a leases row 7 full-width lines and gives the
|
||||
* value ~40% of the width; half-width pairs fold it into 4. Values stay left-aligned.
|
||||
*
|
||||
* ONE CONTRACT — do not split it again. The stack is MEASURED and fires at ANY width, while
|
||||
* `display: block` and the `.hide-xs`/`.hide-sm` drops once lived only inside
|
||||
* `@media (max-width: 767px)` (theme/90-responsive.css). The window between the two is real: the
|
||||
* sidebar layout's content column is (viewport - 224 - 56), so from ~768 to 860px it is already
|
||||
* below CRAMPED while that query is off. Measured at 790/820/850px, status_leases stacked with
|
||||
* `display: table` still in force and wifi_assoclist_table rendered all five of its .hide-xs
|
||||
* cells; at 760px both were correct. So they key off the CLASS. */
|
||||
/* ---- a table nobody has answered for yet takes no room ----
|
||||
*
|
||||
* A poll tick REPLACES these tables, and a fresh one carries no marks: for the moment between
|
||||
* landing and being stamped it is laid out as a full-width table, several screens taller than
|
||||
* the card stack it is about to be. The engine re-anchors on that intermediate and throws the
|
||||
* reader 612px out and back, twice per tick. fs-select.js answers in a MutationObserver
|
||||
* microtask, i.e. before paint — but only if nothing forces layout in between, and an app that
|
||||
* reads a width right after rendering does exactly that.
|
||||
*
|
||||
* So the table waits outside the layout until it has an answer. `display: none`, not
|
||||
* `visibility: hidden`, because a hidden box still occupies its height.
|
||||
*
|
||||
* Guarded on the fitters being alive: `:root[data-fs-fit]` is written by fs-fit.js and by
|
||||
* nothing else, so a document where that file never ran shows every table exactly as before this
|
||||
* rule existed. A stylesheet that can hide content on its own is one that can hide it
|
||||
* forever. */
|
||||
:root[data-fs-fit] #view .table.fs-dt:not(.fs-fitted),
|
||||
:root[data-fs-fit] #modal_overlay .table.fs-dt:not(.fs-fitted) { display: none; }
|
||||
|
||||
.table.fs-stacked { display: block; width: 100%; }
|
||||
/* `.fs-drop-xs` is the same drop one rung earlier: fs-select.js writes it on a table that has
|
||||
* overflowed, before it decides to card, because the view author has already said which columns
|
||||
* are expendable and a table with two fewer columns often fits. Same declaration, so the two
|
||||
* selectors share the block, and the class is what makes the drop a MEASURED decision rather
|
||||
* than a viewport guess (theme/90-responsive.css keeps that copy for tables that never card). */
|
||||
.table.fs-stacked .td.hide-sm, .table.fs-stacked .th.hide-sm,
|
||||
.table.fs-stacked .td.hide-xs, .table.fs-stacked .th.hide-xs,
|
||||
.table.fs-drop-xs .td.hide-sm, .table.fs-drop-xs .th.hide-sm,
|
||||
.table.fs-drop-xs .td.hide-xs, .table.fs-drop-xs .th.hide-xs { display: none; }
|
||||
|
||||
.table.fs-stacked .tr.table-titles,
|
||||
.table.fs-stacked .thead,
|
||||
.table.fs-stacked .tr.cbi-section-table-titles,
|
||||
.table.fs-stacked .tr.cbi-section-table-descr { display: none; }
|
||||
/* align-items: stretch (the default), NOT flex-start: the cells carry a per-cell
|
||||
* border-bottom, so when one cell of a pair wraps (a 2-line hostname beside a 1-line MAC)
|
||||
* a flex-start neighbour stays short and its separator paints 52px higher — a broken line
|
||||
* mid-card (measured). Stretched, both cells take the flex line's height and the
|
||||
* separators meet; content still sits at the top (the cells are blocks). */
|
||||
/* A `<tfoot>` with no `.tr` inside it IS the row — see the footer block below for which view
|
||||
* writes which shape.
|
||||
*
|
||||
* TWO rules, not one list: a selector list is not forgiving, so a browser without `:has()`
|
||||
* (Firefox before 121) throws away the WHOLE list, and `.table.fs-stacked .tr` — every card on
|
||||
* every stacked table — loses `display: flex` with it. Split, the `:has()` half degrades alone.
|
||||
* The duplicated body is under `css-dup`'s three-declaration floor, so it will not be flagged;
|
||||
* the two must change together. */
|
||||
.table.fs-stacked .tr { display: flex; flex-wrap: wrap; }
|
||||
.table.fs-stacked tfoot:not(:has(> .tr)),
|
||||
.table.fs-stacked .tfoot:not(:has(> .tr)) { display: flex; flex-wrap: wrap; }
|
||||
.table.fs-stacked .td {
|
||||
display: block; min-width: 0; width: auto;
|
||||
padding-block: var(--fs-space-1-5); padding-inline: 0 var(--fs-space-2-5); border: 0; text-align: start;
|
||||
overflow-wrap: anywhere; white-space: normal;
|
||||
}
|
||||
/* The column label, lifted above its value (LuCI writes it per cell as data-title).
|
||||
*
|
||||
* Pinned: the config table (theme/65-dropdown.css) needs these exact declarations under its
|
||||
* @container guard, and CSS cannot share a block between a class and a container query — the two
|
||||
* guards do not OR. tools/mirror.mjs keeps the copies byte-identical; edit one and the build
|
||||
* fails until you edit the other, a duplicate detector going quiet once two copies differ. */
|
||||
.table.fs-stacked .td[data-title]::before {
|
||||
/* @mirror table-card/label */
|
||||
content: attr(data-title); display: block; margin-bottom: var(--fs-space-1);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight); letter-spacing: var(--fs-eyebrow-tracking);
|
||||
color: var(--fs-eyebrow-color);
|
||||
/* @endmirror */
|
||||
}
|
||||
/* A footer cell is the fourth member here, and it has to carry `[data-title]` in its own selector
|
||||
* to win: `.table.fs-stacked tfoot .td::before` is (0,3,1) against the caption rule's (0,4,0) and
|
||||
* loses wherever it is written. Measured on the wifi footer with the titles stamped: `content`
|
||||
* computed to "SSID" over `Total:`. With the attribute it is (0,4,1) and (0,5,0). */
|
||||
.table.fs-stacked .td.cbi-section-actions::before,
|
||||
.table.fs-stacked .td:not([data-title])::before,
|
||||
.table.fs-stacked .td[data-title=""]::before,
|
||||
.table.fs-stacked tfoot .td[data-title]::before,
|
||||
.table.fs-stacked .tfoot .td[data-title]::before { content: none; }
|
||||
/* The row's buttons are not a label/value pair — full width below the pairs.
|
||||
* PINNED with the config table's copy — see above. */
|
||||
.table.fs-stacked .td.cbi-section-actions {
|
||||
/* @mirror table-card/actions */
|
||||
display: flex; flex: 1 1 100%; justify-content: flex-start;
|
||||
flex-wrap: wrap; gap: var(--fs-space-2); padding-top: var(--fs-space-2);
|
||||
/* @endmirror */
|
||||
}
|
||||
/* LuCI groups a row's buttons in ONE inner <div> (startup.js wraps all five), so the td's own
|
||||
* flex-wrap above never fires — the div is a single flex item, and .fs-main's overflow-x:clip
|
||||
* CUT the tail button (Startup at 390px, measured: the div needs 350px in a 324px cell and
|
||||
* "Stop" vanished). Same trap the config table hit on the interfaces row; PINNED to its copy
|
||||
* in theme/65-dropdown.css. */
|
||||
.table.fs-stacked .td.cbi-section-actions > * {
|
||||
/* @mirror table-card/actions-inner */
|
||||
flex: 1 1 auto; display: flex; flex-wrap: wrap; gap: var(--fs-space-2);
|
||||
/* @endmirror */
|
||||
}
|
||||
/* Nothing in a half-width cell may force the row wider than the viewport: .fs-main is
|
||||
* overflow-x:clip, so an over-wide child is CUT, not scrolled to. */
|
||||
.table.fs-stacked .td > *,
|
||||
.table.fs-stacked .td .ifacebadge { min-width: 0; max-width: 100%; }
|
||||
|
||||
/* ---- the footer, in both shapes upstream writes it ----
|
||||
*
|
||||
* A `<tfoot>` is still a table-footer-group inside a `display: block` table, so in a card it drew
|
||||
* as a box beside the cards: measured at 390px on the station list, 186px wide against 354.
|
||||
* `20_lan.js` builds `tfoot > tr > td` and needs only the footer out of the way, the `.tr` above
|
||||
* already being a flex row; `30_wifi.js` appends the `<td>`s to the `<tfoot>` through E(), where
|
||||
* no parser runs and no row is implied, so there the footer has to become the row — that arm is
|
||||
* up with the `.tr` rule. `:has(> .tr)` tells them apart.
|
||||
*
|
||||
* An empty footer cell goes entirely: a card is a list of facts and an empty cell is not one. The
|
||||
* captions are suppressed up in the `content: none` group, for the specificity reason stated
|
||||
* there. */
|
||||
.table.fs-stacked tfoot:has(> .tr),
|
||||
.table.fs-stacked .tfoot:has(> .tr) { display: block; }
|
||||
.table.fs-stacked tfoot .td:empty,
|
||||
.table.fs-stacked .tfoot .td:empty { display: none; }
|
||||
|
||||
/* --- the DATA table's flavour (L.ui.Table, tagged .fs-dt) ---
|
||||
* Clip rows to the frame's corners: zebra paints its background on the .tr and the frame is
|
||||
* overflow:visible, so a striped row's square background pokes past the corners. Safe once
|
||||
* stacked — a flex-wrap row fits the width, so there is no horizontal column left to clip, which
|
||||
* is the only thing overflow:visible protected. `#view .table.fs-dt.fs-stacked` (1,3,0) outranks
|
||||
* the frame's `#view .table[id]` (1,2,0) on specificity, not on order.
|
||||
*
|
||||
* `#modal_overlay` as well, because the FRAME already reaches a dialog and this clip did not: a
|
||||
* data table inside a dialog's `.cbi-section` takes the frame from `.cbi-section .table[id]`
|
||||
* above and has the same corners with the same zebra painted square across them. */
|
||||
#view .table.fs-dt.fs-stacked,
|
||||
#modal_overlay .table.fs-dt.fs-stacked { overflow: hidden; }
|
||||
/* `:not(.placeholder)` — the plate is out of flow (base/40-tables.css) and its row exists only to
|
||||
* reserve the height it needs. Padding is subtracted from that reservation (border-box), so the
|
||||
* card's row inset left 41px of the 63px the plate is: measured on Wireless as 10px of text
|
||||
* hanging below the frame once the table stacked. A row with no rows in it has nothing to inset. */
|
||||
.table.fs-dt.fs-stacked .tr:not(.placeholder) { padding: var(--fs-space-2-5) var(--fs-space-4) var(--fs-space-3); }
|
||||
/* ---- the pair width, and the adversary specificity cannot reach ----
|
||||
*
|
||||
* Half the row is what makes the card a card. It was `.fs-stacked .td` at (0,2,0), deliberately
|
||||
* low so the unguarded `.table .td.col-N` below, at (0,3,0), could beat it on specificity rather
|
||||
* than source order — which holds against every rule in a LAYER and none outside one.
|
||||
* luci-mod-dashboard ships `@media (max-width: 640px) { .Dashboard … .tr .td { flex: 2 2 10% } }`
|
||||
* unlayered, and that beats every layered rule at any specificity: measured at 390px, four cells
|
||||
* of a station row at 81px on one line, `flex-basis` computing to 10% — the pairs never formed.
|
||||
*
|
||||
* Hence the flag, the sanctioned kind. Spent narrowly, and by SELECTOR because a flag would
|
||||
* outrank these two families as well: `.cbi-section-actions` is a full-width line of buttons,
|
||||
* `[class*="col-"]` is the view author's own weight. The third `:not()` is not one of those — it
|
||||
* is how this rule loses to the meter below, both being flagged: without it (0,5,0) beats (0,4,0)
|
||||
* and the meter silently keeps half a line. */
|
||||
.table.fs-stacked .td:not(.cbi-section-actions):not([class*="col-"]):not(:has(.cbi-progressbar)) {
|
||||
flex: 1 1 50% !important;
|
||||
}
|
||||
/* A meter takes the whole line: `.cbi-progressbar::after` prints the bar's title above its right
|
||||
* edge (25-progressbar.css), which in a card is where the cell's own caption sits — measured at
|
||||
* 390px, `SIGNAL STRENGTH` and `RSSI: 65% (-57dBm)` drawn over each other. Beside the bar instead
|
||||
* would be paid out of the bar, too short at half a row to read as one. */
|
||||
.table.fs-stacked .td:has(.cbi-progressbar) { flex: 1 1 100% !important; }
|
||||
|
||||
/* ---- column weights: one unguarded block, unguarded on purpose ----
|
||||
* A weight (1-10) is a share of a CARDED row — the JS says which cell is a narrow badge and
|
||||
* which the wide status text; without it every cell falls back to the flat 50% above.
|
||||
*
|
||||
* Do not copy them under a guard. `flex` applies only to a FLEX ITEM, and a `.td` becomes one
|
||||
* exactly when its `.tr` turns into a flex container — by either mechanism (`.fs-stacked`,
|
||||
* measured at any width, or the config table's @container, which can card on a 1200px desktop).
|
||||
* Anywhere else they are inert, so one copy serves all three tiers. Basis N*30px, as in stock,
|
||||
* so the weights compose the same way. */
|
||||
.table .td.col-1, .table .th.col-1 { flex: 1 1 30px; }
|
||||
.table .td.col-2, .table .th.col-2 { flex: 2 2 60px; }
|
||||
.table .td.col-3, .table .th.col-3 { flex: 3 3 90px; }
|
||||
.table .td.col-4, .table .th.col-4 { flex: 4 4 120px; }
|
||||
.table .td.col-5, .table .th.col-5 { flex: 5 5 150px; }
|
||||
.table .td.col-6, .table .th.col-6 { flex: 6 6 180px; }
|
||||
.table .td.col-7, .table .th.col-7 { flex: 7 7 210px; }
|
||||
.table .td.col-8, .table .th.col-8 { flex: 8 8 240px; }
|
||||
.table .td.col-9, .table .th.col-9 { flex: 9 9 270px; }
|
||||
.table .td.col-10, .table .th.col-10 { flex: 10 10 300px; }
|
||||
|
||||
/* general table cell padding — compact but readable (Startup/Processes/etc) */
|
||||
.table .td { padding-top: var(--fs-space-2); padding-bottom: var(--fs-space-2); }
|
||||
|
||||
/* ---- the last resort: a foreign <table> the card stack cannot claim ----
|
||||
*
|
||||
* fs-select.js tags any `#view table` that HAS a header row as `.table.fs-dt`, so it is measured
|
||||
* and cards like every other data table. What is left here is the table with no header at all: a
|
||||
* log, a statistics matrix, a layout table. Those must not be carded even if they overflow — a
|
||||
* card prints `data-title` above each value, and a matrix has no titles to print, so stacking one
|
||||
* produces a column of numbers with nothing saying what they are. Comparison is the point of
|
||||
* that shape; it scrolls instead.
|
||||
*
|
||||
* `display: block` plus `overflow-x: auto` on the table ITSELF, not on a wrapper: the theme
|
||||
* cannot add markup around someone else's element, and the block box is what gives it a scroll
|
||||
* container. The rows still lay out as a table, a `display: block` <table> wrapping its children
|
||||
* in an anonymous table box.
|
||||
*
|
||||
* Unguarded by a media query, because the viewport was never the fact that mattered: a narrow
|
||||
* panel or a split window overflows at any width, and a phone report is only where it was
|
||||
* noticed first.
|
||||
*
|
||||
* A dialog is the worst place to leave it out, hence the `#modal_overlay` half of the selector:
|
||||
* the overlay is the scroll container (base/60-modal.css) and the dialog is centred in it with
|
||||
* `margin: auto`, so an over-wide child scrolls the dialog's own edge off the screen instead of
|
||||
* scrolling itself. Measured at 390px with a four-column `nowrap` log table: in #view it scrolls
|
||||
* inside itself (358px shown of 636px, page scroll 0); in a dialog it rendered 636px wide in
|
||||
* 317px of room and gave the overlay 282px of horizontal scroll. */
|
||||
/* `.fs-xscroll` is the same outcome reached the other way: fs-select.js writes it on a `.table`
|
||||
* with no header row that has been measured to overflow — the shape a bare `<table>` selector
|
||||
* cannot reach, a third-party app being free to render its log as `<div class="table">`. A class
|
||||
* rather than a selector, and measured rather than declared, for a spec-level reason:
|
||||
* `overflow-x: auto` forces `overflow-y` to compute to `auto` too (css-overflow-3 §3.1), so a
|
||||
* table given this becomes a clip for every popup inside it, and ui.js then walks up from an open
|
||||
* dropdown, finds the TABLE as the scroll parent and sizes the list against it. The fitter
|
||||
* refuses the class to any table holding a widget, so this rule needs no `:has()` ladder. */
|
||||
#view table:not(.table):not(.cbi-section-table):not(.fs-dt),
|
||||
#modal_overlay table:not(.table):not(.cbi-section-table):not(.fs-dt),
|
||||
#view .table.fs-xscroll, #modal_overlay .table.fs-xscroll {
|
||||
display: block;
|
||||
max-width: 100%;
|
||||
overflow-x: auto;
|
||||
/* the scroll gesture stops at this table instead of dragging the page sideways */
|
||||
overscroll-behavior-x: contain;
|
||||
/* the scrollbar IS the affordance here. A gradient "there is more to the right" shadow is the
|
||||
* usual trick and does not work on these tables: it has to paint on the scroll container,
|
||||
* behind rows that carry their own zebra fill, so it shows through every second row only. */
|
||||
scrollbar-width: thin;
|
||||
}
|
||||
|
||||
/* ---- a table of controls stacks: it is a form laid out as a table ----
|
||||
*
|
||||
* Written by fs-select.js on a header-less table that overflows and holds a control. Scrolling
|
||||
* one is not an option — the popup inside would be clipped by the scroll container it just
|
||||
* became — and doing nothing leaves it cut: at 320px of room the row needed 338 and the button
|
||||
* was past `.fs-main`'s clip with no way to reach it.
|
||||
*
|
||||
* `display: block` on all three levels, the one place this theme wants it: the rows are a form,
|
||||
* so there is nothing to compare across them and nothing to keep in columns. Each control takes
|
||||
* the width of its line and the table cannot exceed its parent by construction. Nothing here
|
||||
* creates a scroll container, so an open dropdown still escapes. */
|
||||
.table.fs-rowstack,
|
||||
.table.fs-rowstack .tr,
|
||||
.table.fs-rowstack .td,
|
||||
.table.fs-rowstack .th { display: block; width: auto; }
|
||||
/* the cells were table-cells a moment ago and carried its side padding; as blocks they need the
|
||||
* vertical rhythm instead, or the controls sit flush against each other */
|
||||
.table.fs-rowstack .td { padding-inline: 0; padding-block: var(--fs-space-1); }
|
||||
|
||||
/* ---- what makes a scrolled table readable: the row keeps its name ----
|
||||
*
|
||||
* Scrolling a table sideways takes the identity column away first, leaving a screenful of values
|
||||
* belonging to nothing. Pinning the first cell of every row is the one thing a card view gives
|
||||
* for free and a scrolled table does not.
|
||||
*
|
||||
* The cells need their own background (a row's does not travel with a sticky cell in the
|
||||
* separated model, as for the header above) and a hairline on the inline end, so the pinned
|
||||
* column reads as an edge rather than as text sliding over text. `z-index: 2` keeps it over the
|
||||
* sticky header's `1` where the two cross, at the corner cell. */
|
||||
#view .table.fs-xscroll .tr > :first-child,
|
||||
#modal_overlay .table.fs-xscroll .tr > :first-child,
|
||||
#view .table.fs-xscroll tr > :first-child,
|
||||
#modal_overlay .table.fs-xscroll tr > :first-child {
|
||||
position: sticky; left: 0; z-index: 2;
|
||||
background: var(--fs-panel);
|
||||
border-inline-end: var(--fs-hairline);
|
||||
}
|
||||
/* a keyboard user reaches the scroll box by tabbing to it (fs-select.js gives it tabindex and a
|
||||
* name); it has to show that it has focus — outline, not box-shadow, so forced-colors keeps it */
|
||||
#view .table.fs-xscroll:focus-visible,
|
||||
#modal_overlay .table.fs-xscroll:focus-visible {
|
||||
outline: 2px solid var(--fs-accent);
|
||||
outline-offset: 2px;
|
||||
}
|
||||
}
|
||||
@@ -1,219 +0,0 @@
|
||||
@layer theme {
|
||||
/* Alert panel: a left accent stripe on a panel card; the type variants recolour the frame.
|
||||
* `background: var(--fs-panel)` used to be repeated per variant to out-specify base's
|
||||
* gradients — a layer does that for free (theme beats base whatever the specificity), so
|
||||
* one rule does it. */
|
||||
.alert-message {
|
||||
padding: var(--fs-space-3-5) var(--fs-space-4);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
border: var(--fs-hairline);
|
||||
/* logical: the stripe marks the READING start of the alert, so it swaps sides with the
|
||||
* document (LuCI ships ar/fa/he catalogues) — physical, it sat on the far edge in RTL. */
|
||||
border-inline-start: 3px solid var(--fs-accent);
|
||||
/* The surface is OPAQUE and the status tint rides on top of it. A variant that replaces the
|
||||
* background with `var(--fs-*-fill)` paints an 18% wash with nothing behind it — invisible on
|
||||
* a flat canvas, and transparent to the wallpaper under Appearance -> Wallpaper, where the
|
||||
* tile reads straight through every status alert.
|
||||
*
|
||||
* So --fs-panel stays the background-COLOUR for every variant and the tint is a
|
||||
* background-IMAGE layer over it. The named `-fill` step is unchanged, so an untinted router
|
||||
* sees the same pixels, and the local `--fs-alert-tint` is what keeps this one rule instead
|
||||
* of six `background:` overrides that each have to re-state the panel. */
|
||||
background-color: var(--fs-panel);
|
||||
background-image: linear-gradient(var(--fs-alert-tint, transparent), var(--fs-alert-tint, transparent));
|
||||
color: var(--fs-text);
|
||||
gap: var(--fs-space-3);
|
||||
}
|
||||
/* ---- status lives in the stripe and the surface; the ring is always neutral ----
|
||||
*
|
||||
* Split between `border-color` (all four sides, including the 3px stripe) and
|
||||
* `border-left-color` (the stripe alone), four of seven alerts wear a coloured ring and three a
|
||||
* grey one — a hierarchy nobody designed, with the difference between "not applied yet" and
|
||||
* "this is about to fail" hanging on one pixel of frame.
|
||||
*
|
||||
* The surface carries it instead, at the ladder's named `-fill` step, which
|
||||
* docs/design-system.md describes as the callout surface — exactly what an alert is. Not a fresh
|
||||
* `color-mix()`: an unnamed level is how four spellings of one tint appeared here before.
|
||||
*
|
||||
* `:not(.btn)` is load-bearing: `admin/system/flash` renders its confirm control as
|
||||
* `<label class="btn alert-message danger">`, a BUTTON wearing the alert classes, and without
|
||||
* the guard the tint out-ranks `.btn.danger` on source order: the "Force upgrade" control faded
|
||||
* from its danger fill (rgb(234,122,116)) to a pale wash. */
|
||||
.alert-message.warning:not(.btn) {
|
||||
border-color: var(--fs-border); border-inline-start-color: var(--fs-warn);
|
||||
--fs-alert-tint: var(--fs-warn-fill);
|
||||
}
|
||||
.alert-message.error:not(.btn), .alert-message.danger:not(.btn) {
|
||||
border-color: var(--fs-border); border-inline-start-color: var(--fs-danger);
|
||||
--fs-alert-tint: var(--fs-danger-fill);
|
||||
}
|
||||
.alert-message.success:not(.btn) {
|
||||
border-inline-start-color: var(--fs-good);
|
||||
--fs-alert-tint: var(--fs-good-fill);
|
||||
}
|
||||
/* `.info` is a STATUS and tints like the others; a bare .alert-message stays a flat panel, because
|
||||
* a note is not a status.
|
||||
*
|
||||
* `.notice` is grouped HERE rather than with .success, where it is pixel-identical — same fill,
|
||||
* same rail, no other channel — so one status word carries two meanings while the theme's own
|
||||
* `.label.notice` is accent and `.cbi-tooltip.notice` neutral. What settles the direction is
|
||||
* what LuCI means by it: ui.js emits `notice spinning` for the "applying configuration changes"
|
||||
* banner, i.e. IN PROGRESS rather than done, and stock luci-theme-bootstrap keeps green for
|
||||
* success alone. Informational, so accent. */
|
||||
.alert-message.info:not(.btn), .alert-message.notice:not(.btn) {
|
||||
border-inline-start-color: var(--fs-accent);
|
||||
--fs-alert-tint: var(--fs-accent-fill);
|
||||
}
|
||||
|
||||
/* ---- a spinning alert is a glyph and a message, side by side ----
|
||||
*
|
||||
* The spinner is a `::before` on the element carrying `.spinning` (base/95-luci.css), and it is
|
||||
* `inline-block` so that it sits in the flow of the button labels and `em.spinning` texts that
|
||||
* usually host it. This host is neither: `ui.changes.displayStatus()` builds the apply dialog as
|
||||
* a BLOCK box whose content is a BLOCK element, so the glyph opens a line box of its own and the
|
||||
* message goes underneath it.
|
||||
*
|
||||
* Grid rather than flex, because the caller decides how many children there are and flex would
|
||||
* lay a second one out beside the first: `displayStatus()` passes one `<p>` today but builds two
|
||||
* elements for its non-spinning states, and `addNotification()` takes `spinning` from anyone.
|
||||
* Two columns — glyph, then everything else. Measured over the three shapes a caller can
|
||||
* produce: the content started 24.6 / 20.6 / 19.5px BELOW the glyph's line and now starts on it.
|
||||
*
|
||||
* The notification variant is deliberately untouched: ui.js writes `style="display:flex"` on the
|
||||
* element itself, and an inline style beats a layered rule, so those keep their own flex row. */
|
||||
.alert-message.spinning {
|
||||
display: grid;
|
||||
grid-template-columns: auto 1fr;
|
||||
/* centres the glyph against the FIRST row rather than pinning it to that row's top */
|
||||
align-items: center;
|
||||
/* `.alert-message`'s own `gap` above is the row gap between stacked children; the column gap
|
||||
* is the glyph's own spacing and is the smaller step, so it is stated rather than inherited
|
||||
* from that shorthand. */
|
||||
column-gap: var(--fs-space-2);
|
||||
}
|
||||
/* the glyph is a grid item now, so its inline margin would double the column gap; and it is
|
||||
* pinned to row 1 so that it stays beside the FIRST child however many follow */
|
||||
.alert-message.spinning::before { grid-row: 1; margin-inline-end: 0; }
|
||||
.alert-message.spinning > * { grid-column: 2; }
|
||||
|
||||
/* h2 is what the theme's own notices emit (the document had no heading above h4 at all); h4 is
|
||||
* here because a third-party alert may use it, and coverage only grows. h5/h6 joined for the
|
||||
* same reason — base styled them and the theme did not, so an alert heading looked like an
|
||||
* alert heading down to h4 and then fell back to base's. */
|
||||
.alert-message :is(h2, h3, h4, h5, h6) { margin: 0 0 var(--fs-space-1); font-size: var(--fs-type-lg); font-weight: var(--fs-weight-bold); color: var(--fs-text); }
|
||||
/* the alert's own content reset — moved from base with the heading ramp (45-misc.css): its
|
||||
* `line-height: inherit` beat the ramp's tight leading in-layer, and left behind it would
|
||||
* lose to the ramp by layer (measured: alert headings dropped 21 -> 16.8px) */
|
||||
.alert-message h4,
|
||||
.alert-message h5,
|
||||
.alert-message pre,
|
||||
.alert-message ul,
|
||||
.alert-message li,
|
||||
.alert-message p {
|
||||
border: none;
|
||||
line-height: inherit;
|
||||
background: transparent;
|
||||
padding: 0;
|
||||
}
|
||||
/* --fs-text, not --fs-dim: the paragraph IS the message. The line below already gives every
|
||||
* ul/ol/li/pre inside an alert full-strength ink, so a two-sentence alert had its first
|
||||
* sentence muted and its bullet list not — and on the tinted surface above, dim is the value
|
||||
* that measured 4.06:1 when the Reset button had it (55-buttons.css). */
|
||||
.alert-message p { margin: var(--fs-space-1) 0; color: var(--fs-text); font-size: var(--fs-type); }
|
||||
/* …and the body elements an alert may carry. Absorbed from base/90-widgets.css, same values:
|
||||
* the theme had claimed only <p> out of that rule's six selectors. */
|
||||
.alert-message :is(ul, ol, li, pre) { color: var(--fs-text); margin: .25em 0; }
|
||||
/* inner table (firmware Current/Available) — flatten so it does not read as a nested card
|
||||
* on the alert panel; subtle row dividers only */
|
||||
.alert-message .table { margin: var(--fs-space-2-5) 0; background: transparent; border: 0; box-shadow: none; border-radius: 0; }
|
||||
/* --fs-text, not --fs-eyebrow-color: everywhere else an eyebrow sits on --fs-panel, but here the
|
||||
* surface is a status tint, and the muted ink does not survive it — measured on the firmware
|
||||
* table over the warning fill, hicontrast/light: 3.35-3.36:1 against AA's 4.5. The eyebrow still
|
||||
* reads as one from its tracking and size; only the ink changes. */
|
||||
.alert-message .table .th,
|
||||
/* The title-row selectors are not decoration: `.table .tr.table-titles .th` in 30-tables.css is
|
||||
* FOUR classes (0,4,0) and out-ranks the plain one above (0,3,0), so without these the header
|
||||
* kept the eyebrow ink no matter what this rule said — being later in the sheet buys nothing
|
||||
* against a heavier selector, which is the point of the "never win on source order" rule. */
|
||||
.alert-message .table .tr.table-titles .th,
|
||||
.alert-message .table .tr.cbi-section-table-titles .th { color: var(--fs-text); font-weight: var(--fs-eyebrow-weight); font-size: var(--fs-type-xs); letter-spacing: var(--fs-eyebrow-tracking); }
|
||||
/* the column gap is --fs-space-3 like every other cell in the theme; --fs-space-3-5 here was the
|
||||
* only 14px cell gap in the sheet, and nothing above defends it — the comment covers flattening
|
||||
* the frame, not the rhythm. (The row density stays --fs-space-2: a table inside an alert is a
|
||||
* dense readout, same as the config tables that state it deliberately.) */
|
||||
.alert-message .table .th, .alert-message .table .td { padding: var(--fs-space-2) var(--fs-space-3) var(--fs-space-2) 0; background: transparent; border-color: color-mix(in srgb, var(--fs-border) 60%, transparent); }
|
||||
.alert-message .table .td { color: var(--fs-text); }
|
||||
|
||||
/* The validation tooltip (ui.js pops it on a .cbi-tooltip-container). Its colour words were the
|
||||
* one status surface the theme never claimed, and nothing could see it: the gallery rendered a
|
||||
* plain `.cbi-tooltip` only, and an un-rendered widget shows no diff, which reads as "already
|
||||
* dead". The gallery renders all four now.
|
||||
*
|
||||
* The fill stays SOLID, unlike `.label` below: a tooltip floats over arbitrary content, so a
|
||||
* border carrying the status would have to read against whatever happens to be behind it. The
|
||||
* ink is the role's own `--fs-on-*`, which 03-palettes.css sizes per palette and per mode — a
|
||||
* global white failed AA on seven of the eight dark-palette fills. */
|
||||
/* One elevation for the widget. base lit it with a raw 2px halo in the hairline colour, which
|
||||
* measures 1.08-1.86:1 against the surfaces a tooltip lands on, while the theme overrode the
|
||||
* single instance somebody happened to look at. A tooltip floats over ARBITRARY content — the
|
||||
* same reason the colour variants below stay opaque — so it is the last surface that should be
|
||||
* separated from the page by a hairline. */
|
||||
.cbi-tooltip { box-shadow: var(--fs-shadow-pop); }
|
||||
/* base reveals it on :hover alone. The container is `cursor: help` and carries no tabindex in
|
||||
* anything LuCI ships, so nothing can focus it today and this matches nothing — but the
|
||||
* focusability belongs to ui.js, and a third-party app that gives its own tooltip container a
|
||||
* tabindex gets a keyboard-reachable tooltip the day it does. */
|
||||
.cbi-tooltip-container:focus-within .cbi-tooltip:not(:empty) { inset-inline-start: auto; opacity: 1; }
|
||||
.cbi-tooltip.info { background: var(--fs-accent); border-color: var(--fs-accent); color: var(--fs-on-accent); }
|
||||
.cbi-tooltip.success { background: var(--fs-good); border-color: var(--fs-good); color: var(--fs-on-good); }
|
||||
.cbi-tooltip.error { background: var(--fs-danger); border-color: var(--fs-danger); color: var(--fs-on-danger); }
|
||||
.cbi-tooltip.notice { background: var(--fs-panel2); border-color: var(--fs-border); color: var(--fs-text); }
|
||||
|
||||
/* The `.label` pill. LuCI core barely uses it, but any luci-app-* may reach for it, so the
|
||||
* theme owns it in tokens (base's copy is absorbed). `.important` is the conventional name
|
||||
* for what we call accent; `.danger` has no counterpart there and is added because
|
||||
* packages use it. See docs/gallery.html. */
|
||||
.label {
|
||||
display: inline-block; padding: var(--fs-space-1) var(--fs-space-2); border-radius: var(--fs-radius-pill);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-weight); line-height: 1.4;
|
||||
background: var(--fs-panel2); border: var(--fs-hairline);
|
||||
color: var(--fs-dim); text-shadow: none; text-transform: none;
|
||||
/* carried over from the absorbed styles/base .label rule */
|
||||
white-space: nowrap; margin: .125em 0 .125em .4em;
|
||||
}
|
||||
/* The variants set no background, deliberately: they inherit the opaque --fs-panel2 from `.label`
|
||||
* above. A translucent tint of their own colour under text of that colour drags the background
|
||||
* toward the text and eats the contrast it needs, and being translucent it renders differently
|
||||
* on every surface, so no single percentage is safe — measured across palette x mode, every
|
||||
* variant landed at 3.4-4.4:1. On --fs-panel2 the palette guarantees >=4.5 by construction, and
|
||||
* the coloured border carries the status just as loudly. */
|
||||
.label.important, .label.notice { border-color: var(--fs-accent); color: var(--fs-accent); }
|
||||
.label.warning { border-color: var(--fs-warn); color: var(--fs-warn); }
|
||||
.label.success { border-color: var(--fs-good); color: var(--fs-good); }
|
||||
.label.danger, .label.error { border-color: var(--fs-danger); color: var(--fs-danger); }
|
||||
a.label:link, a.label:visited { color: var(--fs-dim); }
|
||||
a.label:hover { text-decoration: none; color: var(--fs-text); }
|
||||
|
||||
/* The show/hide toggles in a section title are .label pills too, but clickable. SINGLE
|
||||
* owner of the pill look: pages/20-overview.css used to restate it (page layer, unscoped —
|
||||
* so it silently won everywhere) with drifted values; these are the ones that were actually
|
||||
* rendering. The trailing overrides (text-transform … box-shadow) kill the uppercase /
|
||||
* margin / min-width / badge decorations base used to put on these pills. */
|
||||
.cbi-title .label {
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-weight);
|
||||
padding: var(--fs-space-1) var(--fs-space-3); border-radius: var(--fs-radius-pill);
|
||||
background: var(--fs-panel2); border: var(--fs-hairline);
|
||||
color: var(--fs-dim); cursor: pointer; line-height: 1.4;
|
||||
text-transform: none; letter-spacing: 0;
|
||||
margin: 0; min-width: 0; box-shadow: none;
|
||||
}
|
||||
.cbi-title .label:hover { color: var(--fs-text); border-color: var(--fs-dim); opacity: 1; }
|
||||
/* These pills toggle section visibility — interactive, so keyboard focus must show. */
|
||||
.cbi-title .label:focus-visible {
|
||||
outline: none; border-color: var(--fs-accent); box-shadow: var(--fs-focus-ring);
|
||||
}
|
||||
/* Surface stays OPAQUE (--fs-panel2 inherited from the base pill): accent text on
|
||||
* --fs-accent-soft is the accent-on-its-own-tint AA failure measured at 4.21:1 in the open
|
||||
* dropdown (theme/65-dropdown.css) — the border carries the accent instead. */
|
||||
.cbi-title .label.notice { opacity: 1; color: var(--fs-accent); border-color: var(--fs-accent); }
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
@layer theme {
|
||||
/* ---- tab strips: one component, four entry points ----
|
||||
* LuCI emits a strip under four selectors with no markup difference worth honouring:
|
||||
* #tabmenu ul.tabs page tabs, rendered into the server shell
|
||||
* ul.cbi-tabmenu.mode mode switcher (Available / Installed / Updates)
|
||||
* .tabs view tabs (Routing -> IPv4 / IPv6)
|
||||
* .cbi-tabmenu CBI form tabs (System -> General / Logging / …)
|
||||
* They agree on everything except the active marker: `.active` for `ul.tabs`, `.cbi-tab` for
|
||||
* every `.cbi-tabmenu` flavour. All four render as pills in a card. */
|
||||
#tabmenu { margin-bottom: 0; }
|
||||
|
||||
/* the card */
|
||||
#tabmenu ul.tabs,
|
||||
ul.cbi-tabmenu.mode,
|
||||
.tabs,
|
||||
.cbi-tabmenu {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: var(--fs-space-1);
|
||||
list-style: none;
|
||||
margin: 0 0 var(--fs-card-gap);
|
||||
padding: var(--fs-space-2);
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
/* kills a folder-tab baseline gradient (the 1px x 29px background image the strip
|
||||
* conventionally carries) by zeroing its size rather than restating it — base's copy is
|
||||
* absorbed, but any gradient a view or third-party app sets is sized away too */
|
||||
background-size: 0 0;
|
||||
}
|
||||
|
||||
/* a strip nested inside a .cbi-section card -> soft inset row, no frame (a card inside a
|
||||
* card reads as a bug) */
|
||||
.cbi-section .tabs,
|
||||
.cbi-section .cbi-tabmenu:not(.mode):not(.map) {
|
||||
background: var(--fs-panel2);
|
||||
padding: var(--fs-space-1-5);
|
||||
box-shadow: none;
|
||||
}
|
||||
|
||||
#tabmenu ul.tabs > li,
|
||||
ul.cbi-tabmenu.mode > li,
|
||||
.tabs > li,
|
||||
.cbi-tabmenu > li {
|
||||
height: auto;
|
||||
margin: 0; padding: 0;
|
||||
border: 0; background: none;
|
||||
border-radius: var(--fs-radius);
|
||||
color: var(--fs-dim);
|
||||
}
|
||||
|
||||
/* the theme's own page tabs and the mode switcher never carry a sentence-length label, so
|
||||
* `none` is right for them — `ul.cbi-tabmenu.mode > li` below wins specificity over the plain
|
||||
* `.cbi-tabmenu > li` rule that follows, so the mode pills stay `none` regardless of order. */
|
||||
#tabmenu ul.tabs > li,
|
||||
ul.cbi-tabmenu.mode > li,
|
||||
.tabs > li {
|
||||
max-width: none;
|
||||
}
|
||||
|
||||
/* the PLAIN CBI form tabs (ui.js, not the mode switcher): adblock's Overview page names one
|
||||
* "Настройки межсетевого экрана", measured 293px in a 264px column at 320px/Large — 28.6px past
|
||||
* it, section clipped by 30px; EN measured 0. The `a` already carries `white-space: nowrap;
|
||||
* overflow: hidden; text-overflow: ellipsis` (base/50-chrome.css) — it never engaged because the
|
||||
* li's `max-width: none` left its automatic minimum size at the label's full content width, so
|
||||
* flexbox never shrank it. `100%` is smaller than that content width once the column is, which
|
||||
* is exactly the case that broke; everywhere the tab already fits, this is a no-op. */
|
||||
.cbi-tabmenu > li {
|
||||
max-width: 100%;
|
||||
}
|
||||
|
||||
#tabmenu ul.tabs > li > a,
|
||||
ul.cbi-tabmenu.mode > li > a,
|
||||
.tabs > li > a,
|
||||
.cbi-tabmenu > li > a {
|
||||
display: block;
|
||||
margin: 0;
|
||||
padding: var(--fs-space-2) var(--fs-space-3-5);
|
||||
border: 0;
|
||||
border-radius: var(--fs-radius);
|
||||
line-height: 1.3;
|
||||
font-size: var(--fs-type);
|
||||
font-weight: var(--fs-weight);
|
||||
color: var(--fs-dim);
|
||||
transition: background var(--fs-dur), color var(--fs-dur);
|
||||
}
|
||||
|
||||
#tabmenu ul.tabs > li > a:hover,
|
||||
ul.cbi-tabmenu.mode > li > a:hover,
|
||||
.tabs > li > a:hover,
|
||||
.cbi-tabmenu > li > a:hover {
|
||||
background: var(--fs-accent-soft);
|
||||
color: var(--fs-text);
|
||||
}
|
||||
|
||||
/* active pill */
|
||||
#tabmenu ul.tabs > li.active,
|
||||
ul.cbi-tabmenu.mode > li.cbi-tab,
|
||||
.tabs > li.active,
|
||||
.cbi-tabmenu > li.cbi-tab {
|
||||
color: var(--fs-on-accent);
|
||||
}
|
||||
#tabmenu ul.tabs > li.active > a,
|
||||
ul.cbi-tabmenu.mode > li.cbi-tab > a,
|
||||
.tabs > li.active > a,
|
||||
.cbi-tabmenu > li.cbi-tab > a {
|
||||
background: var(--fs-accent);
|
||||
color: var(--fs-on-accent);
|
||||
font-weight: var(--fs-weight-bold);
|
||||
}
|
||||
|
||||
/* ---- keyboard focus: a ring that survives the ACTIVE pill ----
|
||||
*
|
||||
* base/50-chrome.css drew it as `outline: 2px solid var(--fs-accent)` inset by -2px, which is
|
||||
* invisible on exactly the tab most likely to be focused, the active pill's own background being
|
||||
* that same accent (measured on the router: both rgb(86,157,245)).
|
||||
*
|
||||
* One rule for both states, on --fs-focus-ring-solo: a tab flips nothing else on focus, so the
|
||||
* ring IS the indicator, and the tinted --fs-focus-ring measures 1.15-1.29:1 against the strip —
|
||||
* the first version of this fix took that tint for the inactive pill and swapped one invisible
|
||||
* indicator for another.
|
||||
* -solo's 2px surface gap is also what lets one value serve the active pill. box-shadow, not
|
||||
* outline, because the strip clips and a shadow is not clipped by the scroll container. */
|
||||
#tabmenu ul.tabs > li > a:focus-visible,
|
||||
ul.cbi-tabmenu.mode > li > a:focus-visible,
|
||||
.tabs > li > a:focus-visible,
|
||||
.cbi-tabmenu > li > a:focus-visible {
|
||||
outline: none;
|
||||
box-shadow: var(--fs-focus-ring-solo);
|
||||
}
|
||||
|
||||
/* Density steps for a crowded strip: fs-chrome.js (fitTabStrips) MEASURES whether the tabs
|
||||
* wrap to a second row and escalates .fs-dense1 -> .fs-dense2, mutually exclusive (dense1 is
|
||||
* removed the moment dense2 is added, so a pill is never trimmed by both at once). Both steps
|
||||
* give the pill the SAME padding (--fs-space-1 --fs-space-2) and, where the rule sets it at
|
||||
* all, the SAME font-size (--fs-type) — dense1 does not touch font-size, dense2 restates it;
|
||||
* neither actually shrinks it further, since --fs-type is already the strip's own base size.
|
||||
* Only the strip's own `gap` is touched by a dense rule, and only at d2; past that floor the
|
||||
* strip may wrap. The id in the first selector matches the #tabmenu rule's specificity. */
|
||||
#tabmenu ul.tabs.fs-dense1 > li > a,
|
||||
.tabs.fs-dense1 > li > a,
|
||||
.cbi-tabmenu.fs-dense1 > li > a { padding: var(--fs-space-1) var(--fs-space-2); }
|
||||
|
||||
#tabmenu ul.tabs.fs-dense2,
|
||||
.tabs.fs-dense2,
|
||||
.cbi-tabmenu.fs-dense2 { gap: var(--fs-space-1); }
|
||||
#tabmenu ul.tabs.fs-dense2 > li > a,
|
||||
.tabs.fs-dense2 > li > a,
|
||||
.cbi-tabmenu.fs-dense2 > li > a { padding: var(--fs-space-1) var(--fs-space-2); font-size: var(--fs-type); }
|
||||
|
||||
/* map-level tabs keep the body font size instead of base's 16.5px/bold */
|
||||
.cbi-tabmenu.map > li { font-size: var(--fs-type); font-weight: var(--fs-weight); }
|
||||
/* the little "n errors" badge on a tab */
|
||||
.cbi-tab-disabled[data-errors]::after { background: var(--fs-danger); }
|
||||
}
|
||||
@@ -1,227 +0,0 @@
|
||||
@layer theme {
|
||||
/* The realtime graphs size their drawing from #view, not from the box they draw into:
|
||||
* `width = document.querySelector('#view').offsetWidth - 2`, in every realtime view and in the
|
||||
* luci-app-*-status copies of them. That assumption holds only in a theme whose .cbi-section has
|
||||
* no gutter; ours is a card, 16px of padding plus a 1px border, so the canvas comes out 34px
|
||||
* narrower than the drawing — and the views draw NEWEST-first from the right, so the freshest
|
||||
* samples are the ones falling off the edge. It reads as a phone bug only because the loss is
|
||||
* absolute: 34px of a 1124px desktop plot is 3%, of a 322px phone plot 10%.
|
||||
*
|
||||
* So bleed the graph box back out to the card's border edge, making the canvas exactly
|
||||
* `#view - 2` again. The bleed is padding plus border, derived from --fs-card-pad rather than
|
||||
* restated, or narrowing the gutter would silently re-clip every graph.
|
||||
*
|
||||
* The `!important` fights the inline `width: 100%` the view writes on the box: nothing in a
|
||||
* cascade layer can outrank an inline declaration. */
|
||||
#view .cbi-section > div[style]:has(> svg) {
|
||||
width: auto !important;
|
||||
margin-inline: calc(-1 * (var(--fs-card-pad) + 1px));
|
||||
}
|
||||
|
||||
/* …and the same box's frame, which the same inline style paints BLACK: every realtime view writes
|
||||
* `border:1px solid #000;background:#fff` on it. Black is a colour no palette of this theme
|
||||
* contains, so on a dark surface the graph reads as a framed cut-out, and the frame lands
|
||||
* exactly on the card's own border edge because of the bleed above (issue #32).
|
||||
*
|
||||
* Wider than the bleed rule on purpose: channel_analysis.js hangs off a bare [data-tab] div and
|
||||
* must not be bled, but its border is just as black, so this asks only "an inline-styled box
|
||||
* wrapping an <svg>".
|
||||
*
|
||||
* Only the COLOUR moves. The 1px stays, being the graph's own edge, and `background: #fff` is
|
||||
* left alone: the <svg> is sized to the box's content edge, so the white never paints. Only an
|
||||
* author `!important` outranks an inline declaration, and `border-color` alone is enough — the
|
||||
* width and style already agree with what the theme would ask for. */
|
||||
#view div[style]:has(> svg) {
|
||||
border-color: var(--fs-border) !important;
|
||||
}
|
||||
|
||||
/* WCAG 2.2 SC 1.4.1 (Use of Color, A): inside a block of text a link may not be identified
|
||||
* by COLOUR ALONE — it needs a non-colour cue or 3:1 against the surrounding text, and
|
||||
* --fs-accent on --fs-text measures 1.4:1 in dark mode. So: underline links in prose.
|
||||
* Scoped to prose deliberately — nav links, buttons, pills and table cells are identified
|
||||
* by position and shape, and underlining them would be noise. */
|
||||
p a, dd a,
|
||||
.cbi-value-description a,
|
||||
.alert-message a:not(.btn):not(.cbi-button) {
|
||||
text-decoration: underline;
|
||||
}
|
||||
|
||||
/* A <strong>/<b> is a LABEL, and a label is UI text, so it takes the UI face even on a monospaced
|
||||
* surface. LuCI builds every status readout as `<strong>MAC:</strong> ac:1f:6b:…`: the strong
|
||||
* names the datum, the text after it IS the datum. The theme puts mono on those surfaces, the
|
||||
* strong inherits it, and <strong> also means weight 700 — so the label asks for a bold mono
|
||||
* face that exists for no other reason: 227 elements across seven pages, and 20 KB of a
|
||||
* 600-weight mono face fetched to draw the word "MAC:".
|
||||
*
|
||||
* It must SET the face, not merely be excluded from the mono rule: an excluded element still
|
||||
* INHERITS its parent's. Excluding it was the first attempt and changed nothing.
|
||||
*
|
||||
* pre/code/#syslog/textarea are exempt: there a <strong> is part of the monospaced CONTENT. */
|
||||
:is(strong, b):not(pre *, code *, #syslog *, textarea *) {
|
||||
font-family: var(--fs-font-sans);
|
||||
}
|
||||
|
||||
/* Same argument, two holdouts. `.ifacebadge` is a BADGE — chrome, not a value — sitting in a mono
|
||||
* cell, and `.ifacebadge-active` makes it bold; sans keeps the active/inactive weight cue (WCAG
|
||||
* 1.4.1, that distinction not being carried by colour) with faces the page already has.
|
||||
* `<code>`/`<pre>` hold a LITERAL, which does not inherit its container's emphasis.
|
||||
*
|
||||
* The second selector is not redundant: the mono rule in theme/60-inputs.css is (0,1,0), a TIE
|
||||
* with a bare `.ifacebadge`, and a tie is settled by source order, which 60-inputs would win.
|
||||
* Win on specificity instead, at (0,2,0). */
|
||||
.ifacebadge,
|
||||
.cbi-value-field .ifacebadge { font-family: var(--fs-font-sans); }
|
||||
code, pre { font-weight: var(--fs-weight-normal); }
|
||||
|
||||
/* ---- the poll's `fade-in` is not animated at all, and that is the whole rule ----
|
||||
*
|
||||
* `fade-in` is upstream's class and luci-mod-status re-marks with it on EVERY poll tick — each
|
||||
* section, and the wrapper holding all of them — so anything this theme hangs on that class
|
||||
* replays on every tick across the entire content column.
|
||||
*
|
||||
* A fade plus a 4px slide moved the page under the reader; the fade alone still pulsed the whole
|
||||
* column on every tick, reported from an iPhone as shaking that happens WITHOUT SCROLLING AT
|
||||
* ALL, which is what named it — a poll tick is the only thing that happens on a still page.
|
||||
*
|
||||
* So the theme animates nothing on it. The class stays in the markup, being upstream's, and the
|
||||
* `fade-in` keyframes in base/95-luci.css stay for the coverage reason stated there. */
|
||||
.cbi-title-ref { color: var(--fs-accent); }
|
||||
.close { color: var(--fs-text); text-shadow: none; opacity: .6; }
|
||||
.close:hover { opacity: 1; }
|
||||
.ifacebox { background: var(--fs-panel); border-color: var(--fs-border); }
|
||||
.ifacebox .ifacebox-head { background: var(--fs-panel2); color: var(--fs-text); }
|
||||
/* The active-interface highlight lives in THIS layer, next to the head it overrides: the
|
||||
* same rule in base was dead — a layer beats specificity, and the plain `.ifacebox-head`
|
||||
* above repainted `.active` along with the rest. */
|
||||
.ifacebox .ifacebox-head.active { background: var(--fs-accent); color: var(--fs-on-accent); }
|
||||
.ifacebadge { background: var(--fs-panel2); border-color: var(--fs-border); }
|
||||
.ifacebadge-active { border-color: var(--fs-accent); }
|
||||
.zonebadge-empty { border-color: var(--fs-border); color: var(--fs-dim); }
|
||||
|
||||
/* The @container PLUMBING for the responsive tables — only WHICH boxes are query containers, under
|
||||
* what names. The card rules are not here: a CBI section table cards under `@container
|
||||
* fs-content (max-width: 992px)` (theme/65-dropdown.css — 992, not the row's own 960px floor,
|
||||
* because the query reads THIS element, one level above the `.cbi-section` that spends
|
||||
* `--fs-card-pad` before the table ever sees the width), and a data table cards by MEASUREMENT
|
||||
* (.fs-stacked, fs-select.js) at any width.
|
||||
*
|
||||
* Query the CONTENT width, not the viewport: the sidebar eats width, so a viewport breakpoint
|
||||
* stacks too late or too early depending on layout.
|
||||
*
|
||||
* Named, deliberately — an unnamed @container binds to the nearest ancestor that happens to have
|
||||
* a container-type, so giving container-type to any new component would silently re-target every
|
||||
* unnamed query underneath it:
|
||||
* fs-view the overview's grid (pages/20-overview.css, @container 800)
|
||||
* fs-content "whatever content column I am in", carried by .cbi-map, #view and .modal (below),
|
||||
* so a query resolves to the nearest of the three. */
|
||||
.cbi-map { container-type: inline-size; container-name: fs-content; }
|
||||
#view { container-type: inline-size; container-name: fs-view fs-content; }
|
||||
|
||||
/* A modal is not inside #view — ui.js appends #modal_overlay to <body> — so every @container query
|
||||
* above resolves to nothing in there and no table stacks: on a phone the Edit-interface dialog
|
||||
* rendered its form at desktop widths and cut the inputs off. Carry both names so a dialog
|
||||
* stacks exactly like the page, a third-party app's modal included. */
|
||||
.modal { container-type: inline-size; container-name: fs-view fs-content; }
|
||||
|
||||
/* pager (« prev · text · next ») — generic, not page-scoped: any .pager gets an inline
|
||||
* centred row with compact square buttons. */
|
||||
.pager.center { display: flex; flex-direction: row; flex-wrap: nowrap; align-items: center; justify-content: center; gap: var(--fs-space-2-5); padding: var(--fs-space-3-5) 0; }
|
||||
.pager .text { flex: 0 0 auto; font-size: var(--fs-type); color: var(--fs-dim); }
|
||||
|
||||
/* The heading ramp, absorbed from base wholesale (docs/css.md). Stock LuCI hands h2 to a page title
|
||||
* and h3/legend to a section title, and the heading-card rule below plus theme/30-tables.css
|
||||
* repaint exactly those two, so most of the ramp is only ever rendered by a third-party
|
||||
* luci-app-* — styled anyway, coverage being a contract. Every step is a scale token and the
|
||||
* ramp is monotonic. `legend` is deliberately not in the group: theme/30-tables.css owns it, and
|
||||
* a member here would fight that at equal specificity, i.e. on source order. */
|
||||
h1, h2, h3, h4, h5, h6 {
|
||||
font-weight: var(--fs-weight-bold);
|
||||
color: var(--fs-text);
|
||||
/* 1.5 is prose leading; a heading is a label and looks slack at it. */
|
||||
line-height: var(--fs-leading-tight);
|
||||
}
|
||||
h1 { margin-bottom: var(--fs-space-4); font-size: var(--fs-type-2xl); }
|
||||
h2 { font-size: var(--fs-type-xl); }
|
||||
h3 { font-size: var(--fs-type-lg); }
|
||||
h4 { font-size: var(--fs-type); }
|
||||
h5 { font-size: var(--fs-type); }
|
||||
h6 { font-size: var(--fs-type-xs); color: var(--fs-dim); text-transform: uppercase; }
|
||||
|
||||
/* Heading card (h2 + .cbi-map-descr): everything sitting directly on the page background
|
||||
* gets a .cbi-section card's frame, so a page reads as a stack of panels instead of loose
|
||||
* text floating over the (possibly patterned) background. */
|
||||
.cbi-map > h2,
|
||||
#view > h2 {
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
margin: 0 0 var(--fs-card-gap);
|
||||
padding: var(--fs-space-4);
|
||||
font-size: var(--fs-type-xl);
|
||||
font-weight: var(--fs-weight-bold);
|
||||
color: var(--fs-text);
|
||||
}
|
||||
/* a heading followed by a description: split the card across the two siblings (no wrapper
|
||||
* element exists to hold both) */
|
||||
.cbi-map > h2:has(+ .cbi-map-descr),
|
||||
#view > h2:has(+ .cbi-map-descr) {
|
||||
border-bottom: 0;
|
||||
border-radius: var(--fs-radius-lg) var(--fs-radius-lg) 0 0;
|
||||
padding-bottom: var(--fs-space-1);
|
||||
margin-bottom: 0;
|
||||
box-shadow: none;
|
||||
}
|
||||
.cbi-map > h2 + .cbi-map-descr,
|
||||
#view > h2 + .cbi-map-descr {
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-top: 0;
|
||||
border-radius: 0 0 var(--fs-radius-lg) var(--fs-radius-lg);
|
||||
margin: 0 0 var(--fs-card-gap);
|
||||
padding: 0 var(--fs-space-4) var(--fs-space-4);
|
||||
color: var(--fs-dim);
|
||||
font-size: var(--fs-type);
|
||||
line-height: var(--fs-leading);
|
||||
}
|
||||
|
||||
/* An action-button row (a `.right` wrapper holding Add/Save) sitting directly under a field
|
||||
* had no gap above it — the apk "Repo Public Keys -> Add key" paste box, and every other
|
||||
* paste-a-value-then-submit layout, pinned its button to the textarea. Scoped to a `.right`
|
||||
* immediately following a form control, so it never touches right-aligned text or cells. */
|
||||
#view :is(textarea, input[type="text"], input[type="password"], .cbi-dropdown) + .right {
|
||||
margin-top: var(--fs-space-2-5);
|
||||
}
|
||||
|
||||
/* A button row belonging to the PAGE TITLE rather than to any section. Nothing gives it a bottom
|
||||
* margin, so it sits flush against the first .cbi-section below and reads as part of that card
|
||||
* instead of as a page-level action; the same 16px every .cbi-section uses.
|
||||
*
|
||||
* And a top margin for the same reason at the other edge, the row sitting directly under the
|
||||
* page heading with nothing between them. Half the bottom gap, because a heading and its own
|
||||
* action belong together. */
|
||||
.cbi-title-buttons { margin-block: var(--fs-space-2) var(--fs-card-gap); }
|
||||
|
||||
/* The per-section Delete button (`.cbi-section-remove`, what luci-base renders for every NAMED
|
||||
* section: SQM's queues, the firewall's zones, any app that lets you add and drop instances) sat
|
||||
* flush against whatever follows it — usually that section's own tab bar. Reported upstream on
|
||||
* SQM, but nothing here is about SQM: it is one class luci-base gives every such section, and
|
||||
* the gap belongs to the pattern rather than to the page. */
|
||||
.cbi-section-remove { margin-bottom: var(--fs-space-2); }
|
||||
|
||||
/* A top-level block in a map that is not a section still keeps the page's rhythm.
|
||||
*
|
||||
* A view may return a bare widget where a section is expected — `s.render = () => new
|
||||
* ui.Textarea(...).render()` hands the map a plain `<div>` with no `.cbi-section` — so nothing
|
||||
* gives that block the gap every section carries and the next section starts against it. Stock
|
||||
* bootstrap measures the same 0px, but there a section is a stretch of page and here it is a
|
||||
* CARD, so the missing gap reads as two cards fused.
|
||||
*
|
||||
* Written against what a map CONTAINS rather than against one app: the exclusions are the
|
||||
* children luci-base itself puts there and which own their spacing already — the map heading and
|
||||
* its description, the action bar, a tabbed map's tab bar and pane, and sections.
|
||||
*
|
||||
* `:not(:empty)` because a map can hold a placeholder that renders nothing. */
|
||||
.cbi-map > *:not(.cbi-section):not(.cbi-map-descr):not(.cbi-page-actions):not(h2):not(legend):not(.cbi-tabmenu):not(.cbi-map-tabbed):not(:empty) {
|
||||
margin-bottom: var(--fs-card-gap);
|
||||
}
|
||||
}
|
||||
@@ -1,90 +0,0 @@
|
||||
@layer theme {
|
||||
/* ---- the top-layout bar: :root[data-layout="top"], every width ----
|
||||
*
|
||||
* A DELTA, not a layout. The bar itself — sticky, blurred, row, popup submenus, square icon
|
||||
* buttons, right cluster — is the unguarded base in 20-shell.css, the bar being what the chrome
|
||||
* IS unless the vertical sidebar overrides it. This file adds what the top-layout bar wants on
|
||||
* top of that:
|
||||
* - a designed bar height, and padding aligned to the content column;
|
||||
* - the menu on the brand's row instead of wrapped beneath it.
|
||||
*
|
||||
* No `@media` floor: "does the menu fit on the brand's row?" is a property of the CONTENT (5
|
||||
* sections stock, eleven with a few luci-app-*), not of the viewport, so the whole bar is
|
||||
* MEASURED — fs-chrome.js shrinks the pills, collapses the poll pill to an icon, then stacks the
|
||||
* menu onto its own row, at any width. The under-item dropdown and its clamp therefore apply at
|
||||
* every width too. */
|
||||
:root[data-layout="top"] .fs-sidebar {
|
||||
/* min-height, not height: the bar has a designed height but must be able to GROW —
|
||||
* a long hostname wraps onto a second line inside the capped brand (20-shell.css),
|
||||
* and a fixed height would clip it. */
|
||||
min-height: var(--fs-bar-h); height: auto;
|
||||
gap: var(--fs-space-3);
|
||||
/* nowrap while the menu rides the brand's row. Without it flexbox wraps the BAR, carrying the
|
||||
* menu onto a second line by itself while its own pills stay in one row — a stacked bar in
|
||||
* everything but the styling. It also destroys the fits-on-one-row measurement, a menu handed
|
||||
* a whole row of course fitting. Forbidding the wrap forces the menu to share the row and to
|
||||
* wrap its OWN pills when it cannot, which is the signal fitChrome measures. */
|
||||
flex-wrap: nowrap;
|
||||
/* align the bar's contents to the .fs-content column, so the brand and the menu line
|
||||
* up with the headings and the cards below */
|
||||
padding: 0 max(20px, calc((100% - var(--fs-content-max)) / 2 + var(--fs-content-pad)));
|
||||
}
|
||||
|
||||
/* the menu rides the brand's row; its flex:1 opens the gap that pushes the right-hand
|
||||
* cluster to the content column's right edge */
|
||||
:root[data-layout="top"] .fs-sidebar ul.nav {
|
||||
order: 2; flex: 1 1 auto; margin-inline-start: var(--fs-space-2);
|
||||
}
|
||||
:root[data-layout="top"] .fs-sidebar #indicators,
|
||||
:root[data-layout="top"] .fs-themerow,
|
||||
:root[data-layout="top"] .fs-logout { order: 3; margin-inline-start: 0; }
|
||||
|
||||
/* The under-item dropdown anchor, its hover bridge and the clamp are NOT here: they belong to
|
||||
* the BAR and live unguarded in 20-shell.css. They used to be this file's, and that WAS issue
|
||||
* #19 — the sidebar layout collapsed onto a bar is the same chrome, and it inherited a panel
|
||||
* pinned to the bar's left edge with no bridge, unreachable by hover. This file is the top
|
||||
* layout's delta; a rule every bar state needs is not a delta. */
|
||||
|
||||
/* the mode strip (only rendered when a router has more than one top-level mode) takes
|
||||
* its own full-width row under the bar */
|
||||
/* :not(:empty):not(.single) instead of a hide pair — the bar's base rule (20-shell.css)
|
||||
* already hides the strip; see the sidebar twin there for why the pair was folded. */
|
||||
:root[data-layout="top"] .fs-modemenu:not(:empty):not(.single) {
|
||||
display: flex; order: 4; flex: 1 1 100%; margin: 0; gap: var(--fs-space-1);
|
||||
}
|
||||
|
||||
/* the bar replaces the sidebar's 22px top padding with the top-nav's 26px */
|
||||
:root[data-layout="top"] .fs-content { padding-top: var(--fs-space-6); }
|
||||
|
||||
/* ---- the menu does not fit on the brand's row: .fs-bar-stack ----
|
||||
*
|
||||
* Set by fs-chrome.js (fitChrome), not by a media query: whether the menu fits beside the brand
|
||||
* depends on how many sections the router HAS, so the width at which the bar must stack is a
|
||||
* property of the content and a hard-coded breakpoint gets it wrong in both directions. The JS
|
||||
* shrinks the pills first, then collapses the poll pill, and stacks only when even that still
|
||||
* overflows. */
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack {
|
||||
flex-wrap: wrap; height: auto; padding: var(--fs-space-2-5) var(--fs-space-4);
|
||||
}
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack ul.nav {
|
||||
order: 3; flex: 1 1 100%; margin-inline-start: 0;
|
||||
}
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack #indicators,
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack .fs-themerow,
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack .fs-logout { order: 2; }
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack #indicators,
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack .fs-themerow { margin-inline-start: auto; }
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack #indicators:not(:empty) ~ .fs-themerow { margin-inline-start: 0; }
|
||||
/* Two .fs-themerow buttons, Search then Appearance: only the FIRST rendered far-edge item may
|
||||
* keep the auto inline-start margin, exactly as in the base bar, or flexbox splits the free
|
||||
* space between the two autos and Search drifts to mid-bar. The base `.fs-themerow ~
|
||||
* .fs-themerow` guard is out-specified by the auto rule above (0,4,0 against 0,2,0), so it must
|
||||
* be restated here. Bites when #indicators is :empty — right after an SPA nav, before
|
||||
* the poll pill returns. */
|
||||
:root[data-layout="top"] .fs-sidebar.fs-bar-stack .fs-themerow ~ .fs-themerow { margin-inline-start: 0; }
|
||||
|
||||
/* The right cluster's own escalation — .fs-ind-compact and .fs-bar-actrow — is NOT here: it
|
||||
* belongs to the BAR, and the sidebar layout is a bar too once fitShell has stamped
|
||||
* data-narrow. Both live with the bar in 20-shell.css; this file is only the top layout's
|
||||
* delta, and the menu's .fs-bar-stack above is the part that really is top-only. */
|
||||
}
|
||||
@@ -1,341 +0,0 @@
|
||||
@layer theme {
|
||||
/* Buttons placed straight in a field, not in a .control-group (app action rows
|
||||
* Enable/Disable, Start/Restart/Stop): inline-block buttons only get whitespace spacing
|
||||
* horizontally, so on wrap the rows collapsed together. Wrapping flex with a real gap. */
|
||||
.cbi-value-field:has(> .cbi-button) {
|
||||
display: inline-flex; flex-wrap: wrap; gap: var(--fs-space-2); align-items: center; justify-content: flex-end;
|
||||
}
|
||||
|
||||
/* The button. The native `input` types are in the selector list on purpose: LuCI's own views
|
||||
* always use <button class="cbi-button">, but a third-party luci-app-* may emit a bare
|
||||
* <input type="submit">, and base only gives those width/height: auto — coverage is a
|
||||
* contract (docs/gallery.html). `.btn` and `.cbi-button` are interchangeable in LuCI markup
|
||||
* (a row-action button usually carries both), so every rule here names both. */
|
||||
.cbi-button, .btn,
|
||||
input[type="button"], input[type="submit"], input[type="reset"] {
|
||||
display: inline-flex; align-items: center; justify-content: center;
|
||||
/* auto, stated: theme/60-inputs.css's generic `input` box says 210px x 32px, and a base
|
||||
* reset would lose to it by layer — a button sizes to its label */
|
||||
width: auto; height: auto;
|
||||
min-height: var(--fs-ctl-h);
|
||||
padding: var(--fs-space-2) var(--fs-space-3-5);
|
||||
font-family: var(--fs-font-sans); font-weight: var(--fs-weight); line-height: 1.1;
|
||||
color: var(--fs-text);
|
||||
background: var(--fs-panel2);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
box-shadow: none; text-shadow: none;
|
||||
/* border-COLOR, not `border`: the shorthand animates border-width too — a layout
|
||||
* animation on every hover instead of a paint one (absorbed from base with the ring) */
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* bare `button` rides along: a third-party app's unclassed <button> hovered the same border
|
||||
* cue in base's old glow rule, and border-color is a no-op on its border: 0 box — harmless
|
||||
* there, meaningful the moment the app gives it a border */
|
||||
.cbi-button:hover, .btn:hover, button:hover,
|
||||
input[type="button"]:hover, input[type="submit"]:hover, input[type="reset"]:hover { border-color: var(--fs-dim); }
|
||||
|
||||
/* Keyboard focus, not decoration: without this a button shows nothing on focus. The
|
||||
* `box-shadow: none` above kills any stray focus glow (theme beats base regardless of
|
||||
* specificity), and the UA outline only ever shows on :focus-visible, which this rule restyles.
|
||||
* A plain mouse :focus deliberately shows nothing — a glow rings every clicked button, and the
|
||||
* pressed cue below already answers the click. Same --fs-focus-ring as every field. */
|
||||
.cbi-button:focus-visible, .btn:focus-visible,
|
||||
input[type="button"]:focus-visible, input[type="submit"]:focus-visible, input[type="reset"]:focus-visible {
|
||||
outline: none;
|
||||
border-color: var(--fs-accent);
|
||||
box-shadow: var(--fs-focus-ring);
|
||||
}
|
||||
/* Solid variants sit ON --fs-accent/--fs-good/--fs-danger, so an accent-tinted ring is invisible
|
||||
* against them: ring in the surface colour with an accent halo. Written out as a literal ending
|
||||
* in --fs-accent-soft, that halo was a 10-15% tint at 1.15-1.29:1 and the only thing it painted
|
||||
* was the 2px gap; --fs-focus-ring-solo is the same geometry with a solid accent, under one
|
||||
* name. */
|
||||
.cbi-button-positive:focus-visible, .cbi-button-action:focus-visible,
|
||||
.cbi-button-negative:focus-visible, .cbi-button-remove:focus-visible,
|
||||
.cbi-button-apply:focus-visible, .cbi-button-save:focus-visible,
|
||||
.btn.primary:focus-visible, .btn.danger:focus-visible,
|
||||
.btn.error:focus-visible, .btn.success:focus-visible, .btn.info:focus-visible {
|
||||
outline: none;
|
||||
border-color: transparent;
|
||||
box-shadow: var(--fs-focus-ring-solo);
|
||||
}
|
||||
|
||||
/* Pressed state. The `box-shadow: none` above would erase any press cue, so the inset shadow
|
||||
* is declared here — the sole copy (base's identical one was absorbed). */
|
||||
.cbi-button:active, .btn:active, .btn.active,
|
||||
input[type="button"]:active, input[type="submit"]:active, input[type="reset"]:active {
|
||||
box-shadow: inset 0 2px 4px color-mix(in srgb, var(--fs-border) 40%, transparent);
|
||||
}
|
||||
|
||||
/* Solid variants — three fills, not six. `.cbi-button-*` is what LuCI's own views emit and
|
||||
* `.btn.<colour-word>` what a third-party luci-app-* tends to emit, and base paints those words
|
||||
* with gradients that are dead: the plain `.btn` rule above sets background, border and colour
|
||||
* in a later layer, so an unclaimed `.btn.danger` renders as a neutral grey button with no
|
||||
* colour cue. Coverage is a contract, so the theme claims them — in the SAME rule as their
|
||||
* .cbi-button-* twin, because written apart a recolour lands on one half and not the other. */
|
||||
.cbi-button-positive, .btn.success {
|
||||
background: var(--fs-good); border-color: transparent; color: var(--fs-on-good);
|
||||
}
|
||||
.cbi-button-action, .cbi-button-action.important, .btn.primary, .btn.info {
|
||||
background: var(--fs-accent); border-color: transparent; color: var(--fs-on-accent);
|
||||
}
|
||||
.cbi-button-negative, .cbi-button-negative.important, .cbi-button-remove,
|
||||
.btn.danger, .btn.error {
|
||||
background: var(--fs-danger); border-color: transparent; color: var(--fs-on-danger);
|
||||
}
|
||||
/* This hover must stay AHEAD of the page-action Save rule below: at equal specificity its
|
||||
* `border-color: transparent` would erase Save's outline on hover. (.cbi-button-remove is
|
||||
* deliberately absent — it never had the lift, and the row-action rules colour it their
|
||||
* own way.) */
|
||||
.cbi-button-positive:hover, .cbi-button-action:hover, .cbi-button-apply:hover,
|
||||
.cbi-button-save:hover, .cbi-button-negative:hover,
|
||||
.btn.success:hover, .btn.info:hover, .btn.danger:hover, .btn.error:hover {
|
||||
filter: var(--fs-hover-lift); border-color: transparent;
|
||||
}
|
||||
.cbi-button-reset, .cbi-button-link { background: transparent; border-color: var(--fs-border); color: var(--fs-dim); }
|
||||
|
||||
/* Size words. The `.btn` rule above re-sets padding and radius from the token scale in a
|
||||
* later layer, so a size word that carried only a font-size (as base's absorbed copy did)
|
||||
* came out with default-button padding. Theme owns .btn.large/.small in full now, geometry
|
||||
* on the radius scale rather than base's hardcoded 6px. */
|
||||
.btn.large { font-size: var(--fs-type-lg); min-height: var(--fs-ctl-h-lg); padding: var(--fs-space-2) var(--fs-space-4); border-radius: var(--fs-radius); }
|
||||
.btn.small { font-size: var(--fs-type-xs); min-height: var(--fs-ctl-h-sm); padding: var(--fs-space-1) var(--fs-space-2-5); border-radius: var(--fs-radius-sm); }
|
||||
|
||||
.cbi-section .table[id] .td .btn,
|
||||
.cbi-section .table[id] .td .cbi-button { padding: var(--fs-space-1) var(--fs-space-2-5); font-size: var(--fs-type); }
|
||||
.alert-message .btn, .alert-message .cbi-button {
|
||||
border-radius: var(--fs-radius); padding: var(--fs-space-2) var(--fs-space-3); font-weight: var(--fs-weight);
|
||||
background: var(--fs-panel2); border: var(--fs-hairline); color: var(--fs-text);
|
||||
}
|
||||
.alert-message .btn:hover { border-color: var(--fs-accent); color: var(--fs-accent); }
|
||||
|
||||
/* Page action bar (.cbi-page-actions) — the Save/Apply footer. base renders a tall
|
||||
* half-empty plate with bottom-only radius; make it a compact rounded action bar. */
|
||||
.cbi-page-actions {
|
||||
background: transparent;
|
||||
border: 0;
|
||||
border-radius: 0;
|
||||
box-shadow: none;
|
||||
padding: var(--fs-space-2) 0;
|
||||
margin: 0 0 var(--fs-card-gap);
|
||||
text-align: end;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: flex-end;
|
||||
gap: var(--fs-space-2);
|
||||
/* The design call: WRAP the bar rather than let its items shrink into it. Save/Reset are
|
||||
* plain text with no ellipsis, so their min-content protects them — a no-wrap row's shrink
|
||||
* factor lands entirely on the Save & Apply split control, whose caption DOES have an
|
||||
* ellipsis to give (theme/65-dropdown.css) and so absorbs the whole squeeze. Measured on the
|
||||
* gallery's own fixture (EN "Save & Apply"): a no-wrap row cut it by up to 87px at 320px/
|
||||
* Normal and 119px at 320px/Large, worse than the numbers this bug was filed against
|
||||
* (43-68px on a live page, where the sidebar leaves less room than the gallery's isolated
|
||||
* card) — same fault, same direction, this fixture just has less room to give.
|
||||
* `flex-wrap: wrap` sends the split control (or Save+Reset) to its own line once they no
|
||||
* longer fit one, so the caption is squeezed only by its OWN box, never by a sibling's:
|
||||
* the same fixture measures 0px cut at every width/density this bug was filed against, RU
|
||||
* or EN, after this one line. The caption still owns an ellipsis for the genuine edge it
|
||||
* cannot solve — a full RU sentence at Large density in a 320px column has nowhere left to
|
||||
* grow even alone on its line (measured: 33px still short there) — and that is the right
|
||||
* place for it to give, not a sibling button's unrelated width. */
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
.cbi-page-actions .cbi-button,
|
||||
.cbi-page-actions .btn {
|
||||
min-height: var(--fs-ctl-h);
|
||||
padding: 0 var(--fs-space-5);
|
||||
border-radius: var(--fs-radius);
|
||||
font-weight: var(--fs-weight);
|
||||
display: inline-flex; align-items: center; justify-content: center;
|
||||
vertical-align: middle;
|
||||
}
|
||||
/* Reset takes the same step of the ladder as Save (-soft at rest, -fill on hover), so the two read
|
||||
* as equally weighted secondary actions beside the solid Save & Apply — but off the DANGER role,
|
||||
* not the accent one: Reset discards your unsaved changes. (An opaque --fs-panel2 was the first
|
||||
* attempt and weighed MORE than Save's translucent 10-15% tint: a solid surface and a tint do
|
||||
* not read as the same fill, whatever their lightness.) The label is --fs-text for the same
|
||||
* reason as Save's — --fs-dim on
|
||||
* --fs-danger-soft measures 4.49:1 in the worst palette x mode block, under AA by a hundredth.
|
||||
* The role lives in the fill and the border. */
|
||||
.cbi-page-actions .cbi-button-reset {
|
||||
background: var(--fs-danger-soft);
|
||||
border: 1px solid var(--fs-danger-line);
|
||||
color: var(--fs-text);
|
||||
}
|
||||
.cbi-page-actions .cbi-button-reset:hover {
|
||||
background: var(--fs-danger-fill);
|
||||
border-color: var(--fs-danger-line-hi);
|
||||
}
|
||||
|
||||
/* There is no `.spinning` padding ladder here, and it must not come back: seven selectors
|
||||
* reserving room for an absolutely-positioned glyph, each climbing a class above whatever else
|
||||
* padded that element. The ladder lost twice in the field (issues #15 and #22), and every loss
|
||||
* looks the same — the spinner draws on top of the label, silently; #22 lost to a 0,5,0
|
||||
* data-table rule. base/95-luci.css puts the
|
||||
* glyph IN THE FLOW instead, so it reserves its own space. */
|
||||
|
||||
input[type="file"]::file-selector-button {
|
||||
margin-inline-end: var(--fs-space-3); padding: var(--fs-space-2) var(--fs-space-3-5);
|
||||
font-family: var(--fs-font-sans); font-size: var(--fs-type); font-weight: var(--fs-weight);
|
||||
color: var(--fs-text); background: var(--fs-panel2);
|
||||
border: var(--fs-hairline); border-radius: var(--fs-radius-sm); cursor: pointer;
|
||||
}
|
||||
input[type="file"]::file-selector-button:hover { border-color: var(--fs-accent); color: var(--fs-accent); }
|
||||
|
||||
/* Row-action buttons (Edit / Delete / Start-Stop) in a table or a .cbi-section-actions container.
|
||||
* Compact so tables stay dense: neutral outline by default, with the variants colouring the ones
|
||||
* that carry meaning. The neutral :hover comes FIRST on purpose — last, it greys the coloured
|
||||
* variants back out on hover, which only an !important on their colours hides. Equal
|
||||
* specificity, so a variant hover must be written after it.
|
||||
*
|
||||
* WCAG 2.2 SC 2.5.8: a pointer target must be >= 24x24 px, or spaced so 24px circles centred on
|
||||
* adjacent targets do not overlap. At 28px tall with a 1px margin either side the circles DO
|
||||
* overlap, so the exemption does not apply; 32px clears it. */
|
||||
.cbi-section-actions .cbi-button, .cbi-section-actions .btn,
|
||||
.cbi-section-table .cbi-button {
|
||||
min-height: var(--fs-ctl-h-sm); padding: 0 var(--fs-space-3); font-size: var(--fs-type);
|
||||
/* `.td .cbi-button, .td .btn` dropped (task 0151): the action cells this was filed against
|
||||
* (form.TableSection's `.td.cbi-section-table-cell.cbi-section-actions`, per 30-tables.css's
|
||||
* own discriminator) are already reached by `.cbi-section-actions .cbi-button`/`.btn` below —
|
||||
* `.cbi-section-actions` sits on the .td itself, so the descendant selector matches with no
|
||||
* `.td` needed. What the bare `.td` reached and those two do not is every OTHER button in
|
||||
* every OTHER cell: measured collateral, 14 buttons including the icon-only rail drag handle
|
||||
* and a plain-cell "Reserve IP" (Wireless's hand-built `.td.middle`, DHCP leases — neither
|
||||
* carries `.cbi-section-actions`), `overflow: hidden` re-baselining an inline-block and
|
||||
* growing the DHCP leases rows 50px -> 50.84px (10 rows at 1280) for nothing that clipped.
|
||||
* base/95-luci.css sizes each button `flex: 1 1 4em` inside `.td.cbi-section-actions`. A
|
||||
* DEFINITE flex-basis is what let the fix below regress the desktop: with `overflow: hidden`
|
||||
* alone, the automatic minimum for a definite basis resolves to 0 in EVERY row regardless of
|
||||
* room, so `flex-grow` divides by count instead of by need even where nothing needed to
|
||||
* shrink — measured live on Firewall Zones at 1440px, three buttons that read 37.66/97.73/
|
||||
* 89.69px in v0.14.11 converged to 75.02/75.03/75.03px, 11-21px of caption ellipsised for
|
||||
* zero gain (same row total, 225.08px, either way). `flex-basis: auto` is the one-property
|
||||
* fix: it hands sizing back to CONTENT, so the automatic minimum is the caption's own
|
||||
* min-content again and `flex-grow` only ever redistributes genuine slack — reproduced
|
||||
* locally (docs/gallery.html's Startup fixture, unconstrained): auto restores the exact
|
||||
* v0.14.11 widths (101.58/137.72/112.08/230.25px) at 1440, 0px moved, with `overflow: hidden`
|
||||
* left in place. `overflow: hidden` + the ellipsis below still answer the original fault —
|
||||
* a row genuinely narrower than its captions' combined content now shrinks BELOW their
|
||||
* min-content, not before, and the caption gives (ellipsis), never the neighbour's box.
|
||||
* Sweep-measured on real captions at every density: 14-19px on Startup, 12-13px on
|
||||
* "Клонировать", 16-18px on "Перезапустить"/"Перезагрузить", 5px on "Принудительно
|
||||
* завершить" — 0 with the English caption in the same row. `.cbi-page-actions`'s
|
||||
* `flex-wrap: wrap` (above) does not reach these — that selector is the Save/Apply footer,
|
||||
* not a table row, and this is a different container with no line to wrap onto. */
|
||||
flex-basis: auto;
|
||||
overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
|
||||
}
|
||||
.td .cbi-button, .cbi-section-actions .cbi-button, .cbi-section-table .cbi-button {
|
||||
background: transparent; background-image: none;
|
||||
border: var(--fs-hairline); color: var(--fs-dim);
|
||||
}
|
||||
.td .cbi-button:hover { border-color: var(--fs-dim); color: var(--fs-text); }
|
||||
|
||||
.td .cbi-button-action, .td .cbi-button-edit, .td .cbi-button-apply,
|
||||
.cbi-section-actions .cbi-button-edit, .cbi-section-actions .cbi-button-action {
|
||||
color: var(--fs-accent); border-color: var(--fs-accent-line); background: transparent;
|
||||
}
|
||||
/* THE HOVER INK IS --fs-text, NOT THE ROLE COLOUR, and that is the rule this file already
|
||||
* states twice with measurements: text of colour C on a translucent tint of C eats its own
|
||||
* contrast (Save: accent on accent-soft = 4.25:1, an AA failure; the alert `.label` chip: 3.4-4.4
|
||||
* across the palettes). The row actions were the last place it survived — the role still reads,
|
||||
* from the fill and the border, which is exactly how Save and Reset carry theirs. */
|
||||
.td .cbi-button-action:hover, .td .cbi-button-edit:hover, .td .cbi-button-apply:hover,
|
||||
.cbi-section-actions .cbi-button-action:hover {
|
||||
background: var(--fs-accent-soft); color: var(--fs-text);
|
||||
border-color: var(--fs-accent-line-hi);
|
||||
}
|
||||
/* An enabled/positive toggle in a table cell (System -> Startup) rendered as blue text on a
|
||||
* green fill = unreadable. Green outline instead, matching the red-outline negative button. */
|
||||
.td .cbi-button-positive, .cbi-section-actions .cbi-button-positive {
|
||||
color: var(--fs-good); border-color: var(--fs-good-line); background: transparent;
|
||||
}
|
||||
/* …and the border-colour the other two variants already had. Without it the green outline stayed
|
||||
* at -line while action and negative brightened to -line-hi, so hovering the positive toggle
|
||||
* read as less responsive than its neighbours in the same row. */
|
||||
.td .cbi-button-positive:hover, .cbi-section-actions .cbi-button-positive:hover {
|
||||
background: var(--fs-good-soft); color: var(--fs-text);
|
||||
border-color: var(--fs-good-line-hi);
|
||||
}
|
||||
.td .cbi-button-negative, .td .cbi-button-remove,
|
||||
.cbi-section-actions .cbi-button-remove, .cbi-section-actions .cbi-button-negative {
|
||||
color: var(--fs-danger); border-color: var(--fs-danger-line); background: transparent;
|
||||
}
|
||||
.td .cbi-button-negative:hover, .td .cbi-button-remove:hover,
|
||||
.cbi-section-actions .cbi-button-negative:hover {
|
||||
background: var(--fs-danger-soft); color: var(--fs-text);
|
||||
border-color: var(--fs-danger-line-hi);
|
||||
}
|
||||
|
||||
/* Page actions: Save & Apply is THE primary action, Save is demoted so only one button reads
|
||||
* as primary. `--on-color` drives the spinner mask in styles/base. */
|
||||
.cbi-page-actions .cbi-button-apply,
|
||||
.cbi-page-actions .cbi-dropdown .cbi-button-apply {
|
||||
background: var(--fs-accent);
|
||||
background-image: none;
|
||||
border: 1px solid transparent;
|
||||
color: var(--fs-on-accent);
|
||||
--on-color: var(--fs-on-accent);
|
||||
text-shadow: none;
|
||||
}
|
||||
/* Save carries a TINT at rest, not a bare outline: beside the solid Save & Apply a fully
|
||||
* transparent button reads as disabled rather than secondary. The steps come off the role ladder
|
||||
* (02-tokens.css) — -soft (12%) at rest, -fill (18%) on hover, one step up the same ladder.
|
||||
*
|
||||
* The label is --fs-text, not --fs-accent: never put text of colour C on a translucent tint of C
|
||||
* (docs/design-system.md). The tint drags the surface toward the text and eats its own contrast
|
||||
* — accent on accent-soft measures 4.25:1, an AA failure. The role is carried by the fill and
|
||||
* the border.
|
||||
*
|
||||
* `filter: none` cancels the shared hover's --fs-hover-lift: on a translucent tint a brightness
|
||||
* shift washes the fill out instead of deepening it. */
|
||||
.cbi-page-actions .cbi-button-save,
|
||||
.cbi-page-actions .cbi-button-apply + .cbi-button-save,
|
||||
.cbi-page-actions .cbi-button-negative + .cbi-button-save {
|
||||
background: var(--fs-accent-soft);
|
||||
background-image: none;
|
||||
border: 1px solid var(--fs-accent-line);
|
||||
color: var(--fs-text);
|
||||
--on-color: var(--fs-on-accent);
|
||||
text-shadow: none;
|
||||
}
|
||||
.cbi-page-actions .cbi-button-save:hover {
|
||||
background: var(--fs-accent-fill);
|
||||
border-color: var(--fs-accent-line-hi);
|
||||
filter: none;
|
||||
}
|
||||
|
||||
/* Buttons that are part of a compound field widget. */
|
||||
.cbi-dynlist > .add-item > button,
|
||||
.cbi-dynlist > .add-item > .cbi-button-add {
|
||||
/* min-width was a bare 38px — the same number --fs-ctl-h already states. A restated value
|
||||
* is the drift this ladder exists to prevent, and it also sat out the Density axis. */
|
||||
flex: 0 0 auto; width: auto; min-width: var(--fs-ctl-h);
|
||||
min-height: var(--fs-ctl-h-sm); padding: 0 var(--fs-space-3); margin: 0;
|
||||
border: 0; border-inline-start: var(--fs-hairline);
|
||||
border-radius: 0;
|
||||
background: transparent; color: var(--fs-dim);
|
||||
}
|
||||
.cbi-dynlist > .add-item > button:hover,
|
||||
.cbi-dynlist > .add-item > .cbi-button-add:hover { color: var(--fs-accent); }
|
||||
.control-group:has(> .cbi-input-password) > button.cbi-button-neutral {
|
||||
border: 0; border-radius: 0; margin: 0;
|
||||
background: transparent; color: var(--fs-dim);
|
||||
padding: 0 var(--fs-space-3); min-height: var(--fs-ctl-h);
|
||||
border-inline-start: var(--fs-hairline);
|
||||
}
|
||||
.control-group:has(> .cbi-input-password) > button.cbi-button-neutral:hover { color: var(--fs-accent); }
|
||||
/* SQUARE, ON THE LADDER: these were the only buttons in the theme set in bare pixels
|
||||
* (40 wide x 34 high), and 34 was the one control height that appears in no scale — the ladder
|
||||
* is --fs-ctl-h-sm/-h/-h-lg = 30/38/44, plus the derived FIELD height (--fs-control-h, 32).
|
||||
* A literal also opts out of the Density axis: every other control shrinks with
|
||||
* --fs-density-box and the pager did not. Square because the glyph is an arrow, not a label. */
|
||||
.pager .btn.prev, .pager .btn.next {
|
||||
flex: 0 0 auto; width: var(--fs-ctl-h); min-width: var(--fs-ctl-h); height: var(--fs-ctl-h); padding: 0;
|
||||
border-radius: var(--fs-radius); border: var(--fs-hairline);
|
||||
background: var(--fs-panel2); color: var(--fs-text);
|
||||
display: inline-flex; align-items: center; justify-content: center;
|
||||
}
|
||||
.pager .btn.prev:hover, .pager .btn.next:hover { border-color: var(--fs-accent); color: var(--fs-accent); }
|
||||
}
|
||||
@@ -1,921 +0,0 @@
|
||||
@layer theme {
|
||||
/* Value rows.
|
||||
* display:flex + align-items:baseline come from base — do not restate, and do not switch to
|
||||
* center: a row's field can be taller than its control when a `.cbi-value-description` sits
|
||||
* under it, and center then pushes the label to the middle of control+description, visibly
|
||||
* below the control. baseline lines the label up with the field's first line for every
|
||||
* widget. */
|
||||
.cbi-value { justify-content: space-between; gap: var(--fs-space-4); padding: var(--fs-space-2) 0; margin: 0; border-bottom: var(--fs-hairline); }
|
||||
/* stacked controls in a field (Local Time: date input + Sync buttons) need breathing room —
|
||||
* the raw <br> collapses them. Exclude the password reveal group: it must stay seamless. */
|
||||
.cbi-value-field > .control-group { margin-top: var(--fs-space-2); }
|
||||
.cbi-value-field > .control-group:not(:has(.cbi-input-password)) {
|
||||
display: inline-flex; flex-wrap: wrap; gap: var(--fs-space-2); align-items: center;
|
||||
}
|
||||
/* The hairline separates one value row from the NEXT one, so it is dropped whenever no value row
|
||||
* follows — not only at the end of the section. A section ending with a table or an action bar
|
||||
* otherwise draws the line across the top of whatever comes next, cutting through a framed
|
||||
* table's rounded corner. `:last-child` was the special case of this. */
|
||||
.cbi-value:not(:has(+ .cbi-value)) { border-bottom: 0; }
|
||||
/* A toggle/checkbox field has no text baseline: `.cbi-checkbox` is inline-flex with no line box,
|
||||
* so its synthesised baseline is the box's BOTTOM edge and align-items:baseline floats the
|
||||
* toggle ~5px above the label. Centre those rows instead — but only where no help sentence sits
|
||||
* under the control, since centring then drops the label to the middle of control+description,
|
||||
* the regression the comment above warns about. */
|
||||
.cbi-value:not(:has(.cbi-value-description)):has(> .cbi-value-field > .cbi-checkbox, > .cbi-value-field > div > .cbi-radio) {
|
||||
align-items: center;
|
||||
}
|
||||
/* The generic control transition — absorbed from base's transition group. ONLY the
|
||||
* transition: control typography stays in base on purpose (see the note there — as a
|
||||
* bare-element theme rule it out-layered `.zonebadge-empty`'s smaller font, measured
|
||||
* 10.8 -> 13px on the firewall). border-COLOR, not `border`: the shorthand animates
|
||||
* border-width too — a layout animation on every hover instead of a paint one. */
|
||||
input, button {
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
|
||||
/* keep base's padding-top (--fs-space-1) — it is tuned for base's align-items: baseline. */
|
||||
.cbi-value-title {
|
||||
color: var(--fs-dim); font-size: var(--fs-type); font-weight: var(--fs-weight);
|
||||
/* stated, not inherited: the control rule above hands every label `line-height: normal`,
|
||||
* and this one is TEXT — dropping it silently hands the label the font's own default
|
||||
* (measured: 18px -> normal, off the scale entirely). Absorbed from base with the rule
|
||||
* that made it necessary. */
|
||||
line-height: var(--fs-leading);
|
||||
}
|
||||
/* Mono is for the VALUES a field holds. The exclusions:
|
||||
* buttons are chrome, not data — excluded here rather than relying on 55-buttons.css being
|
||||
* concatenated later. `:where()` keeps the exclusion at zero specificity, so the <select>
|
||||
* rule below still wins its own font.
|
||||
* .cbi-value-description is LuCI's inline HELP SENTENCE and lives inside .cbi-value-field.
|
||||
* `strong`/`b` — LuCI writes `<strong>MAC:</strong> ac:1f:6b:…`, so the strong is the LABEL
|
||||
* and the text after it the value. Feeding the label to the mono rule makes it mono AND
|
||||
* weight 700, a face of its own: 227 elements over seven pages in bold mono, and 20 KB of a
|
||||
* 600-weight mono face fetched to draw them.
|
||||
* The label rule itself is in theme/45-misc.css and must ASSIGN the sans face: a <strong> merely
|
||||
* excluded here still INHERITS mono from .cbi-value-field — excluding it alone was measured and
|
||||
* changed nothing. */
|
||||
.cbi-value-field,
|
||||
.cbi-value-field *:where(:not(.btn, .cbi-button, .cbi-value-description)) { font-family: var(--fs-font-mono); }
|
||||
/* text-wrap: the help sentence is a <div>, so base's prose rule (which reaches `p` and the
|
||||
* section/map descriptions) never covered it — and this is the one that wraps most, since it
|
||||
* sits in the field column. Same reasoning as there. */
|
||||
.cbi-value-description { font-family: var(--fs-font-sans); text-wrap: pretty; }
|
||||
|
||||
/* A text field in a CBI form is not a fixed 210px: that width is base's, and the same 210px
|
||||
* holds far less here — the field is monospaced and padded --fs-space-3 a side instead of 4,
|
||||
* so a server URL was clipped mid-domain while the .cbi-dynlist directly under it is 440px
|
||||
* wide (issue #5). Elastic, with the dynlist's own
|
||||
* ceiling so the two line up. Number/date/time keep the fixed width: they hold short values, and
|
||||
* a 440px box for a port number reads as a mistake. */
|
||||
.cbi-value-field input[type="text"],
|
||||
.cbi-value-field input[type="url"],
|
||||
.cbi-value-field input[type="search"] { width: 100%; max-width: var(--fs-field-max); }
|
||||
/* A .cbi-value is designed to hold ONE title+field pair, and base lays it out as a flex row. Some
|
||||
* apps cram several pairs into one .cbi-value, and the flex row then flows them side by side
|
||||
* until the fields overflow the card. Give each title and each field its own full-width row —
|
||||
* the stacked layout base already uses on a phone — scoped by `:has()` to the abnormal
|
||||
* multi-PAIR case only, so every normal single-field row keeps its label-beside-field layout.
|
||||
*
|
||||
* The test is the second TITLE, not the second field, and that is the whole of this rule's
|
||||
* safety: `:has()` is live, so keying on a second field means any app that appends one at
|
||||
* runtime — a status line, an output pane, a spinner holder — flips the row from "label beside
|
||||
* field" to "everything stacked" under the user's finger. Measured: pressing a button in such a
|
||||
* row moved that button 31px down. */
|
||||
.cbi-value:has(.cbi-value-title ~ .cbi-value-title) > .cbi-value-title,
|
||||
.cbi-value:has(.cbi-value-title ~ .cbi-value-title) > .cbi-value-field {
|
||||
flex: 1 1 100%;
|
||||
margin-inline-start: 0;
|
||||
text-align: start;
|
||||
}
|
||||
/* fields inside a table cell fill it — moved from base with the generic 210px box below:
|
||||
* in base these beat the box in-layer, left behind they would lose to it by layer */
|
||||
.td > input[type="text"],
|
||||
.td > input[type="password"],
|
||||
.td > select,
|
||||
.td > .cbi-dropdown:not(.btn):not(.cbi-button),
|
||||
.cbi-dynlist > .add-item > .cbi-dropdown { width: 100%; }
|
||||
.cbi-section-create > * > input { width: 100%; }
|
||||
|
||||
/* --- live components that bypassed the theme --- */
|
||||
/* A CBI row is a <div class="cbi-value"> on a form and a <td class="cbi-value-field"> in a
|
||||
* section table — same <var>, and the theme had claimed only the table half. */
|
||||
div.cbi-value var, .td.cbi-value-field var { color: var(--fs-accent); }
|
||||
.td.cbi-value-field var.cbi-tooltip-container { border-bottom-color: var(--fs-accent); }
|
||||
.cbi-filebrowser { border-color: var(--fs-border); background: var(--fs-panel); border-radius: var(--fs-radius-lg); }
|
||||
.cbi-filebrowser > ul > li:hover { background: var(--fs-panel2); }
|
||||
.cbi-filebrowser .upload { border-top-color: var(--fs-border); }
|
||||
|
||||
/* A file-browser row must hold its own buttons, and the row CLIPS what does not fit rather than
|
||||
* showing it. base sizes the row by proportion (name `flex: 10`, actions `flex: 3`), which is
|
||||
* sound for base's own ~20px buttons in a text-height row; this theme's button is 36px tall with
|
||||
* 14px of side padding and a file row carries up to three of them, so at 23% of the row they do
|
||||
* not fit — and `.cbi-filebrowser > *` is `overflow: hidden`, so a button touches the clip box
|
||||
* on both axes and loses its rounded corners, which reads as a broken button.
|
||||
*
|
||||
* So: size the action column to its CONTENT and let the name give way (a name can ellipsize, a
|
||||
* button cannot), give the children a real gutter, and space the rows. It wraps rather than
|
||||
* clips when even that is not enough. */
|
||||
.cbi-filebrowser > * { border-bottom-color: var(--fs-border); padding: var(--fs-space-1-5) var(--fs-space-2); }
|
||||
.cbi-filebrowser > ul { display: flex; flex-direction: column; gap: var(--fs-space-1); }
|
||||
.cbi-filebrowser > ul > li { align-items: center; flex-wrap: wrap; gap: var(--fs-space-2); }
|
||||
.cbi-filebrowser > ul > li > div:first-child { flex: 1 1 auto; min-width: 0; }
|
||||
/* `0 1 auto`, not `0 0 auto`: the actions block is three buttons (Deselect / Download / Delete) and
|
||||
* it may WRAP but may not shrink, so on a 320px screen it kept its one-line width and stuck 23px
|
||||
* out of the browser box — measured in the gallery at 320px, where `Delete` ended past the card.
|
||||
* Shrinking is what lets its own `flex-wrap` fire; `min-width: 0` is what lets shrinking reach
|
||||
* below the buttons' min-content, which is the pair every flex item in this theme needs. */
|
||||
.cbi-filebrowser > ul > li > div:last-child {
|
||||
flex: 0 1 auto; min-width: 0;
|
||||
display: flex; flex-wrap: wrap; gap: var(--fs-space-2); justify-content: flex-end;
|
||||
}
|
||||
.cbi-filebrowser > ul > li > div:last-child > button { margin: 0; }
|
||||
/* moved from base with the generic 210px box (same layer arithmetic as the .td rules) */
|
||||
.cbi-filebrowser .upload > div > input { width: 100%; }
|
||||
|
||||
/* Form widgets — toggles, file input. Applies to every CBI form. */
|
||||
|
||||
/* A raw checkbox inside a button-styled label sat flush against its text: base zeroes the
|
||||
* checkbox margin (30-forms.css) and only a literal space separated the ✓ from the words
|
||||
* (issue #5.1 — attendedsysupgrade's "Keep settings" confirm: label.btn > input[type=checkbox]
|
||||
* + text). Restore a gap. The toggle-switch .cbi-checkbox below is unaffected — its own
|
||||
* margin: 0 outranks this rule by specificity ((0,2,1) vs this rule's (0,2,1) on a DIFFERENT
|
||||
* ancestor class, so the two never both match one element: `.cbi-checkbox` is never `.btn`). */
|
||||
.btn > input[type="checkbox"], .btn > input[type="radio"] { margin-inline-end: .5em; }
|
||||
|
||||
/* checkbox -> toggle switch, drawn on the INPUT itself.
|
||||
*
|
||||
* Was drawn on label[for] with the real input hidden (position:absolute; opacity:0; width/
|
||||
* height:0) — forum.openwrt.org/t/251930 post #141: luci-app-modemdata (and any third-party CSS
|
||||
* built the way bootstrap expects, styling the native input) injects an unlayered
|
||||
* `label[for] { display: none }` flagged important, scoped to its own markup, which left
|
||||
* NOTHING visible, since the input it left alone was the invisible one. Drawing on the input
|
||||
* means an app that hides label[for] hides an already-empty placeholder, not the switch.
|
||||
*
|
||||
* The pill, the knob and the knob's travel are all on --fs-density-box. As bare literals they
|
||||
* make LuCI's most common control the only one in the theme that ignores the Density axis, while
|
||||
* every button and field around it moves: measured, the switch held 40x22 at Compact and at
|
||||
* Large while the fields beside it went 38 -> 32.3 -> 43.7. The switch is a box that holds a
|
||||
* knob, which is the
|
||||
* box tier by definition. Local names rather than new global tokens: one component needs one
|
||||
* number and three things derived from it.
|
||||
*
|
||||
* flex-shrink: 0 below (task 0145): `.cbi-checkbox` is the flex row, and a caption after the
|
||||
* pill — `label.cbi-checkbox > input + label[for] + TEXT`, package-manager.js's and banip's real
|
||||
* markup — makes the input (now the real, sized flex item; label[for] no longer is one, below) a
|
||||
* SECOND, shrinkable flex item. Unshrunk it stays exactly --sw-w; measured shrunk on the live
|
||||
* Install dialog on both stands when this box was still label[for]'s (task 0145): RU/Normal/390px
|
||||
* gave a used width of 30.17px against 40 declared and a knob 6.83px past the pill's right edge,
|
||||
* EN/Large/360px 36.22 against 46 declared and a 6.47px overhang — flex-shrink: 0 alone took both
|
||||
* to -3.00px and -3.31px (the knob safely inside the pill, not flush with it). The flex row and
|
||||
* its sibling caption are unchanged by which element carries the pill, so the guard carries over.
|
||||
*
|
||||
* label[for] stays in the DOM (ui.js and every third-party app that builds this markup emit it)
|
||||
* but draws and occupies nothing: `[for]` still discriminates it from the SECOND label
|
||||
* Checkbox.render() appends when `tooltip` is set (form.Flag.tooltip — e.g. luci-app-firewall's
|
||||
* zones.js on `masq`), `label.cbi-tooltip-container` holding the hint icon, which must keep
|
||||
* rendering. */
|
||||
/* `overflow-wrap: anywhere`: the caption after the pill is a plain text flex item, which already
|
||||
* wraps at spaces on its own — this is only for the one WORD that does not fit even at the row's
|
||||
* own full width. Measured on this exact caption (see the pill's own comment below): pseudo-loc
|
||||
* grows "неиспользуемые" (14 letters) to 20, wide enough on its own to push the whole row 24.6px
|
||||
* past `.cbi-value-field` at 320px/Large with no scroller — a real Russian compound this length
|
||||
* is not implausible (the theme already ships an untranslated one), so the row should absorb it
|
||||
* by breaking the word, not by escaping its column. */
|
||||
.cbi-checkbox { display: inline-flex; align-items: center; gap: var(--fs-space-2); overflow-wrap: anywhere; }
|
||||
/* label[for] takes over the input's old trick (position:absolute, zero box, opacity:0): out of
|
||||
* flow and out of the flex item count, so `.cbi-checkbox`'s `gap` still opens on only the SAME
|
||||
* two neighbours it always did — see the tooltip-container note below. */
|
||||
.cbi-checkbox > label[for] { position: absolute; opacity: 0; width: 0; height: 0; margin: 0; }
|
||||
.cbi-checkbox > input[type="checkbox"] {
|
||||
--sw-w: calc(40px * var(--fs-density-box));
|
||||
--sw-h: calc(22px * var(--fs-density-box));
|
||||
--sw-knob: calc(16px * var(--fs-density-box));
|
||||
--sw-pad: calc(2px * var(--fs-density-box));
|
||||
/* `appearance: none` and this compound's other unstated properties (color, the invalid
|
||||
* --bd-color/--fg-color custom props) still come from the bare `input[type="checkbox"]`
|
||||
* rule further down, written for a third-party app's raw markup: harmless to share, since
|
||||
* this input never reads --bd-color/--fg-color. The parts of that rule that WOULD paint
|
||||
* over this switch (the drawn box, the mark, the focus ring) are scoped with
|
||||
* `:not(:where(.cbi-checkbox > input))` at their own selector instead of being undone here —
|
||||
* cheaper than restating every property this rule already states for the opposite reason,
|
||||
* and it is one property, not eight, that both rules would otherwise fight over. */
|
||||
display: inline-block; position: relative; margin: 0; flex-shrink: 0;
|
||||
width: var(--sw-w); height: var(--sw-h); border-radius: var(--fs-radius-pill);
|
||||
background: var(--fs-track); border: var(--fs-hairline);
|
||||
cursor: pointer; transition: background var(--fs-dur), border-color var(--fs-dur); vertical-align: middle;
|
||||
}
|
||||
/* The invisible overlay stretching the hit target to 44x30 (WCAG 2.5.8: the pill is 22px tall,
|
||||
* under the 24px floor) — moved here from label[for] unchanged. position:absolute, so it adds
|
||||
* nothing to layout; the knob keeps ::after.
|
||||
*
|
||||
* `content`/`position` come from the raw checkbox's own shared `::before, ::after { position:
|
||||
* absolute; content: "" }` rule further down — left UNSCOPED and reused here rather than
|
||||
* restated, since both pseudo-elements need exactly those two values anyway. The two rules
|
||||
* that would otherwise paint a drawn box and a mark ON this pseudo (their own selectors,
|
||||
* further down) are scoped with `:not(:where(.cbi-checkbox > input))` instead, so nothing is left to
|
||||
* override here.
|
||||
*
|
||||
* The inset stays literal while the pill above scales: this is an accessibility floor, and a
|
||||
* floor that shrinks with a density setting is not one. At Compact the target is still 38x26.7,
|
||||
* over the minimum. */
|
||||
.cbi-checkbox > input[type="checkbox"]::before { inset: -4px -2px; }
|
||||
.cbi-checkbox > input[type="checkbox"]::after {
|
||||
top: var(--sw-pad); inset-inline-start: var(--sw-pad);
|
||||
width: var(--sw-knob); height: var(--sw-knob); border-radius: 50%;
|
||||
background: var(--fs-dim);
|
||||
/* transform, not `left`: `left` is a layout property, so the knob re-laid out the row on
|
||||
* every frame of the slide. translateX is composited. */
|
||||
transform: translateX(0);
|
||||
transition: transform var(--fs-dur-move), background var(--fs-dur);
|
||||
}
|
||||
/* The tooltip-container label (above) is unstyled by the switch rules and falls back to the
|
||||
* browser's plain inline label plus base's `cursor: help` — the icon glyph, no pill. It still
|
||||
* needs a gap from the switch, and `.cbi-checkbox`'s own `gap` above gives it one instead of a
|
||||
* margin declared here: label[for] inside that flex row is `position: absolute` (above), so it
|
||||
* is never a flex item, and `gap` only ever opens BETWEEN flex items — an ordinary `.cbi-checkbox`
|
||||
* with just the switch input has one flex item (the input itself) and gets no gap at all, while
|
||||
* the tooltip fixture's input+tooltip-label pair gets exactly one. --fs-space-2 (8px), same
|
||||
* number the removed margin used — the gap the theme already uses beside an inline checkbox
|
||||
* glyph (`.btn > input[type="checkbox"]` above). The flex-item COUNT and the gap token are the
|
||||
* same as before this rule moved from label[for] to the input; only which element is the
|
||||
* absolute one swapped. */
|
||||
.cbi-checkbox > input[type="checkbox"]:checked { background: var(--fs-accent); border-color: transparent; }
|
||||
/* The travel is derived rather than hand-written, so it cannot drift out of step with the three
|
||||
* sizes above. The `- 2px` is the pill's two 1px BORDERS and is the whole subtlety: --sw-w is a
|
||||
* border-box width, while an absolutely-positioned ::after is placed against the PADDING box, so
|
||||
* the knob has 2px less room and deriving without that term lands it off-centre — the travel
|
||||
* comes out 20px where symmetry wants 18. The border does not scale with density, so the term
|
||||
* stays literal. */
|
||||
.cbi-checkbox > input[type="checkbox"]:checked::after {
|
||||
transform: translateX(calc(var(--sw-w) - var(--sw-knob) - var(--sw-pad) * 2 - 2px));
|
||||
background: var(--fs-on-accent);
|
||||
}
|
||||
/* The bare fallback ring further down (`input:focus`, for every untyped/unlisted input, and its
|
||||
* `input[type="checkbox"]:focus::before` twin) is scoped with `:not(:where(.cbi-checkbox > input))` at
|
||||
* its own selector, so a plain click on this real, visible input rings nothing — as it never
|
||||
* did before this input was the drawn element, since only :focus-visible below is meant to. */
|
||||
/* The <input> IS the switch now, so the ring goes there directly, or the most common control in
|
||||
* LuCI shows nothing under keyboard focus.
|
||||
*
|
||||
* -solo, because on the CHECKED switch — half the switches on any page — neither other channel
|
||||
* exists: the rule above fills the track with --fs-accent and sets `border-color: transparent`,
|
||||
* so the border flip is accent on accent (measured: fill rgb(86,157,245) against a border of the
|
||||
* same accent at .97 alpha) and the tinted ring is accent at .15 alpha. */
|
||||
.cbi-checkbox > input[type="checkbox"]:focus-visible {
|
||||
border-color: var(--fs-accent);
|
||||
box-shadow: var(--fs-focus-ring-solo);
|
||||
}
|
||||
.cbi-checkbox > input[type="checkbox"]:disabled { opacity: var(--fs-disabled-opacity); cursor: not-allowed; }
|
||||
|
||||
/* Raw checkbox/radio — the drawing, absorbed from base whole: it undoes the generic `input` box
|
||||
* below, and left in base every one of those overrides would lose to that rule by layer. The box
|
||||
* is 16px on the grid and the tick or dot is inset FROM it rather than restating its own number,
|
||||
* so resizing the box cannot leave the mark off-centre. LuCI's own forms wrap checkboxes in the
|
||||
* .cbi-checkbox toggle above; the raw drawing is what a third-party app's bare markup gets.
|
||||
*
|
||||
* `.cbi-checkbox > input` matches the switch's own input too: this base rule stays unscoped for
|
||||
* it, since the switch's own rules above want its `appearance: none` and read neither
|
||||
* --bd-color nor --fg-color. But the drawn box, the mark and the focus ring below DO paint over
|
||||
* the switch once its input is a real, visible element rather than 0x0 — each of those three
|
||||
* selectors carries `:not(:where(.cbi-checkbox > input))` for that reason alone; undoing them instead,
|
||||
* property by property, on the switch's own rules costs more than the one exclusion clause
|
||||
* each needs. */
|
||||
input[type="checkbox"],
|
||||
input[type="radio"] {
|
||||
--bd-color: var(--fs-border);
|
||||
--fg-color: var(--fs-text);
|
||||
/* 16px on the grid, but on the BOX tier, not the space tier. `var(--fs-space-4)` was the
|
||||
* same 16px at Normal and the wrong multiplier everywhere else: space moves to .65 at
|
||||
* Compact and stays 1 at Large, so the tick box went to 10.4px (smaller than any other
|
||||
* control on the page — measured) and then refused to grow at Large. A checkbox is a box
|
||||
* that has to HOLD an icon, which is what --fs-density-box is defined for. */
|
||||
--box: calc(16px * var(--fs-density-box));
|
||||
--mark-inset: 3px;
|
||||
/* ---- the drawing is 16px; the target is 24px ----
|
||||
*
|
||||
* WCAG 2.2 SC 2.5.8 lets an undersized target pass on SPACING — 24px centre to centre — which
|
||||
* is what a 16px tick box has always relied on. That holds while the theme decides the layout
|
||||
* and stops the moment a third-party app lays out its own rows, putting this checkbox and a
|
||||
* link inside the 24px. A target that passes only because of somebody else's markup is not a
|
||||
* target that passes.
|
||||
*
|
||||
* So the ELEMENT is 24px and the drawing stays 16px, centred inside it: the two pseudo
|
||||
* elements are already absolutely positioned, so centring costs `inset: 0; margin: auto`.
|
||||
* Nothing moves visually — the box, the tick and the focus ring are all drawn by the pseudo
|
||||
* elements, and the element itself has neither background nor border.
|
||||
*
|
||||
* `max()`, not a flat 24px: the Large density scales `--box` to 18.4px, and a target must
|
||||
* never SHRINK when the user asks for a bigger UI. */
|
||||
--hit: max(24px, var(--box));
|
||||
appearance: none;
|
||||
width: var(--hit);
|
||||
height: var(--hit);
|
||||
/* …and the target does not cost a row its height: the element is 24px but occupies its old
|
||||
* `--box` in layout, the negative margin pulling the extra area back out of the flow so the
|
||||
* box overflows itself symmetrically. Measured on a third-party listing: rows went 42px ->
|
||||
* 51px with the target simply grown, and 43px with the margin, the target still answering to
|
||||
* a hit test at its centre. */
|
||||
margin: calc((var(--box) - var(--hit)) / 2);
|
||||
color: var(--fg-color);
|
||||
position: relative;
|
||||
display: inline-block;
|
||||
cursor: pointer;
|
||||
background: none;
|
||||
border: none;
|
||||
/* padding/border-radius are NOT reset: the generic input box's values land on an
|
||||
* appearance-none 16px box whose pseudo-elements are absolute — invisible, and what the
|
||||
* widget has always computed */
|
||||
}
|
||||
input[type="checkbox"]::before,
|
||||
input[type="checkbox"]::after,
|
||||
input[type="radio"]::before,
|
||||
input[type="radio"]::after {
|
||||
position: absolute;
|
||||
content: "";
|
||||
}
|
||||
input[type="checkbox"]:not(:where(.cbi-checkbox > input))::before,
|
||||
input[type="radio"]::before {
|
||||
/* centred in the 24px target, and direction-agnostic: `inset: 0; margin: auto` on a box with
|
||||
* a fixed size is the one centring that needs no translate and therefore behaves the same in
|
||||
* RTL, where an `inset-inline-start: 50%` + `translate: -50%` pair would push the drawing the
|
||||
* wrong way. */
|
||||
inset: 0;
|
||||
margin: auto;
|
||||
width: var(--box);
|
||||
height: var(--box);
|
||||
background: linear-gradient(var(--fs-panel), var(--fs-panel2));
|
||||
border: 1px solid var(--bd-color);
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* each box states its own radius — one shared 2px re-declared to 50% for the radio would
|
||||
* be a same-selector shadow inside this layer */
|
||||
input[type="checkbox"]::before { border-radius: 2px; }
|
||||
input[type="radio"],
|
||||
input[type="radio"]::before {
|
||||
border-radius: 50%;
|
||||
}
|
||||
/* keyboard/click focus rings on the DRAWN box — the theme's one ring token, replacing
|
||||
* base's old generic glow; :focus (not :focus-visible) keeps the pre-absorption behaviour
|
||||
* of ringing a clicked box. Both states (plain and invalid) are declared once, further
|
||||
* down this file, in the selector lists every other same-body ring joins — see the two
|
||||
* `--fs-focus-ring`/`--fs-focus-ring-invalid` rules below the text-input group. */
|
||||
input[type="checkbox"]:not(:where(.cbi-checkbox > input))::after,
|
||||
input[type="radio"]::after {
|
||||
/* the mark is inset from the DRAWING, and the drawing is centred in the target, so the mark
|
||||
* centres the same way rather than measuring from the target's own edge */
|
||||
inset: 0;
|
||||
margin: auto;
|
||||
width: calc(var(--box) - var(--mark-inset) * 2);
|
||||
height: calc(var(--box) - var(--mark-inset) * 2);
|
||||
}
|
||||
input[type="checkbox"]:not(:where(.cbi-checkbox > input)):checked::after,
|
||||
input[type="radio"]:checked::after {
|
||||
/* OURS. Drawn as a STROKE, which is this theme's icon language (see --spinner-icon in
|
||||
* base/95-luci.css and --fs-icon-refresh in 02-tokens.css: fill:none, round caps, a 24 grid).
|
||||
* It replaces a solid filled path that was byte-identical to luci-theme-bootstrap's — and to
|
||||
* luci-theme-openwrt-2020's, which is the same project's artwork, not evidence the drawing is
|
||||
* generic. A mask keys on ALPHA, so a stroked path masks exactly as a filled one did. */
|
||||
--checkmark-icon: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23000' stroke-width='3.2' stroke-linecap='round' stroke-linejoin='round'><path d='M4.5 12.5 9.5 17.5 19.5 6.5'/></svg>");
|
||||
-webkit-mask: var(--checkmark-icon) center/cover no-repeat;
|
||||
mask: var(--checkmark-icon) center/cover no-repeat;
|
||||
background: var(--fg-color);
|
||||
}
|
||||
input[type="radio"]:checked:after {
|
||||
/* the radio's dot — filled, because a ring would read as "not selected". OURS: our grid,
|
||||
* our radius (the fill is the one shape a stroke cannot express). */
|
||||
--checkmark-icon: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><circle cx='12' cy='12' r='6.5' fill='%23000'/></svg>");
|
||||
}
|
||||
input[type="checkbox"].cbi-input-invalid,
|
||||
input[type="radio"].cbi-input-invalid {
|
||||
--bd-color: var(--fs-danger);
|
||||
--fg-color: var(--fs-danger);
|
||||
}
|
||||
|
||||
/* The generic field box, absorbed from base's `input, textarea, select, …` group; each other
|
||||
* member lives with its component rule now. Bare `input` keeps the historical 210px box as the
|
||||
* fallback for every type the exhaustive text-input list below does not name — and for a
|
||||
* typeless <input>, which IS a text input. The widget types that must NOT wear this box carry
|
||||
* their own theme rules: a base override would lose to this rule by layer whatever its
|
||||
* specificity. */
|
||||
input {
|
||||
display: inline-block;
|
||||
width: 210px;
|
||||
height: var(--fs-control-h);
|
||||
padding: var(--fs-space-1) var(--fs-space-2);
|
||||
background: var(--fs-panel);
|
||||
color: var(--fs-text);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
}
|
||||
/* base's old `#localtime { width: 300px }` media rule was NOT moved here: the elastic
|
||||
* .cbi-value-field width above already out-layered it (measured on the live router: the
|
||||
* field rendered 440px, not 300) — the rule was dead, and a dead rule is deleted, not
|
||||
* relocated */
|
||||
|
||||
/* native file input — the `initial`/auto resets are absorbed from base: the generic box
|
||||
* above would otherwise dress the native chooser in a 210px bordered field */
|
||||
input[type="file"] {
|
||||
color: var(--fs-dim); font-size: var(--fs-type);
|
||||
padding: initial;
|
||||
border: initial;
|
||||
line-height: initial;
|
||||
box-shadow: none;
|
||||
/* no !important: this out-specifies the generic `input { width: 210px }` on its own.
|
||||
* height/background are NOT reset: the chooser keeps the generic box's control height
|
||||
* and panel tint, as it always has. */
|
||||
width: auto;
|
||||
}
|
||||
|
||||
/* native <select> — custom chevron + theme (matching the text inputs). The chevron data-URI
|
||||
* lives in 03-palettes.css per palette/mode block, because a URI cannot read var(); it
|
||||
* replaced a hardcoded grey that ignored palette and dark mode. */
|
||||
select, select.cbi-input-select, .cbi-value-field select {
|
||||
/* unprefixed only: the floor (Chrome 108/Firefox 101/Safari 15.4) clears unprefixed
|
||||
* `appearance` everywhere (Chrome 84, Firefox 80, Safari 15.4 — docs/css.md). -webkit- was
|
||||
* 96 B across these four rules for nothing this sheet still has to run on. */
|
||||
appearance: none;
|
||||
background-color: var(--fs-panel2);
|
||||
background-image: var(--fs-select-chevron);
|
||||
/* right inset from the scale, not a literal 12 — the .cbi-select shell below states the same
|
||||
* position and two spellings of one number is how they would drift apart */
|
||||
/* two 6px bands forming the V, the far one a band-width further in; --fs-space-3 stays the
|
||||
* single spelling of the inset, as the note above says */
|
||||
background-repeat: no-repeat; background-size: 6px 6px;
|
||||
background-position: right calc(var(--fs-space-3) - 1px) center, right calc(var(--fs-space-3) + 5px) center;
|
||||
padding: var(--fs-space-2) var(--fs-space-8) var(--fs-space-2) var(--fs-space-3);
|
||||
border: var(--fs-hairline); border-radius: var(--fs-radius);
|
||||
color: var(--fs-text); font-family: var(--fs-font-sans); font-size: var(--fs-type);
|
||||
line-height: 1.3; min-height: var(--fs-ctl-h); cursor: pointer;
|
||||
/* width/display absorbed from base's generic field box: a select's natural width is its
|
||||
* longest option, so without the fixed box two selects in one form column ragged-edge;
|
||||
* display stated because Chromium's base-select UA default is inline-flex, not the
|
||||
* inline-block the widget has always computed */
|
||||
width: 210px;
|
||||
display: inline-block;
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* group-then-refine, directly under its group: the listbox variant must NOT take the closed
|
||||
* control's one-line height. A SURFACE token, not an ink one: this once read --fs-on-accent
|
||||
* (the ink meant to go ON an accent fill), which resolves to plain white and painted a white
|
||||
* listbox in dark mode. `height: inherit` absorbed from base with the width above — without
|
||||
* it the fixed box would cap a multi-row listbox at one line. */
|
||||
select[multiple] { background-color: var(--fs-panel2); color: var(--fs-text); height: inherit; }
|
||||
/* :focus joins the shared accent ring in the text-input group below. */
|
||||
/* absorbed from base's reset: 100% (= inherit) keeps the option on its select's size, and
|
||||
* only <option> needs the 2em leading — the other controls carry line-height: normal above */
|
||||
option { font-size: 100%; line-height: 2em; }
|
||||
select option { background: var(--fs-panel); color: var(--fs-text); }
|
||||
|
||||
/* Native <select> drop list: the OS renders it, so the `select option` colours above are ignored
|
||||
* on most platforms. Chromium's customisable-select (`appearance: base-select`) renders the
|
||||
* picker in the DOM, so it can be themed like the .cbi-dropdown menu; @supports-gated, and
|
||||
* browsers without it keep the styled closed control plus the native list.
|
||||
*
|
||||
* Scoped to `.cbi-value-field select` only: a third-party app can mount a raw <select> outside
|
||||
* the CBI form and drive it its own way, and early Chrome builds mis-render such a select as a
|
||||
* single-item list. Those sit outside .cbi-value-field, so this scope leaves them native. */
|
||||
@supports (appearance: base-select) {
|
||||
.cbi-value-field select { appearance: base-select; }
|
||||
.cbi-value-field select::picker-icon { display: none; }
|
||||
::picker(select) {
|
||||
appearance: base-select;
|
||||
background: var(--fs-panel); border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg); box-shadow: var(--fs-shadow-pop);
|
||||
padding: var(--fs-space-1-5); margin-top: var(--fs-space-1-5);
|
||||
}
|
||||
.cbi-value-field select option {
|
||||
padding: var(--fs-space-2) var(--fs-space-3); border-radius: var(--fs-radius-sm); font-size: var(--fs-type);
|
||||
/* no `color` here: `select option` above already sets --fs-text, and this restated it
|
||||
* (switched off against 174 options, nothing moved). `background: transparent` is NOT the
|
||||
* same — it deliberately undoes that rule's --fs-panel so the row's own hover shows. */
|
||||
background: transparent; min-height: 0;
|
||||
}
|
||||
.cbi-value-field select option::checkmark { display: none; }
|
||||
.cbi-value-field select option:hover, .cbi-value-field select option:focus-visible { background: var(--fs-panel2); }
|
||||
/* Opaque surface + inset rail, same shape as the open .cbi-dropdown's selected row
|
||||
* (theme/65-dropdown.css): accent text on --fs-accent-soft measured 4.21:1 in dark,
|
||||
* under AA — the tint of the accent eats its own contrast. */
|
||||
.cbi-value-field select option:checked {
|
||||
/* @mirror selected-row/paint */
|
||||
background: var(--fs-panel2); color: var(--fs-accent); box-shadow: var(--fs-row-rail);
|
||||
/* @endmirror */
|
||||
}
|
||||
}
|
||||
|
||||
/* .cbi-select — the legacy luci-compat shell (a div around a native <select>), absorbed from base
|
||||
* whole: the generic field box, the shell's own paint and a focus ring on the theme's token. The
|
||||
* shell is a DIV, so display and width must be stated. `:not(select)` because the class also
|
||||
* appears ON a bare <select>: a replaced element cannot draw the ::before chevron, so shell
|
||||
* paint there means a gradient with no glyph. */
|
||||
/* It paints like the themed <select>, being the same control in an older shell — never a
|
||||
* skeuomorphic surface of its own: a gradient from panel to border is lighter at the bottom in
|
||||
* the dark palettes, and nothing else in the theme has a gradient at all. The geometry below is
|
||||
* the `select` rule above, property for property, so a legacy shell and a modern select line up
|
||||
* in one form column. This is the non-JS fallback: the people who see it already have something
|
||||
* broken. */
|
||||
.cbi-select:not(select) {
|
||||
display: inline-block;
|
||||
width: 210px;
|
||||
/* `height`, NOT `min-height` — the inner select fills the shell with `height: 100%`, and a
|
||||
* percentage against an auto-height parent has no definite containing block to resolve
|
||||
* against, so it falls back to content height: measured, the select collapsed 30px -> 15px
|
||||
* inside a 38px shell, text at the top and half the hit area gone. The themed `select` can
|
||||
* use a floor because it IS the control; a wrapper has to state a height for its child. */
|
||||
height: var(--fs-ctl-h);
|
||||
color: var(--fs-text);
|
||||
font-size: var(--fs-type);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
padding: 0;
|
||||
position: relative;
|
||||
background-color: var(--fs-panel2);
|
||||
background-image: var(--fs-select-chevron);
|
||||
background-repeat: no-repeat;
|
||||
background-size: 6px 6px;
|
||||
background-position: right calc(var(--fs-space-3) - 1px) center, right calc(var(--fs-space-3) + 5px) center;
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* The disabled cue used to live ENTIRELY on the ▾ plate: base/30-forms.css dims
|
||||
* `.cbi-select[disabled]::before` and never the shell itself. With the plate gone the state had
|
||||
* no visual at all, so the shell carries it now. */
|
||||
.cbi-select[disabled]:not(select) {
|
||||
opacity: var(--fs-disabled-opacity);
|
||||
pointer-events: none;
|
||||
}
|
||||
/* .focus and .cbi-input-invalid.focus join the shared accent/danger ring rules further down
|
||||
* this file — same two bodies as every other :focus/:focus-within ring on this token. */
|
||||
/* the native <select> inside the shell: invisible, filling it, clearing the ▾ plate on the
|
||||
* right. The inset is a scale step; the right margin is the plate's width, so it stays
|
||||
* em-relative to the glyph it clears. Every themed-select declaration above (chevron,
|
||||
* padding, min-height) must be answered here, or the inner select paints like a free-standing
|
||||
* one inside the 32px shell. */
|
||||
.cbi-select select,
|
||||
.cbi-select select:focus {
|
||||
appearance: none;
|
||||
outline: none;
|
||||
border: none;
|
||||
background: transparent;
|
||||
background-image: none;
|
||||
box-shadow: none;
|
||||
height: 100%;
|
||||
min-height: 0;
|
||||
width: 100%;
|
||||
/* clears the CHEVRON, which the shell now paints on its own background — the same
|
||||
* --fs-space-8 inset the themed select uses. `margin-right: .6em` used to clear the ▾ plate
|
||||
* instead, and an em-relative margin against a px-positioned glyph is how the two drifted. */
|
||||
padding: 0 var(--fs-space-8) 0 var(--fs-space-3);
|
||||
font-size: var(--fs-type);
|
||||
line-height: normal;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
/* spinner / loading */
|
||||
.spinning, .cbi-value em, em.spinning { color: var(--fs-dim); }
|
||||
|
||||
/* Text inputs and other field widgets, rounded and themed to match the selects and dropdowns
|
||||
* (base leaves them at radius 3 and white). Excludes checkbox/radio and file, handled above.
|
||||
*
|
||||
* The type list must be EXHAUSTIVE: an omission does not fall back to "unstyled", it falls back
|
||||
* to BASE, which still paints a stock white 3px-radius field beside a themed one. */
|
||||
.cbi-input-text, .cbi-input-password, .cbi-input-textarea,
|
||||
.cbi-section-create-name, .cbi-value-field input.create-item-input,
|
||||
input[type="text"], input[type="password"], input[type="number"],
|
||||
input[type="email"], input[type="url"], input[type="search"],
|
||||
input[type="tel"], input[type="date"], input[type="time"],
|
||||
input[type="datetime-local"], input[type="month"], input[type="week"],
|
||||
input[type="color"],
|
||||
textarea {
|
||||
background: var(--fs-panel2);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
color: var(--fs-text);
|
||||
padding: var(--fs-space-2) var(--fs-space-3);
|
||||
min-height: var(--fs-ctl-h);
|
||||
box-shadow: none;
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* width/font-size absorbed from base's generic field box, same numbers — a textarea has
|
||||
* always sat at the fixed 210px (the elastic rule above names only text/url/search) */
|
||||
/* `max-width: 100%` beside the width, because a textarea is the one field whose intrinsic width
|
||||
* comes from an ATTRIBUTE (`cols`, default 20) rather than from the box: measured at a 300px
|
||||
* viewport, two textareas in the gallery stood 19px outside their card while every other control
|
||||
* in the same column fitted. The 210px is the designed width and still applies wherever there is
|
||||
* room for it. */
|
||||
textarea { min-height: 84px; line-height: var(--fs-leading); width: 210px; max-width: 100%; font-size: var(--fs-type); }
|
||||
/* A textarea's native scrollbar is a square strip and a rounded corner does not clip it, so on a
|
||||
* scrolling config field the grey bar pokes past the radius as a square notch. Fix: a slim
|
||||
* self-rounded thumb floated off the edges (transparent border plus background-clip:
|
||||
* padding-box), a transparent track, and a track margin keeping the thumb clear of the corners.
|
||||
*
|
||||
* Deliberately no `scrollbar-width`/`scrollbar-color`: either makes Chromium switch to the
|
||||
* standard scrollbar and ignore this whole ::-webkit block — and that standard bar is the
|
||||
* square, unclipped one. Firefox has no ::-webkit and clips natively.
|
||||
*
|
||||
* 16px wide so ::-webkit-resizer, sized off the scrollbar, gets a bigger grab area; the 5px
|
||||
* transparent thumb border still leaves it 6px visible. */
|
||||
textarea::-webkit-scrollbar { width: 16px; height: 16px; }
|
||||
textarea::-webkit-scrollbar-track { background: transparent; margin: var(--fs-space-4) 0 var(--fs-space-2-5); }
|
||||
textarea::-webkit-scrollbar-thumb {
|
||||
background: var(--fs-dim); border-radius: var(--fs-radius-pill);
|
||||
border: 5px solid transparent; background-clip: padding-box;
|
||||
}
|
||||
textarea::-webkit-scrollbar-thumb:hover { background: var(--fs-text); }
|
||||
/* The bottom-right square where the vertical bar meets the resize grip defaulted to white
|
||||
* and poked past the rounded corner — transparent, so the frame shows. */
|
||||
textarea::-webkit-scrollbar-corner { background: transparent; }
|
||||
/* The resize grip highlights the frame's bottom-right corner — an accent arc tracing the frame's
|
||||
* own radius, with no straight legs. Two borders plus the corner radius draw the arc, and the
|
||||
* legs vanish because the box is shrunk to exactly the radius: the resizer is the scrollbar's
|
||||
* 16px, so a `16px − radius` margin leaves a radius-sized box whose right and bottom border IS
|
||||
* the quarter curve. (A mask would give a shorter arc, but ::-webkit-resizer ignores mask, and a
|
||||
* baked-in SVG colour would not follow the palette.) */
|
||||
/* PHYSICAL on purpose, and mirrored by hand below: ::-webkit-resizer is a UA-drawn corner whose
|
||||
* side follows the writing direction, and it does not accept logical properties — with only the
|
||||
* LTR rule the arc drew on the wrong corner in an RTL document (a stray quarter-circle on the
|
||||
* left of every textarea). */
|
||||
textarea::-webkit-resizer {
|
||||
background: transparent;
|
||||
border-right: 2px solid var(--fs-accent);
|
||||
border-bottom: 2px solid var(--fs-accent);
|
||||
border-bottom-right-radius: var(--fs-radius);
|
||||
margin: calc(16px - var(--fs-radius)) 0 0 calc(16px - var(--fs-radius));
|
||||
}
|
||||
:root[dir="rtl"] textarea::-webkit-resizer {
|
||||
border-right: 0; border-left: 2px solid var(--fs-accent);
|
||||
border-bottom-right-radius: 0; border-bottom-left-radius: var(--fs-radius);
|
||||
margin: calc(16px - var(--fs-radius)) calc(16px - var(--fs-radius)) 0 0;
|
||||
}
|
||||
|
||||
.cbi-input-text:hover, .cbi-input-password:hover, .cbi-input-textarea:hover,
|
||||
input[type="text"]:hover, input[type="password"]:hover, input[type="number"]:hover,
|
||||
input[type="email"]:hover, input[type="url"]:hover, input[type="search"]:hover,
|
||||
textarea:hover { border-color: var(--fs-dim); }
|
||||
|
||||
/* bare `input:focus` absorbed from base's generic glow onto the same ring: it is the fallback
|
||||
* for the types the list does not name and for a typeless <input>; on a bare checkbox/radio it
|
||||
* lands on the drawn box UNDER the ::before ring below — coincident boxes, one visible ring, as
|
||||
* the old glow behaved. `:not(:where(.cbi-checkbox > input))` excludes the toggle switch, whose input is
|
||||
* a real, visible element with its own :focus-visible-only ring (above) — a plain click on it
|
||||
* must ring nothing. `select:focus` and the keyboard-removable dynlist chip (ui.js gives it a
|
||||
* tabindex) join here rather than repeating the same three declarations under their own
|
||||
* selector: one shared body instead of three, 149 B off cascade.css. */
|
||||
.cbi-input-text:focus, .cbi-input-password:focus, .cbi-input-textarea:focus,
|
||||
.cbi-section-create-name:focus,
|
||||
input:focus:not(:where(.cbi-checkbox > input)),
|
||||
input[type="text"]:focus, input[type="password"]:focus, input[type="number"]:focus,
|
||||
input[type="email"]:focus, input[type="url"]:focus, input[type="search"]:focus,
|
||||
input[type="tel"]:focus, input[type="date"]:focus, input[type="time"]:focus,
|
||||
textarea:focus,
|
||||
select:focus,
|
||||
.cbi-dynlist > .item:focus {
|
||||
border-color: var(--fs-accent);
|
||||
box-shadow: var(--fs-focus-ring);
|
||||
outline: none;
|
||||
}
|
||||
/* The plain accent ring above, restated for four components whose selector cannot join that
|
||||
* list without changing what it matches (a pseudo-element, a legacy shell class, two
|
||||
* `:focus-within` containers) — same two declarations, one shared body instead of four, 186 B
|
||||
* off cascade.css. `:is()` around the `:has()` compound keeps the list forgiving: unwrapped, a
|
||||
* `:has()` compound sharing a selector list with plain ones fails the WHOLE rule below the
|
||||
* floor (Firefox < 121; docs/css.md "Two shapes fail it"), instead of just losing that one
|
||||
* selector. `:not(:where(.cbi-checkbox > input))` on the checkbox part for the same reason as the plain
|
||||
* ring above: the toggle switch's own :focus-visible rule is the only one allowed to ring it. */
|
||||
input[type="checkbox"]:not(:where(.cbi-checkbox > input)):focus::before, input[type="radio"]:focus::before,
|
||||
.cbi-select.focus,
|
||||
.cbi-dynlist > .add-item:focus-within,
|
||||
.control-group:is(:has(> .cbi-input-password)):focus-within {
|
||||
border-color: var(--fs-accent);
|
||||
box-shadow: var(--fs-focus-ring);
|
||||
}
|
||||
|
||||
/* Invalid state keeps the danger cue. `.cbi-value-error input` is the Lua-CBI path and belongs
|
||||
* HERE, not in base: base does declare a red border-color for it, but the rule above sets the
|
||||
* `border` SHORTHAND, and a shorthand in a later layer wipes the longhand out regardless of
|
||||
* specificity — so every third-party app on luci-compat rendered the field in --fs-border grey
|
||||
* and had lost its field-error cue while the modern .cbi-input-invalid path worked.
|
||||
*
|
||||
* `.cbi-input-invalid:focus` is not redundant with the rule it sits beside: the generic
|
||||
* `input:focus` above is (0,1,1) and would repaint a focused invalid field accent, and
|
||||
* `.cbi-input-invalid:focus` at (0,2,0) is what stops it — the TYPED `:focus` rules above are
|
||||
* (0,2,1) and still outrank this, so a typed invalid field focuses accent, exactly as before
|
||||
* the absorption. The checkbox/radio `::before` ring and the legacy `.cbi-select` shell need
|
||||
* the identical danger body for the same reason on their own elements — one shared rule
|
||||
* instead of four, 186 B off cascade.css. */
|
||||
input[type="checkbox"].cbi-input-invalid:focus::before,
|
||||
input[type="radio"].cbi-input-invalid:focus::before,
|
||||
.cbi-select.cbi-input-invalid.focus,
|
||||
.cbi-input-invalid, input.cbi-input-invalid, textarea.cbi-input-invalid,
|
||||
.cbi-value-error input, .cbi-value-error textarea,
|
||||
.cbi-input-invalid:focus {
|
||||
border-color: var(--fs-danger);
|
||||
box-shadow: var(--fs-focus-ring-invalid);
|
||||
}
|
||||
/* The same rejected value shown by a ui.Dropdown rather than an <input>: the widget itself and,
|
||||
* when it is closed, the <li> that displays the value. base carried these two and the theme only
|
||||
* the input, so half of one state lived in a layer the theme cannot reach. */
|
||||
.cbi-input-invalid.cbi-dropdown:not(.btn):not(.cbi-button),
|
||||
.cbi-input-invalid.cbi-dropdown:not([open]) > ul > li { border-color: var(--fs-danger); }
|
||||
|
||||
/* readonly keeps its faded border — moved from base with the generic box (its border-color
|
||||
* longhand would lose to the box's `border` shorthand by layer). The doubled [readonly] is
|
||||
* a deliberate specificity step: at (0,1,1) this ties the typed input rules above and the
|
||||
* cascade would rest on file order — in base the same tie made the fade silently LOSE to
|
||||
* the typed border, so a readonly text field never faded at all; (0,2,1) states the intent. */
|
||||
:is(input, select, textarea)[readonly][readonly] {
|
||||
border-color: color-mix(in srgb, var(--fs-border) calc(var(--fs-disabled-opacity) * 100%), transparent);
|
||||
pointer-events: auto;
|
||||
cursor: auto;
|
||||
}
|
||||
|
||||
/* dynamic list: keep base's layout (inline-flex column of chips + one add-item row) — do NOT
|
||||
* set display/flex-wrap here or the add row breaks. Only colours, rounding, a compact +
|
||||
* button, and no wrapping box: capped narrow so the chip's × sits near the text instead of
|
||||
* floating across a full-width field. */
|
||||
.cbi-dynlist {
|
||||
gap: var(--fs-space-1-5);
|
||||
background: transparent; border: 0; padding: 0;
|
||||
/* `min(240px, 100%)`, not a bare 240: the floor is there so a chip's × sits near its text
|
||||
* rather than floating across a full-width field, and it becomes a defect the moment the
|
||||
* column is narrower than the floor — measured in the gallery at a 320px viewport, the list
|
||||
* held 240px inside a 210px field and every chip, the add row and its input stood 29px
|
||||
* outside the card. A floor that exceeds the room is not a floor, it is an overflow. */
|
||||
min-height: 0; min-width: min(240px, 100%); max-width: var(--fs-field-max); width: 100%;
|
||||
vertical-align: top;
|
||||
}
|
||||
.cbi-dynlist > .item {
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-sm);
|
||||
color: var(--fs-text);
|
||||
box-shadow: none;
|
||||
margin: 0;
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* a chip is keyboard-removable (ui.js gives it a tabindex): :focus joins the shared accent
|
||||
* ring in the text-input group above. */
|
||||
/* The chip's × plate is a BUTTON in base's paint group (`.item::after, .btn, .cbi-button`) —
|
||||
* absorbed with it, bare as base had it (coverage: an .item outside a dynlist keeps its
|
||||
* plate). The machinery — content/position/edges/align — stays in base with the widget. */
|
||||
.item::after {
|
||||
display: inline-block;
|
||||
cursor: pointer;
|
||||
background: linear-gradient(var(--fs-panel), var(--fs-panel) 25%, var(--fs-panel2));
|
||||
padding: 0 var(--fs-space-3);
|
||||
color: var(--fs-text);
|
||||
line-height: 2em;
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* the hover cue is the lift, not a colour: the plate's fill is a gradient (see
|
||||
* --fs-hover-lift in 02-tokens.css) — replaces base's old focus-glow-on-hover */
|
||||
.item:hover::after { filter: var(--fs-hover-lift); }
|
||||
.cbi-dynlist > .item::after {
|
||||
/* display/padding absorbed from base's machinery rule: the bare plate above says
|
||||
* inline-block / space-3, and by layer it would beat base's refinement */
|
||||
display: inline-flex;
|
||||
padding: 0 var(--fs-space-2);
|
||||
color: var(--fs-danger);
|
||||
border-radius: 0 var(--fs-radius-sm) var(--fs-radius-sm) 0;
|
||||
}
|
||||
/* text add-item = one bordered input group (input + + button attached) */
|
||||
.cbi-dynlist > .add-item {
|
||||
align-items: stretch;
|
||||
background: var(--fs-panel2); border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-sm); overflow: hidden;
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
/* :focus-within joins the shared accent ring in the text-input group above. */
|
||||
.cbi-dynlist > .add-item > input,
|
||||
/* `width: auto` keeps the flex basis in charge: this input sits INSIDE .cbi-value-field, so the
|
||||
* elastic width above would otherwise hand it 100% of the field on top of `flex: 1 1 auto`. */
|
||||
.cbi-dynlist > .add-item > .cbi-input-text {
|
||||
flex: 1 1 auto; min-width: 0; width: auto;
|
||||
border: 0; background: transparent;
|
||||
box-shadow: none; min-height: var(--fs-ctl-h-sm); border-radius: 0;
|
||||
}
|
||||
|
||||
/* password reveal: input + ∗ button as ONE seamless rounded group.
|
||||
* `gap: 0` is load-bearing: base gives every .control-group a gap, and this is the one group
|
||||
* whose members must touch — the group draws the single border and clips them. */
|
||||
.control-group:has(> .cbi-input-password) {
|
||||
display: inline-flex; align-items: stretch; gap: 0;
|
||||
background: var(--fs-panel2);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
overflow: hidden;
|
||||
transition: var(--fs-field-transition);
|
||||
}
|
||||
.control-group:has(> .cbi-input-password) > .cbi-input-password {
|
||||
border: 0; border-radius: 0;
|
||||
background: transparent; box-shadow: none;
|
||||
min-height: var(--fs-ctl-h);
|
||||
}
|
||||
/* :focus-within (wrapped in :is() for the shared list) joins the accent ring in the
|
||||
* text-input group above. */
|
||||
/* base pulls .cbi-section-create up 3px to hug a table border, which glues the "Add" button
|
||||
* to the last row — give it a real gap instead. */
|
||||
.cbi-section-create, .cbi-section-create.cbi-tblsection-create { margin-top: var(--fs-space-3); }
|
||||
|
||||
/* `.hidden` must win over every component rule in this layer. An enumerated list
|
||||
* (`.cbi-value.hidden`, `.cbi-section.hidden`, …) only ever covers the elements someone has
|
||||
* already been bitten by, and the one it misses is the Enter-key submit every legacy Lua page
|
||||
* carries: luci-compat opens each form with `<input type="submit" class="hidden">`, and an
|
||||
* attribute selector counts as a class, so `input[type="submit"]` at (0,1,1) beats a bare
|
||||
* `.hidden` at (0,1,0) and a stray "Save" button floats above the page title (issue #12).
|
||||
* Doubling the class states the invariant once at (0,2,0) instead of chasing elements. An
|
||||
* `!important` would do it too, and would invert the layer order for every future override.
|
||||
* `fs-sheets.js` (rehostIntoThemeLayer) re-hosts a foreign app's own sheet into `@layer theme`,
|
||||
* where it now competes on specificity instead of losing to an unlayered rule by layer order
|
||||
* alone: measured on owrt2512 with luci-app-splify2 26.9, `<aside class="hidden lg:flex …">`
|
||||
* (Rail.tsx) stayed `display: none` at 1440/1920px because `.hidden.hidden` at (0,3,0) — see
|
||||
* below — outranked `.lg\:flex` at (0,1,0). `:not([class*=":"])` excludes any class list that
|
||||
* carries a Tailwind/UnoCSS responsive variant (the colon in `lg:flex`, `md:block`, `sm:inline`)
|
||||
* from the invariant above; LuCI itself never emits a class containing `:`, so nothing stock
|
||||
* is affected. Specificity moves to (0,3,0) — `:not()` counts its argument's attribute
|
||||
* selector, (0,1,0) — still clear of `input[type="submit"]` at (0,1,1) (issue #12, unchanged). */
|
||||
.hidden.hidden:not([class*=":"]) { display: none; }
|
||||
/* RangeSlider (UIRangeSlider) — the one LuCI widget base leaves to native browser rendering.
|
||||
* Token-driven track/thumb.
|
||||
* The INPUT box is the WCAG 2.2 SC 2.5.8 target (24px min): it used to be the 6px track
|
||||
* itself, measured 258x6 on owrt2512/390x844 (System > System). Box and paint split here —
|
||||
* a transparent 24px box, the 6px bar drawn by the track pseudo-element inside it.
|
||||
*
|
||||
* A flat `height: 24px` DOES move the row, and not through `.cbi-range-slider`'s own cross
|
||||
* size — that stayed 29.5px throughout, already pinned by the value chip beside it. It moves
|
||||
* through the enclosing LINE BOX: `.cbi-value-field` lays this element out as ordinary inline
|
||||
* content, and the line's height is anchored on where `.cbi-range-slider` (inline-flex, no
|
||||
* baseline-participating child) reports ITS baseline to the ancestor line — which tracks the
|
||||
* first flex item's own edge and moved with the input's box. Measured before either fix below:
|
||||
* `.cbi-value-field` +2.75px (Chromium) / +2.5px (Firefox), `.cbi-value` +1.5px / +1.0px,
|
||||
* track/thumb ~1.25px lower.
|
||||
*
|
||||
* First half of the fix is the checkbox's own trick (`--hit`/`--box` below): grow the box for
|
||||
* the hit target, then pull the extra area back out of flow with a symmetric negative margin
|
||||
* so the box overflows itself around its old centre instead of pushing something taller. 6px
|
||||
* was the box before this rule; -9px is (6px - 24px) / 2. This is what keeps a BARE range
|
||||
* input (no `.cbi-range-slider` wrapper, no taller sibling — a third-party app's own markup)
|
||||
* from growing its own row, the same way the checkbox's margin protects a row with no toggle
|
||||
* label beside it. Measured on its own, though, it left THIS row's growth above unchanged: the
|
||||
* line-box placement of `.cbi-range-slider` tracks the input's own edge, not the flow space the
|
||||
* margin trick frees up, so the second half below is still needed on top of it. */
|
||||
input[type="range"] {
|
||||
appearance: none;
|
||||
width: 100%; height: 24px; min-height: 0; padding: 0;
|
||||
margin-block: -9px;
|
||||
background: transparent; border: 0; border-radius: 0;
|
||||
outline: none; box-shadow: none; cursor: pointer;
|
||||
}
|
||||
input[type="range"]::-webkit-slider-runnable-track {
|
||||
width: 100%; height: 6px;
|
||||
background: var(--fs-track); border: 0; border-radius: var(--fs-radius-pill);
|
||||
}
|
||||
input[type="range"]::-moz-range-track {
|
||||
width: 100%; height: 6px;
|
||||
background: var(--fs-track); border: 0; border-radius: var(--fs-radius-pill);
|
||||
}
|
||||
input[type="range"]::-webkit-slider-thumb {
|
||||
appearance: none;
|
||||
width: 16px; height: 16px; border-radius: 50%;
|
||||
background: var(--fs-accent); border: 2px solid var(--fs-panel);
|
||||
cursor: pointer;
|
||||
/* WebKit centres the thumb on the INPUT's box, not the track: (6 - 16) / 2 = -5px pulls
|
||||
* it back onto the 6px track. Firefox centres ::-moz-range-thumb on the track itself. */
|
||||
margin-top: -5px;
|
||||
}
|
||||
input[type="range"]::-moz-range-thumb {
|
||||
width: 16px; height: 16px; border-radius: 50%;
|
||||
background: var(--fs-accent); border: 2px solid var(--fs-panel); cursor: pointer;
|
||||
}
|
||||
/* -solo: the track sets `border: 0` and `outline: none`, so there is no second channel here
|
||||
* either — the tinted ring was the whole indicator on a 6px bar. Set on the track pseudo,
|
||||
* not the input, so the ring still hugs the 6px bar rather than the 24px hit box. */
|
||||
input[type="range"]:focus::-webkit-slider-runnable-track { box-shadow: var(--fs-focus-ring-solo); }
|
||||
input[type="range"]:focus::-moz-range-track { box-shadow: var(--fs-focus-ring-solo); }
|
||||
/* THE SAME CEILING THE ELASTIC TEXT INPUTS TAKE, and the reason is the whole point of the
|
||||
* token: a `.cbi-value-field` is `flex: 1`, so `width: 100%` here meant the slider ate the
|
||||
* entire card while the select two rows above stopped at 210px and the readout chip was flung
|
||||
* to the card's right edge. Every stretching control in a form row now ends at one x.
|
||||
*
|
||||
* `vertical-align: middle` answers the second half of the 24px-target growth explained above
|
||||
* `input[type="range"]`. Default (`baseline`) places this inline-flex box in its line by the
|
||||
* edge of its first flex item — the range input — so that edge moving 6px -> 24px still pushed
|
||||
* `.cbi-value-field`'s line taller even with the margin trick already in place. `middle` places
|
||||
* the box by its own total height instead, which the margin trick already held at its old
|
||||
* 29.5px (pinned by the value chip, unaffected by the input's growth), decoupling the two.
|
||||
* Measured on the gallery slider fixture, both engines, this rule plus the margin trick against
|
||||
* HEAD: `.cbi-value-field` +0.000px in both, `.cbi-value` -0.187px (Chromium) / -0.183px
|
||||
* (Firefox) — under a fifth of a CSS px, not a pixel a screen can render differently. Box
|
||||
* unchanged at 258x24. */
|
||||
.cbi-range-slider { display: inline-flex; align-items: center; vertical-align: middle; gap: var(--fs-space-3); width: 100%; max-width: var(--fs-field-max); }
|
||||
.cbi-range-slider-value {
|
||||
background: var(--fs-panel2); border: var(--fs-hairline); border-radius: var(--fs-radius-sm);
|
||||
padding: var(--fs-space-1) var(--fs-space-2); color: var(--fs-accent); font-family: var(--fs-font-mono);
|
||||
/* NOT 600: no face is bundled, so 600 either drags a 20 KB file back in or is faked by
|
||||
* synthetic emboldening, which smears a monospace grid.
|
||||
* The chip already reads as emphatic from its surface, border and accent ink. */
|
||||
font-weight: var(--fs-weight-normal); font-size: var(--fs-type); white-space: nowrap;
|
||||
}
|
||||
.cbi-range-slider-calc, .cbi-range-slider-calc-units { color: var(--fs-dim); font-size: var(--fs-type); }
|
||||
}
|
||||
@@ -1,536 +0,0 @@
|
||||
@layer theme {
|
||||
/* Generic .dropdown-menu popup. Nothing in luci-base emits it — the split "Save & Apply" button is
|
||||
* a `.cbi-dropdown`, a different widget — so this is coverage vocabulary: stock
|
||||
* luci-theme-bootstrap styles it, so a third-party luci-app-* may emit it and expect a themed
|
||||
* result — theme/10-chrome.css claims the same class for the same reason. Not the theme's nav
|
||||
* menu, which is a plain nested <ul>.
|
||||
* Hover text is accent to match the open cbi-dropdown list: this is a form control's menu. */
|
||||
.dropdown-menu { background-color: var(--fs-panel); border-color: var(--fs-border); }
|
||||
.dropdown-menu a { color: var(--fs-text); text-shadow: none; }
|
||||
.dropdown-menu a:hover,
|
||||
.dropdown-menu a:focus-visible { background: var(--fs-panel2); background-image: none; color: var(--fs-accent); }
|
||||
|
||||
/* Split "Save & Apply": a plain dropdown in the action bar carries no frame of its own.
|
||||
*
|
||||
* The guard is the same `:not(.btn):not(.cbi-button)` the widget rules below use, and it is
|
||||
* load-bearing: the split control's outer div IS the button, and the class on it is the one
|
||||
* ui.js picked for the SELECTED mode — `cbi-button-apply`, or `cbi-button-negative` the moment
|
||||
* the user picks "Apply unchecked" (luci.js's ComboButton `classes` map). Unguarded, this rule
|
||||
* (0,2,0) erases that variant's fill while its ink survives from the variant rule that sets no
|
||||
* background: a button painted page-on-page, at 1.06-1.13:1. */
|
||||
.cbi-page-actions .cbi-dropdown:not(.btn):not(.cbi-button) {
|
||||
border: 0; border-radius: var(--fs-radius); background: transparent;
|
||||
}
|
||||
/* Apply is the one variant with no fill of its own — `.cbi-button-action` and the rest carry
|
||||
* theirs from theme/55-buttons.css, and `.cbi-button-apply` is filled only where it is THE
|
||||
* primary action, which is this bar. Painted by SPECIFICITY — it used to be a rule written
|
||||
* afterwards, i.e. a fix that depended on source order. */
|
||||
.cbi-page-actions .cbi-dropdown.cbi-button-apply,
|
||||
.cbi-page-actions .cbi-dropdown > .cbi-button {
|
||||
background: var(--fs-accent);
|
||||
background-image: none;
|
||||
border: 0;
|
||||
color: var(--fs-on-accent);
|
||||
}
|
||||
.cbi-page-actions .cbi-dropdown.cbi-button-apply:hover,
|
||||
.cbi-page-actions .cbi-dropdown > .cbi-button:hover { filter: var(--fs-hover-lift); }
|
||||
|
||||
/* ---- cbi-dropdown widget: the JS select used across all forms ----
|
||||
* Restyled to the design dropdown (panel2, rounded, chevron, focus ring) with a themed open
|
||||
* list. A native <select> is styled separately.
|
||||
*
|
||||
* The widget's MACHINERY is here too, absorbed from base whole. ui.js drives it purely through
|
||||
* attributes ([open], [multiple], [empty], [more], [display], [selected]) and the rules below
|
||||
* turn those into a working combobox. The display state machine is UNFLAGGED: upstream resolved
|
||||
* the states with !important, but flag-vs-flag falls back to specificity-then-order anyway, so
|
||||
* the machine below states the same resolution openly. The flags came in with the absorbed
|
||||
* widget from a theme with no @layer, which needed them to beat its own bare `ul` rule. */
|
||||
.cbi-dropdown {
|
||||
display: inline-flex;
|
||||
cursor: pointer;
|
||||
height: auto;
|
||||
position: relative;
|
||||
padding: 0;
|
||||
}
|
||||
.cbi-dropdown img {
|
||||
/* constrain a vector icon of any intrinsic size to the text line */
|
||||
max-height: 1.6em;
|
||||
width: auto;
|
||||
}
|
||||
.cbi-dropdown > ul {
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
list-style: none;
|
||||
overflow-x: hidden;
|
||||
overflow-y: hidden;
|
||||
display: flex;
|
||||
width: 100%;
|
||||
}
|
||||
/* clears the button's own side inset so the label starts on its text, not on its border.
|
||||
* Unflagged: (0,3,1) over the rule above's (0,1,1) — it only ever needed a flag to beat that
|
||||
* rule's flag. */
|
||||
.cbi-dropdown.btn > ul:not(.dropdown),
|
||||
.cbi-dropdown.cbi-button > ul:not(.dropdown) {
|
||||
margin: 0 0 0 var(--fs-space-3);
|
||||
}
|
||||
.cbi-dropdown.btn.spinning > ul:not(.dropdown),
|
||||
.cbi-dropdown.cbi-button.spinning > ul:not(.dropdown) {
|
||||
margin: 0;
|
||||
}
|
||||
.cbi-dropdown > ul.preview {
|
||||
display: none;
|
||||
}
|
||||
/* no `display` here: `.open` states its own below, and `.more` is display: none until the
|
||||
* [multiple][more]/[multiple][empty] showers flip it — one declaration per state, or the
|
||||
* audit's same-selector shadow check fires on this very pair */
|
||||
.cbi-dropdown > .open,
|
||||
.cbi-dropdown > .more {
|
||||
flex-grow: 0;
|
||||
flex-shrink: 0;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
text-align: center;
|
||||
}
|
||||
/* margin only: base also gave the button's chevron a .5em padding and a border-left divider,
|
||||
* but both were DEAD on arrival — the theme's `.open` rule below zeroes padding and border in
|
||||
* a later layer. A dead declaration is deleted, not relocated. */
|
||||
.cbi-dropdown.btn > .open,
|
||||
.cbi-dropdown.cbi-button > .open {
|
||||
margin-inline-start: .5em;
|
||||
}
|
||||
/* display only: the placeholder's ink is the theme's own `li[placeholder]` --fs-placeholder
|
||||
* below — the same token base/30-forms.css gives the attribute */
|
||||
.cbi-dropdown:not(.btn):not(.cbi-button) > ul > li[placeholder] {
|
||||
display: none;
|
||||
}
|
||||
.cbi-dropdown > ul > li {
|
||||
display: none;
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
/* the ellipsis above did nothing: a flex item's automatic minimum floors it at its OWN
|
||||
* content width until `min-width` says otherwise, so `overflow: hidden` never engaged and a
|
||||
* value longer than the box ran past it instead of eliding — measured at 320px, RU cut
|
||||
* mid-glyph 132px (Compact) / 225px (Normal) / 280px (Large) on https-dns-proxy, 66px on
|
||||
* nlbw/config, 70px inside the network interface-edit modal. No `title`/`aria-label` here on
|
||||
* purpose: the full string stays in the DOM and the accessibility tree, so a screen reader
|
||||
* still gets it whole — a `title` is not announced on touch, and an `aria-label` carrying the
|
||||
* SHORTENED text would violate WCAG 2.5.3 (the accessible name must contain the visible
|
||||
* text). */
|
||||
min-width: 0;
|
||||
flex-shrink: 1;
|
||||
flex-grow: 1;
|
||||
align-items: center;
|
||||
align-self: center;
|
||||
color: inherit;
|
||||
}
|
||||
.cbi-dropdown > ul > li .hide-open { display: initial; }
|
||||
.cbi-dropdown > ul > li .hide-close { display: none; }
|
||||
/* the chip divider on a BUTTON dropdown's preview; the form dropdown zeroes it below */
|
||||
.cbi-dropdown > ul > li[display]:not([display="0"]) {
|
||||
border-inline-start: var(--fs-hairline);
|
||||
}
|
||||
.cbi-dropdown[empty] > ul {
|
||||
max-width: 1px;
|
||||
}
|
||||
.cbi-dropdown > ul > li > form {
|
||||
display: none;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
pointer-events: none;
|
||||
}
|
||||
.cbi-dropdown > ul > li img {
|
||||
vertical-align: middle;
|
||||
margin-inline-end: .25em;
|
||||
}
|
||||
.cbi-dropdown > ul > li > form > input[type="checkbox"] {
|
||||
margin: 0 var(--fs-space-1) 0 0;
|
||||
}
|
||||
|
||||
/* ---- the display state machine, on specificity ----
|
||||
* Every shower out-specifies the hider it overrides: li[display] (0,2,2) over the li hider
|
||||
* (0,1,2); [open] > ul.dropdown > li (0,3,2) likewise; the placeholder rules (0,5,2 and 0,6,2)
|
||||
* over the placeholder hider (0,4,2); the form rule (0,4,3) over its hider (0,1,3). [empty]'s
|
||||
* block (0,2,2) loses to [open]'s flex (0,3,2) deliberately — an open empty list still lays out
|
||||
* as a popup — which is the resolution the old flags produced among themselves. */
|
||||
.cbi-dropdown > ul > li[display],
|
||||
.cbi-dropdown[open] > ul.preview,
|
||||
.cbi-dropdown[open] > ul.dropdown > li,
|
||||
.cbi-dropdown[multiple] > ul > li > label,
|
||||
.cbi-dropdown[multiple][open] > ul.dropdown > li,
|
||||
.cbi-dropdown[multiple][more] > .more,
|
||||
.cbi-dropdown[multiple][empty] > .more {
|
||||
flex-grow: 1;
|
||||
display: flex;
|
||||
}
|
||||
/* The one state the old flags actually carried: a closed optional single dropdown with an empty
|
||||
* value. ui.js hands the [display] attribute to the placeholder row itself, and the placeholder
|
||||
* hider (0,4,2) out-specifies the generic li[display] shower (0,2,2), so unflagged the closed
|
||||
* control renders EMPTY. `:not([open])` keeps this out of the open list, where the
|
||||
* [optional][open] rule below owns the row. */
|
||||
.cbi-dropdown:not([open]):not(.btn):not(.cbi-button) > ul > li[placeholder][display] {
|
||||
flex-grow: 1;
|
||||
display: flex;
|
||||
}
|
||||
.cbi-dropdown[empty] > ul > li,
|
||||
.cbi-dropdown[optional][open] > ul.dropdown > li[placeholder] {
|
||||
display: block;
|
||||
}
|
||||
.cbi-dropdown[multiple][open] > ul.dropdown > li > form {
|
||||
display: flex;
|
||||
}
|
||||
.cbi-dropdown[open] > ul.dropdown > li .hide-open { display: none; }
|
||||
/* `min-width` because the thing that overflows an open row is a CHILD with an inline width, which
|
||||
* wrapping the row cannot reach: form.js's RichListValue writes the description block with an
|
||||
* inline `min-width:25vw`, assuming the list grows to fit — true on a theme that leaves
|
||||
* ul.dropdown unbounded, false here (capped at min(92vw, 420px), 90-responsive.css). The inline
|
||||
* floor is a VIEWPORT fraction, so the wider the screen the worse it gets: at 2559px, 25vw is
|
||||
* 640px inside a 406px row and the row's own `overflow: hidden` cut the sentence mid-word
|
||||
* (issue #15). An author !important is the only thing that outranks an inline declaration. */
|
||||
.cbi-dropdown[open] > ul.dropdown > li .hide-close { display: initial; min-width: 0 !important; }
|
||||
.cbi-dropdown[open] > ul.dropdown > li:last-child {
|
||||
margin-bottom: 0;
|
||||
}
|
||||
.cbi-dropdown[open] > ul.dropdown > li[unselectable] {
|
||||
opacity: .7;
|
||||
}
|
||||
|
||||
.cbi-dropdown:not(.btn):not(.cbi-button) {
|
||||
background: var(--fs-panel2);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius);
|
||||
color: var(--fs-text);
|
||||
min-height: var(--fs-ctl-h);
|
||||
/* absorbed from base's generic field box with the width below. The fixed height is
|
||||
* load-bearing next to the min-height: without it a closed dropdown grows to its
|
||||
* tallest child (the Save & Apply split control carries a 40px button — measured,
|
||||
* 38 -> 42px on the gallery). */
|
||||
height: var(--fs-control-h);
|
||||
font-size: var(--fs-type);
|
||||
transition: var(--fs-field-transition);
|
||||
/* Width absorbed from base/30-forms.css, where it was grouped with .cbi-dynlist's — so the
|
||||
* theme sized the dynlist and base still sized the dropdown, two halves of the same
|
||||
* decision in two layers. Same numbers, and they are NOT the dynlist's (240/440): a
|
||||
* dropdown holds one value, a dynlist a column of them. */
|
||||
min-width: 210px;
|
||||
max-width: 400px;
|
||||
width: auto;
|
||||
/* The widget's own box. In base these two carried `!important` — not to beat an inline
|
||||
* style, but to beat base's OWN generic form-field rule, which sets `display: inline-block`
|
||||
* and `padding: 4px` on this very selector at a higher specificity (0,3,0 vs 0,1,0). A later
|
||||
* LAYER beats it for free, which is exactly what the layer split is for. */
|
||||
display: inline-flex;
|
||||
padding: 0;
|
||||
}
|
||||
/* …and the button dropdown (the Save & Apply split control), where the flag was beating the
|
||||
* theme's own `.cbi-button` padding. Specificity does it: 0,2,0 over 0,1,0. */
|
||||
.cbi-dropdown.btn, .cbi-dropdown.cbi-button { display: inline-flex; padding: 0; }
|
||||
.cbi-dropdown:not(.btn):not(.cbi-button):hover { border-color: var(--fs-dim); }
|
||||
.cbi-dropdown:focus, .cbi-dropdown[open] {
|
||||
border-color: var(--fs-accent);
|
||||
box-shadow: var(--fs-focus-ring);
|
||||
outline: none;
|
||||
}
|
||||
/* `.cbi-dropdown > ul.dropdown > li` is the same menu row on a BUTTON dropdown (the Save & Apply
|
||||
* split control), which the `:not(.btn):not(.cbi-button)` guard excludes — so that menu kept
|
||||
* base's .25em rows while every other dropdown got these. One menu, one row. */
|
||||
.cbi-dropdown:not(.btn):not(.cbi-button) > ul > li,
|
||||
.cbi-dropdown > ul.dropdown > li {
|
||||
padding: var(--fs-space-2) var(--fs-space-3); color: var(--fs-text);
|
||||
font-family: var(--fs-font-sans);
|
||||
/* one menu row: a grid step, which is what a line of text at this scale rounds to. NOT
|
||||
* `calc(--fs-type * --fs-leading)` — that is 19.5px, and a half-pixel on a BOX edge is
|
||||
* the thing the scale exists to stop. Absorbed with the machinery above. */
|
||||
min-height: var(--fs-space-5);
|
||||
}
|
||||
/* …and the row's CONTENTS, which is where that font is otherwise lost. A MULTI-select wraps every
|
||||
* item in `<form><label><input type=checkbox> text</label></form>`, and `.cbi-value-field *` in
|
||||
* theme/60-inputs.css hands mono to every descendant of a field — matching that form and label
|
||||
* directly, while the rule above only reaches the `<li>`. So the same widget draws two fonts
|
||||
* depending on one option: a single-select list sans, every multi-select list mono, in the open
|
||||
* menu and in the closed control alike.
|
||||
*
|
||||
* It is a LABEL, not a value — the distinction `<strong>` gets in theme/45-misc.css — and mono
|
||||
* spacing is what makes a wordy option list look stretched. `inherit`, not the token again: the
|
||||
* row above is the one place the menu's font is chosen. */
|
||||
.cbi-dropdown > ul > li > form,
|
||||
.cbi-dropdown > ul > li label { font-family: inherit; }
|
||||
.cbi-dropdown:not(.btn):not(.cbi-button) > ul > li[display]:not([display="0"]) { border-inline-start: 0; }
|
||||
/* The same ink the `placeholder` attribute takes in base/30-forms.css — "-- Please choose --" is
|
||||
* the absence of a value, not one.
|
||||
*
|
||||
* It repeats the row rule's two selectors instead of writing `> ul > li[placeholder]` once,
|
||||
* because that shorter form (0,2,2) LOSES to the row's own `color: var(--fs-text)` (0,3,2) and
|
||||
* the placeholder row rendered in the value's ink on every form dropdown — dead from the day it
|
||||
* was written, and only visible once `placeholder-ink` measured the row. Each selector here
|
||||
* out-specifies its counterpart above: (0,4,2) over (0,3,2), (0,3,2) over (0,2,2). */
|
||||
.cbi-dropdown:not(.btn):not(.cbi-button) > ul > li[placeholder],
|
||||
.cbi-dropdown > ul.dropdown > li[placeholder] { color: var(--fs-placeholder); }
|
||||
/* the multiselect's inline filter/create inputs — moved from base with the generic `input`
|
||||
* box in theme/60-inputs.css: in base these beat it in-layer, left behind they would lose
|
||||
* to it by layer and render as free-standing 210px fields inside the open list */
|
||||
.cbi-dropdown > ul > li input[type="text"] { height: var(--fs-space-5); }
|
||||
.cbi-dropdown[open] > ul.dropdown > li > input.create-item-input:first-child:last-child { width: 100%; }
|
||||
|
||||
/* Custom chevron in the toggle (stock text/svg arrow hidden). `.open` is the only hit target that
|
||||
* opens the list — on a button dropdown (.cbi-dropdown.btn, e.g. Diagnostics) a click anywhere
|
||||
* else RUNS the button. `font-size: 0` collapsed the stock `line-height: 2em`, so the span
|
||||
* measured 28x0 and the chevron (an absolute ::after) sat outside its own box: aiming at it hit
|
||||
* the button. Hence a real box, chevron centred in it. */
|
||||
.cbi-dropdown > .open {
|
||||
display: flex;
|
||||
font-size: 0; line-height: 0; border: 0;
|
||||
position: relative; padding: 0;
|
||||
align-self: stretch;
|
||||
min-width: var(--fs-btn-size); min-height: var(--fs-ctl-h-sm);
|
||||
align-items: center;
|
||||
cursor: pointer;
|
||||
}
|
||||
/* `.more` is the "…" a multi-value dropdown shows when its chips overflow. base wrote it in ONE
|
||||
* rule with `.open`; the theme took `.open` for the chevron above and left its twin behind, so
|
||||
* the two halves of the same toggle strip sat in different layers. Same geometry, absorbed —
|
||||
* and hidden by default here (the [multiple][more]/[multiple][empty] showers reveal it),
|
||||
* with base's muted ink. */
|
||||
.cbi-dropdown > .more { line-height: 2em; padding: 0 .3em; color: var(--fs-dim); display: none; }
|
||||
.cbi-dropdown > .open > * { display: none; }
|
||||
.cbi-dropdown > .open::after {
|
||||
content: ""; position: absolute; inset: 0; margin: auto;
|
||||
width: 7px; height: 7px;
|
||||
border-right: 2px solid var(--fs-dim); border-bottom: 2px solid var(--fs-dim);
|
||||
transform: translateY(-2px) rotate(45deg); /* optical centre of a "v" */
|
||||
}
|
||||
/* A BUTTON dropdown draws that chevron on the button's own FILL, where --fs-dim is a grey nobody
|
||||
* measured against it — on the accent-filled Save & Apply it reads as a smudge rather than an
|
||||
* arrow. currentColor takes whatever ink the variant already set, so there is no second list of
|
||||
* variants to keep in sync. The form-control dropdown keeps the muted chevron on purpose: there
|
||||
* the arrow is an affordance beside the value, not the content. */
|
||||
.cbi-dropdown.btn > .open::after,
|
||||
.cbi-dropdown.cbi-button > .open::after { border-color: currentColor; }
|
||||
|
||||
/* open list -> design popover (this was once stated four times over; these are the values
|
||||
* that were winning). */
|
||||
.cbi-dropdown[open] { z-index: var(--fs-z-dropdown); }
|
||||
.cbi-dropdown[open] > ul.dropdown {
|
||||
/* what makes it a popup at all — out of flow, stacked from the --fs-z-* scale;
|
||||
* absorbed with the machinery */
|
||||
display: block;
|
||||
position: absolute;
|
||||
z-index: var(--fs-z-dropdown);
|
||||
transition: max-height var(--fs-dur-move);
|
||||
overflow-y: auto;
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
box-shadow: var(--fs-shadow-pop);
|
||||
padding: var(--fs-space-1-5);
|
||||
/* the gap that detaches the popover from its control. It was DEAD until the `ul` margin
|
||||
* flags above came out (they out-ranked it from a lower specificity), so the list sat 1px
|
||||
* off the control — the one value that moved when they went. */
|
||||
margin-top: var(--fs-space-1-5);
|
||||
}
|
||||
.cbi-dropdown[open] > ul.dropdown > li {
|
||||
border-radius: var(--fs-radius-sm); padding: var(--fs-space-2) var(--fs-space-3);
|
||||
border-inline-start: 0; color: var(--fs-text);
|
||||
position: relative;
|
||||
/* An OPEN row wraps; only the closed preview ellipsizes. `.cbi-dropdown > ul > li` sets nowrap
|
||||
* plus ellipsis, which is right for the collapsed control — one line showing the current
|
||||
* value — and wrong for the menu: the list is capped at min(92vw, 420px), so an option
|
||||
* carrying a description runs out of box and is cut mid-word, with no ellipsis because the
|
||||
* cut falls inside a nested element (issue #15). Raising the cap instead would let one
|
||||
* verbose option decide the width of every menu on the page. */
|
||||
white-space: normal; overflow-wrap: anywhere;
|
||||
/* no border-bottom divider: on a rounded box it curls up at the corners. The straight
|
||||
* inset strip below (::after) is the divider, so the hover pill stays rounded. */
|
||||
border-bottom: 0;
|
||||
}
|
||||
.cbi-dropdown[open] > ul.dropdown > li:not(:last-child)::after {
|
||||
content: ""; position: absolute; inset-inline: 11px; bottom: 0;
|
||||
height: 1px; background: var(--fs-border);
|
||||
}
|
||||
.cbi-dropdown[open] > ul.dropdown > li:hover,
|
||||
.cbi-dropdown[open] > ul.dropdown > li.focus { background: var(--fs-panel2); color: var(--fs-accent); }
|
||||
/* After hover on purpose: hovering the selected row must still read as selected. The surface is
|
||||
* OPAQUE (--fs-panel2) and the accent is carried by the inset rail, not by a tint of itself:
|
||||
* accent text on --fs-accent-soft measures 4.21:1 in dark, under AA — the tint drags the
|
||||
* background toward the text and eats its own contrast. axe never saw it, no gallery case
|
||||
* rendering an OPEN dropdown with a chosen value. */
|
||||
.cbi-dropdown[open] > ul.dropdown > li[selected] {
|
||||
/* @mirror selected-row/paint */
|
||||
background: var(--fs-panel2); color: var(--fs-accent); box-shadow: var(--fs-row-rail);
|
||||
/* @endmirror */
|
||||
}
|
||||
/* The focused row wears the theme's ring, not the browser's: ui.js focuses a row as it opens the
|
||||
* menu, and the UA answers a programmatic focus with `outline: auto` — a system-blue capsule
|
||||
* around the top row of every dropdown that already has a value.
|
||||
*
|
||||
* Inset rather than the token's outer 3px, because the menu clips its own overflow and an outer
|
||||
* ring is cut on the first and last rows. The rail rides INSIDE this ring so a focused row that
|
||||
* is also selected keeps it — a shorthand cannot merge with the one below, so the two are listed
|
||||
* together and `--fs-row-rail` keeps that a reference rather than a third copy.
|
||||
*
|
||||
* Both selectors carry `[selected]`-level weight on purpose: the selected-row paint above is
|
||||
* (0,4,2) and a bare `li:focus-visible` would tie with it, leaving the focus ring to source
|
||||
* order. */
|
||||
.cbi-dropdown[open] > ul.dropdown > li[selected]:focus-visible,
|
||||
.cbi-dropdown[open] > ul.dropdown > li:focus-visible {
|
||||
outline: none;
|
||||
box-shadow: var(--fs-row-rail), inset 0 0 0 2px var(--fs-accent-soft);
|
||||
}
|
||||
|
||||
/* A MULTI-select row says "chosen" with its CHECKBOX, so it does not also need the rail. The rail
|
||||
* is `inset 2px 0 0` on a row with an 8px radius, so it draws as an ARC rather than a bar —
|
||||
* fine as the single-select cue it was designed for, one row at a time, and wrong down a column
|
||||
* of them, where three chosen rows read as a broken frame. The checkbox is a non-colour cue in
|
||||
* its own right, which is what WCAG 2.2 SC 1.4.1 asks of "selected"; a single-select row has
|
||||
* none and keeps the rail.
|
||||
*
|
||||
* Written as an override rather than by narrowing the paint below, because those three
|
||||
* declarations are pinned byte-identical to `select option:checked` in theme/60-inputs.css
|
||||
* (tools/mirror.mjs) — a native `<select multiple>` option has no checkbox, so the rail is still
|
||||
* the only cue there. `:not(:focus-visible)` keeps this off the focused row. */
|
||||
.cbi-dropdown[multiple][open] > ul.dropdown > li[selected]:not(:focus-visible) { box-shadow: none; }
|
||||
.cbi-dropdown[multiple][open] > ul.dropdown > li[selected]:focus-visible {
|
||||
box-shadow: inset 0 0 0 2px var(--fs-accent-soft);
|
||||
}
|
||||
|
||||
.cbi-dropdown[open] > ul.dropdown > li.create-item { border-top: var(--fs-hairline); margin-top: var(--fs-space-1); }
|
||||
/* The dropdown's "add item" field is a text input and takes the same radius as every other
|
||||
* one (theme/60-inputs.css). It said 8px here, and won or lost on source order. */
|
||||
.cbi-dropdown .create-item-input { background: var(--fs-panel2); border: var(--fs-hairline); border-radius: var(--fs-radius); color: var(--fs-text); }
|
||||
/* dropdown add-item (e.g. Community Lists) — the .cbi-dropdown styles itself, so the
|
||||
* wrapper stays transparent: no double frame. */
|
||||
.cbi-dynlist > .add-item:has(> .cbi-dropdown) {
|
||||
background: none; border: 0; overflow: visible; box-shadow: none;
|
||||
}
|
||||
|
||||
.cbi-section-table .td .cbi-dropdown,
|
||||
.cbi-section-table .td .cbi-input-select,
|
||||
.cbi-section-table .td select,
|
||||
.cbi-section-table .td input[type="text"] {
|
||||
min-width: 0;
|
||||
max-width: none;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
/* Below ~960px of available width a multi-dropdown row no longer fits, so each config row cards.
|
||||
* Same shape as the fs-dt stack (theme/30-tables.css): label above its cell, a read-only cell
|
||||
* half the row, a widget cell the whole width.
|
||||
*
|
||||
* A @container, not the measurement the data tables use, and it must stay one: these rows are
|
||||
* full of widgets that bake in a width from the layout they were rendered in, so un-collapsing
|
||||
* one to take a reading CHANGES what is read — the firewall zone table then claimed 1747px
|
||||
* where it needs 1190px. Do not "finish the job" by measuring it.
|
||||
*
|
||||
* 992, not 960: the query reads `.cbi-map` (theme/45-misc.css), one level above the `.cbi-section`
|
||||
* that actually holds the table, and never subtracts what that level spends — `--fs-card-pad` on
|
||||
* both sides, 32px at the density every page but Compact ships. Measured live (task 0163):
|
||||
* firewall/zones' `.cbi-map` sat at 968px, 936px once the section's own padding was out, and its
|
||||
* six RU headers needed 1017px — 968 cleared the un-adjusted 960px check and the table never
|
||||
* carded, clipping the header row 49-65px with no scroller anywhere near it (English's shorter
|
||||
* headers happened to fit the same 968px, which is why only RU showed it). 992 = 960 + 32 makes
|
||||
* the check ask what it always meant to: whether the SECTION's own content, not the map's, has
|
||||
* cleared 960px. */
|
||||
@container fs-content (max-width: 992px) {
|
||||
.table.cbi-section-table,
|
||||
.table.cbi-section-table .tbody,
|
||||
.table.cbi-section-table .td { display: block; width: auto; }
|
||||
/* Hide the header in BOTH markups — a card repeats every label, so the header is a duplicate that
|
||||
* only runs off the right edge. form.js wraps titles and descriptions in a `.thead`, while the
|
||||
* Lua CBI that many third-party apps still render through emits a bare
|
||||
* `tr.cbi-section-table-titles` with no .thead, which is why hiding only `.thead` left
|
||||
* luci-app-openvpn's header on screen. `.tr.table-titles` is deliberately not listed:
|
||||
* it comes from L.ui.Table, which never renders a .cbi-section-table, and is hidden by the
|
||||
* fs-dt stack in theme/30-tables.css. */
|
||||
.table.cbi-section-table .thead,
|
||||
.table.cbi-section-table .tr.cbi-section-table-titles,
|
||||
.table.cbi-section-table .tr.cbi-section-table-descr { display: none; }
|
||||
/* no align-items: flex-start — stretch keeps a pair's cells (and their separators) the
|
||||
* same height when one wraps; see the data card's .tr in theme/30-tables.css. */
|
||||
.table.cbi-section-table .tr {
|
||||
display: flex; flex-wrap: wrap; width: auto;
|
||||
border: var(--fs-hairline);
|
||||
border-radius: var(--fs-radius-lg);
|
||||
background: var(--fs-panel2);
|
||||
padding: var(--fs-space-2) var(--fs-space-3-5) var(--fs-space-3);
|
||||
margin-bottom: var(--fs-space-3);
|
||||
}
|
||||
.table.cbi-section-table .tr:hover { background: var(--fs-panel2); }
|
||||
/* `.table.cbi-section-table`, not `.cbi-section-table`: the desktop cell padding is written as
|
||||
* `.table.cbi-section-table .td` and outranks a class-lighter selector, so a plainer one here
|
||||
* silently keeps the desktop padding.
|
||||
*
|
||||
* margin: 0 is load-bearing. The Lua CBI gives a table CELL the same `.cbi-value-field` class
|
||||
* a FORM field carries, and base indents that class by 20px, so a stacked cell measures
|
||||
* 50% + 20px, two no longer fit on a line, and each pair-cell wraps to its own. */
|
||||
.table.cbi-section-table .td {
|
||||
flex: 1 1 100%; min-width: 0; margin: 0;
|
||||
padding-block: var(--fs-space-1-5); padding-inline: 0 var(--fs-space-2-5); border: 0; text-align: start;
|
||||
/* same as the data card's cells (theme/30-tables.css): a carded cell holds opaque
|
||||
* tokens (a real-length IPv6 GUA is 39 chars with no break point — colons are not
|
||||
* break opportunities), and without `anywhere` one ran 156px past a 360px viewport
|
||||
* on the Interfaces page. overflow-wrap inherits, so the inner spans get it too;
|
||||
* white-space beats the `.nowrap` class LuCI puts on some cells. */
|
||||
overflow-wrap: anywhere; white-space: normal;
|
||||
}
|
||||
/* A cell that only READS a value (dummy text, a flag, one button) is short, so two fit on a
|
||||
* line; anything with a real widget keeps the full width (the 100% basis above) — a dropdown
|
||||
* at half a phone's width is unusable. Both spellings of each widget: `CBI.DummyValue` from
|
||||
* form.js, `dvalue` from the Lua CBI's typename. */
|
||||
.table.cbi-section-table .td[data-widget="CBI.DummyValue"],
|
||||
.table.cbi-section-table .td[data-widget="CBI.FlagValue"],
|
||||
.table.cbi-section-table .td[data-widget="CBI.Button"],
|
||||
.table.cbi-section-table .td[data-widget="dvalue"],
|
||||
.table.cbi-section-table .td[data-widget="fvalue"],
|
||||
.table.cbi-section-table .td[data-widget="button"] { flex-basis: 50%; }
|
||||
/* PINNED to the data table's copy in theme/30-tables.css: the same card, needed under a CLASS
|
||||
* there (.fs-stacked, measured) and under this @container here, and CSS cannot OR the two
|
||||
* guards. tools/mirror.mjs holds the copies byte-identical — a duplicate detector goes QUIET
|
||||
* once they differ, exactly when it should shout. */
|
||||
.table.cbi-section-table .td[data-title]::before {
|
||||
/* @mirror table-card/label */
|
||||
content: attr(data-title); display: block; margin-bottom: var(--fs-space-1);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight); letter-spacing: var(--fs-eyebrow-tracking);
|
||||
color: var(--fs-eyebrow-color);
|
||||
/* @endmirror */
|
||||
}
|
||||
/* The row's buttons are not a label/value pair: full width, each button stretching to
|
||||
* share the line (Edit | Delete). PINNED — see above. (These six declarations were the
|
||||
* data table's six in a DIFFERENT ORDER, so a grep could not tell they were one rule.) */
|
||||
.table.cbi-section-table .td.cbi-section-actions {
|
||||
/* @mirror table-card/actions */
|
||||
display: flex; flex: 1 1 100%; justify-content: flex-start;
|
||||
flex-wrap: wrap; gap: var(--fs-space-2); padding-top: var(--fs-space-2);
|
||||
/* @endmirror */
|
||||
}
|
||||
.table.cbi-section-table .td.cbi-section-actions::before { content: none; }
|
||||
/* flex-wrap: LuCI groups the row's buttons in ONE inner <div>, so the td's own wrap
|
||||
* (above) never fires — the div is a single flex item. Four buttons are ~330px; on a
|
||||
* 320px phone the carded interfaces row overflowed its section by 17px. PINNED to the
|
||||
* data table's copy (theme/30-tables.css), which hit the same trap on Startup. */
|
||||
.table.cbi-section-table .td.cbi-section-actions > * {
|
||||
/* @mirror table-card/actions-inner */
|
||||
flex: 1 1 auto; display: flex; flex-wrap: wrap; gap: var(--fs-space-2);
|
||||
/* @endmirror */
|
||||
}
|
||||
.table.cbi-section-table .td .cbi-dropdown,
|
||||
.table.cbi-section-table .td select,
|
||||
.table.cbi-section-table .td input[type="text"] { width: 100%; min-width: 0; }
|
||||
.table.cbi-section-table .td .zone-forwards { width: 100%; }
|
||||
}
|
||||
|
||||
/* ---- widget popups must escape the table card ----
|
||||
* The standalone-table card (theme/30-tables.css) clips row backgrounds to its rounded corners
|
||||
* with `overflow: hidden`, but a form table also holds .cbi-dropdown widgets whose open list is
|
||||
* absolutely positioned — the clip crops it at the table's edge. So drop the clip where a widget
|
||||
* lives; the `.cbi-dropdown[open]` z-index above lifts the list over the following cards.
|
||||
*
|
||||
* Dropping it squares the frame off, though: a real <table> inherits `border-collapse: collapse`,
|
||||
* which ignores border-radius — the card's corners came from the clip, not the border. The
|
||||
* separated model restores them, and at zero spacing it lays out identically. */
|
||||
.table:has(.cbi-dropdown),
|
||||
.table:has(.cbi-dynlist) {
|
||||
overflow: visible;
|
||||
border-collapse: separate;
|
||||
border-spacing: 0;
|
||||
}
|
||||
}
|
||||
@@ -1,91 +0,0 @@
|
||||
@layer theme {
|
||||
/* base/60-modal.css draws the dialog's elevation in --fs-panel2, which in footstrap light is the
|
||||
* same hex as --fs-bg: the shadow under the top of the z-stack drawn in the exact colour of the
|
||||
* page behind it (1.00:1 light, 1.27 dark — a glow, never a shadow, panel2 being lighter than
|
||||
* the canvas). Every other floating surface in the theme takes --fs-shadow-pop. Unscoped
|
||||
* `.modal`, not `#modal_overlay .modal`: .modal is reachable outside the overlay, and the layer
|
||||
* beats base at equal specificity. */
|
||||
.modal { box-shadow: var(--fs-shadow-pop); }
|
||||
|
||||
/* The uci-changes diff takes its tints from the ladder in base (--fs-*-fill for the block,
|
||||
* --fs-*-line for its border) and nowhere else — a second set here paints the same widget at two
|
||||
* strengths depending on whether it is inside the modal, which it always is. Only geometry is
|
||||
* left here: small rounding on the diff boxes and legend swatches.
|
||||
*
|
||||
* The popup's own radius is not restated: base rounds a modal to `var(--fs-radius-lg)` with a
|
||||
* comment saying a modal is a card. */
|
||||
|
||||
/* moved from base with the heading ramp (45-misc.css): the `line-height: normal` here beat
|
||||
* the ramp's tight leading in-layer for a dialog's h4 title, and left behind it would lose
|
||||
* to the ramp by layer (measured: modal headings dropped normal -> 15.6px) */
|
||||
.modal > * {
|
||||
line-height: normal;
|
||||
margin-bottom: .5em;
|
||||
max-width: 100%;
|
||||
}
|
||||
/* an alert dropped into a dialog keeps the alert's own rhythm. In base this resolved by
|
||||
* FILE ORDER (90-widgets after 60-modal, both 0,1,0) — here it wins on specificity, so the
|
||||
* cascade no longer rests on position. */
|
||||
.modal > .alert-message { margin-bottom: var(--fs-space-2); }
|
||||
/* moved from base with the generic field box in theme/60-inputs.css: a dialog's log/output
|
||||
* textarea fills the dialog, and base's width:100% would lose to the 210px box by layer */
|
||||
.modal > pre,
|
||||
.modal > textarea {
|
||||
white-space: pre-wrap;
|
||||
overflow: auto;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
/* A config-form modal (Bridge device options, firewall rule …) is only 600px wide by
|
||||
* default — cramped for a form with a table (Bridge VLAN filtering, whose .cbi-map container
|
||||
* then falls under the 992px card threshold and cards even on a big screen). Fluid via vw:
|
||||
* widens toward 1100 on desktop (the container clears 992 and tables stay tables), stays
|
||||
* narrow (cards) on tablet/phone. */
|
||||
.modal:has(.cbi-map) { max-width: min(1100px, 94vw); }
|
||||
|
||||
/* A modal must never gain a HORIZONTAL scroll: #modal_overlay is the scroll container
|
||||
* (base/60-modal.css, `overflow: auto`) and the dialog is centred in it with `margin: auto`, so
|
||||
* one over-wide child scrolls the modal's own
|
||||
* left edge off the screen — the dialog still there, just unreachable-looking. Measured at
|
||||
* 360px: the overlay wanted 634px of scroll against 530px of room.
|
||||
*
|
||||
* Two children do it, both stock LuCI markup:
|
||||
* - `<label class="btn">` — flash.js writes each checkbox row as one, and `.btn` is
|
||||
* `white-space: pre`, which is right for a button's own label and wrong for a sentence, so
|
||||
* it cannot wrap at any width. Scoped to `label`; a real button keeps `pre`.
|
||||
* - a `<li>` carrying a checksum, one unbreakable 64-character token. */
|
||||
/* …and `overflow-wrap` with it: `white-space: normal` lets the sentence wrap at its spaces, which
|
||||
* is not enough for a label ending in a ~200px path token — in any dialog narrower than that the
|
||||
* label still runs past the box. Measured in the gallery at a 320px viewport: the label was 277px
|
||||
* inside a 264px column, 13px out.
|
||||
*
|
||||
* `min-width: 0` is the other half, and without it the wrap never fires: `.btn` is `inline-flex`,
|
||||
* so the label is a flex CONTAINER whose automatic minimum size is its content's min-content.
|
||||
*
|
||||
* `anywhere` rather than `break-word`, which follows the tier doctrine rather than contradicting
|
||||
* it (base/40-tables.css states it for cells): `break-word` leaves min-content at the widest
|
||||
* token, and the widest token here is wider
|
||||
* than the dialog at 320px, while the anonymous text flex item cannot be given a `min-width` of
|
||||
* its own. A dialog label has no card to fold into. */
|
||||
#modal_overlay .modal label.btn { white-space: normal; overflow-wrap: anywhere; min-width: 0; }
|
||||
#modal_overlay .modal li { overflow-wrap: anywhere; }
|
||||
#modal_overlay .uci-dialog div > ins,
|
||||
#modal_overlay .uci-dialog div > del,
|
||||
#modal_overlay .uci-dialog div > var { border-radius: var(--fs-radius-sm); }
|
||||
#modal_overlay .uci-change-legend-label > ins,
|
||||
#modal_overlay .uci-change-legend-label > del,
|
||||
/* same token as the diff blocks above — a literal 4px sat outside the Rounding axis */
|
||||
#modal_overlay .uci-change-legend-label > var { border-radius: var(--fs-radius-sm); overflow: hidden; }
|
||||
|
||||
/* A changed option is `<var><ins>uci set …</ins></var>`: the outer plate is rounded above and the
|
||||
* coloured fill is the child, and `overflow: hidden` does not round it, because the child never
|
||||
* reaches the corner it would be clipped at — the parent holds it 3px in (1px border plus 2px
|
||||
* padding). So the plate has rounded corners with a square block inside them, and the legend's
|
||||
* swatches are squares inside circles (issue #14). The child takes the parent's radius minus
|
||||
* that inset, which makes the two curves concentric; `max()` keeps it at 0 rather than negative
|
||||
* when Rounding is turned down. */
|
||||
#modal_overlay .uci-dialog var > ins,
|
||||
#modal_overlay .uci-dialog var > del {
|
||||
border-radius: max(0px, calc(var(--fs-radius-sm) - 3px));
|
||||
}
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
@layer theme {
|
||||
/* ==================================================================
|
||||
* The page-search palette. Markup is built by fs-search.js and parented to <body>:
|
||||
* the vertical .fs-sidebar is `overflow: auto`, which would clip a child of the trigger,
|
||||
* and the overlay has to cover the whole viewport anyway.
|
||||
* ================================================================== */
|
||||
|
||||
/* The scrim. --fs-scrim is the theme's one colour literal (plain black at .7) on purpose:
|
||||
* it is the absence of light behind a dialog, not a tint of any palette token. */
|
||||
.fs-search-ov {
|
||||
position: fixed; inset: 0; z-index: var(--fs-z-popover);
|
||||
/* `display` here is what the `hidden` attribute has to beat — base/10-reset.css does that for
|
||||
* every element now, so this file no longer restates it for the overlay alone. */
|
||||
display: flex; justify-content: center;
|
||||
/* not centred vertically: the box grows DOWNWARD as results come in, and a centred one
|
||||
* would slide the input out from under the user's eyes on every keystroke */
|
||||
align-items: flex-start;
|
||||
padding: max(8vh, var(--fs-space-6)) var(--fs-space-4) var(--fs-space-4);
|
||||
background: var(--fs-scrim);
|
||||
animation: fs-fade var(--fs-dur-fade);
|
||||
}
|
||||
|
||||
/* The dialog itself. It is a SCROLL CONTAINER, and that is not decoration: without a cap the
|
||||
* box grows past a short viewport (a phone in landscape is ~380px tall) and the rows at the
|
||||
* bottom become unreachable — a `position: fixed` popup cannot be scrolled by the page. */
|
||||
.fs-search-box {
|
||||
display: flex; flex-direction: column; min-height: 0;
|
||||
width: 100%; max-width: 560px; max-height: min(70dvh, 560px);
|
||||
background: var(--fs-panel);
|
||||
border: var(--fs-hairline); border-radius: var(--fs-radius-lg);
|
||||
box-shadow: var(--fs-shadow-pop);
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.fs-search-row {
|
||||
display: flex; align-items: center; gap: var(--fs-space-2-5); flex: 0 0 auto;
|
||||
padding: var(--fs-space-3) var(--fs-space-3-5);
|
||||
border-bottom: var(--fs-hairline);
|
||||
}
|
||||
.fs-search-ico { display: inline-flex; color: var(--fs-faint); }
|
||||
.fs-search-ico .fs-ico { width: 18px; height: 18px; }
|
||||
/* The input carries no frame of its own — the ROW is the field and the box around it is the
|
||||
* dialog. Two classes (0,2,0) on purpose: the generic field box in 60-inputs.css is
|
||||
* `input[type="text"], …` (0,1,1) and outranks a single class in the same layer whatever the
|
||||
* source order — measured, it painted this input with the page-field border, the panel2 fill,
|
||||
* 8px/11px of padding and a focus ring inside the dialog's own frame.
|
||||
*
|
||||
* 16px rather than the theme's body size, deliberately: a font-size below 16px makes iOS Safari
|
||||
* zoom the page when the field takes focus, and this one takes focus as the palette opens. */
|
||||
.fs-search-row .fs-search-input {
|
||||
flex: 1 1 auto; min-width: 0;
|
||||
margin: 0; padding: 0; border: 0; min-height: 0; background: transparent;
|
||||
color: var(--fs-text);
|
||||
font-family: inherit; font-size: var(--fs-type-lg); font-weight: var(--fs-weight); line-height: 1.4;
|
||||
}
|
||||
.fs-search-row .fs-search-input:focus { outline: none; box-shadow: none; }
|
||||
/* one placeholder ink for the whole theme (03-palettes.css) — this row is not measured by
|
||||
* `placeholder-ink`, the gallery having no search dialog, and must not drift from the fields
|
||||
* that are */
|
||||
.fs-search-row .fs-search-input::placeholder { color: var(--fs-placeholder); font-weight: var(--fs-weight); }
|
||||
|
||||
.fs-search-list { flex: 1 1 auto; min-height: 0; overflow-y: auto; padding: var(--fs-space-1-5); }
|
||||
|
||||
.fs-search-opt {
|
||||
display: flex; align-items: baseline; gap: var(--fs-space-2-5);
|
||||
padding: var(--fs-space-2) var(--fs-space-2-5); border-radius: var(--fs-radius);
|
||||
color: var(--fs-text); text-decoration: none; cursor: pointer;
|
||||
}
|
||||
/* One highlight for both pointer and keyboard: `.active` is set by fs-search.js for the
|
||||
* aria-activedescendant row AND on pointermove, so the mouse and the arrow keys can never
|
||||
* disagree about which row Enter would open. */
|
||||
.fs-search-opt.active { background: var(--fs-accent-soft); color: var(--fs-accent); }
|
||||
.fs-search-opt-title { flex: 0 1 auto; font-weight: var(--fs-weight-bold); font-size: var(--fs-type); }
|
||||
/* the breadcrumb: which section owns the page — the whole point of searching for it */
|
||||
.fs-search-opt-path {
|
||||
flex: 1 1 auto; min-width: 0;
|
||||
color: var(--fs-faint); font-size: var(--fs-type); text-align: end;
|
||||
overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
|
||||
}
|
||||
.fs-search-opt.active .fs-search-opt-path { color: inherit; }
|
||||
|
||||
/* "Recently visited" — the caption over the rows */
|
||||
.fs-search-note {
|
||||
flex: 0 0 auto;
|
||||
padding: var(--fs-space-2-5) var(--fs-space-3-5) var(--fs-space-0-5);
|
||||
color: var(--fs-eyebrow-color);
|
||||
font-size: var(--fs-type-xs); font-weight: var(--fs-eyebrow-weight); letter-spacing: var(--fs-eyebrow-tracking); text-transform: uppercase;
|
||||
}
|
||||
|
||||
/* …and the box's EMPTY STATE when there are no rows at all ("No pages found"), which reads as
|
||||
* a sentence, not as an eyebrow label. :has() rather than a sibling combinator: the note sits
|
||||
* ABOVE the list it describes, so `+` cannot reach back to it. */
|
||||
.fs-search-box:has(.fs-search-list:empty) .fs-search-note {
|
||||
padding: var(--fs-space-6) var(--fs-space-3-5) var(--fs-space-7);
|
||||
text-align: center; text-transform: none; letter-spacing: 0;
|
||||
font-size: var(--fs-type); font-weight: var(--fs-weight);
|
||||
}
|
||||
}
|
||||
@@ -1,198 +0,0 @@
|
||||
@layer theme {
|
||||
/* Phone overflow safety net (<=767px). .fs-main uses overflow-x: clip, so anything wider than the
|
||||
* viewport is silently CUT on the right rather than scrolled to. A device sweep found the
|
||||
* offenders below; each fix lets the control or table shrink or wrap. Tablets were already
|
||||
* clean. */
|
||||
/* A pair of buttons an app packs into one `inline-flex` must be allowed to wrap its labels.
|
||||
*
|
||||
* `white-space: pre` on a button is stock — luci-theme-bootstrap sets it too — and it holds
|
||||
* while the label is short. Ours are wider than stock at the same job: measured on
|
||||
* ssclash's split button at 320, `Сохранить и перезагрузить конфигурацию` is 295px against
|
||||
* stock's 245, because this theme's face is wider than the system stack even at a smaller
|
||||
* size (13px vs 14px), and the 14px side padding adds 12 of the 50. The app's wrapper is
|
||||
* `inline-flex`, so it takes the buttons' max-content — 324px inside a 288px column — and
|
||||
* overflows by 36. Stock fits only because its buttons are narrower.
|
||||
*
|
||||
* Narrowing the buttons would be re-typesetting the theme to suit one app. Letting the label
|
||||
* wrap costs nothing where it already fits — a short label has no wrap point — and turns the
|
||||
* one case that does not into two lines. Scoped to the width where it happens: at 390 the
|
||||
* same page is clean.
|
||||
*
|
||||
* `min-width: 0` with it, or the automatic minimum keeps the button at its longest word and
|
||||
* the flex line cannot shrink it at all.
|
||||
*
|
||||
* `word-break: normal` is the third half of it. base/10-reset.css gives every button
|
||||
* `break-all` — carried over from the fork, and inert while the label cannot wrap at all. The
|
||||
* moment it can, `break-all` takes precedence over word boundaries and the label breaks mid-word
|
||||
* (`Сохранить и перезагрузить ко` / `нфиг`). `overflow-wrap: break-word` keeps the escape hatch
|
||||
* for a single word wider than the button, which is what `break-all` was there for. */
|
||||
@container fs-view (max-width: 360px) {
|
||||
#view .cbi-button, #view .btn,
|
||||
#view input[type="button"], #view input[type="submit"], #view input[type="reset"] {
|
||||
white-space: normal;
|
||||
min-width: 0;
|
||||
word-break: normal;
|
||||
overflow-wrap: break-word;
|
||||
}
|
||||
}
|
||||
|
||||
@media (max-width: 767px) {
|
||||
/* The foreign-<table> scroll fallback used to live here, guarded by this query. It does not
|
||||
* any more: whether a table fits is a property of its CONTENT and its COLUMN, never of the
|
||||
* viewport — the same argument the fit engine is built on — and a 400px-wide panel on a
|
||||
* 1600px desktop needs it exactly as much as a phone does. It is unguarded now, in
|
||||
* theme/30-tables.css, next to the card stack it is the fallback FOR. */
|
||||
|
||||
/* Must stay INSIDE this @media, for specificity within one layer: the 400px cap lives in
|
||||
* theme/65-dropdown.css on `.cbi-dropdown:not(.btn):not(.cbi-button)` — (0,3,0) against this
|
||||
* rule's (0,1,0) — so unscoped this would lose to it everywhere and cap nothing. Inside the
|
||||
* phone tier it is what the narrow width needs: a dropdown must never exceed its field. */
|
||||
.cbi-dropdown { min-width: 0; max-width: 100%; }
|
||||
|
||||
/* Software page: stack each labelled control. base gives its labels a min-width: 250px that
|
||||
* overflows a ~360px screen, and `.controls` is a flex ROW, so its columns cram side by side
|
||||
* and overlap. Scoped by data-page, not by an id: on 24.10 the "Disk space:" label ships with
|
||||
* no id, so a `:has()` scope silently misses the whole page there. !important because
|
||||
* package-manager.js injects an unlayered inline style block, which outranks every layer.
|
||||
* Scoped by `#view[data-page]`, not `body[data-page]`: the attribute lives on the view
|
||||
* itself so the outgoing page keeps its own rules for the whole staging window (fs-router.js,
|
||||
* commitStage) — the same bug and the same fix as styles/pages/30-software.css, discovered
|
||||
* here separately because this narrow-viewport tier is invisible to a gate run at desktop
|
||||
* width (tools/spa-parity.mjs's narrow-viewport pass).
|
||||
* `:where(#view)`, not bare `#view`: zeroes the id's specificity while matching the exact
|
||||
* same element — 20-overview.css, top of `@layer page`, has the full reasoning and the
|
||||
* measured numbers. */
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls { display: block !important; }
|
||||
/* `:not(.pager)` — the page reuses `.controls` for the « / "Displaying 1-100 of 7677" / »
|
||||
* pager, and its .pager is a <div> too. Blocking it stacked those three onto three lines
|
||||
* (reported). Only the LABELLED control groups want stacking; the pager is a row. */
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls > div:not(.pager) { display: block !important; min-width: 0; margin-bottom: var(--fs-space-2); }
|
||||
/* …and the pager itself: a centred row that stays one. `.text` is the only part that may
|
||||
* give way, so the two buttons keep their size instead of being squeezed. */
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls > .pager {
|
||||
display: flex; flex-wrap: nowrap; align-items: center; justify-content: center; gap: var(--fs-space-2);
|
||||
}
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls > .pager > .btn { flex: 0 0 auto; }
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls > .pager > .text { flex: 0 1 auto; min-width: 0; }
|
||||
/* the bar's ::after value ("63% used …") normally floats above the bar, but the "Disk
|
||||
* space:" label already sits there — on a phone the long value text overlapped label +
|
||||
* bar. Drop it BELOW. The bar is a fixed 10px box, so a static ::after cannot push the
|
||||
* next control: reserve space with margin-bottom and place the value absolutely in it.
|
||||
* The disk section is the only `label` immediately followed by a `.cbi-progressbar`. */
|
||||
:where(#view)[data-page="admin-system-package-manager"] label + .cbi-progressbar {
|
||||
width: 100%; margin-bottom: 3em;
|
||||
}
|
||||
:where(#view)[data-page="admin-system-package-manager"] label + .cbi-progressbar::after {
|
||||
top: calc(100% + 5px); inset-inline: 0 auto; bottom: auto;
|
||||
text-align: start; white-space: normal; max-width: 100%;
|
||||
}
|
||||
/* `> div > label` — the group's TITLE label ("Filter:", "Actions:", "Display LuCI
|
||||
* translation packages:"), not every label on the page. Written as plain `.controls label`
|
||||
* it also blocked the three radio labels nested a level deeper, and `filtered / all / none`
|
||||
* came out one per line. They are a set of three short choices: they belong on one row. */
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls > div > label { display: block; min-width: 0; white-space: normal; margin-bottom: var(--fs-space-1); }
|
||||
/* …and the row they sit in. Stock separates them with text nodes, which is enough to
|
||||
* keep them apart but not to keep them from splitting mid-choice — a flex row with a real
|
||||
* gap wraps between labels instead of inside one. */
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls > div > div:has(> label > input[type="radio"]) {
|
||||
display: flex; flex-wrap: wrap; align-items: center; gap: var(--fs-space-1) var(--fs-space-5);
|
||||
}
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls .control-group { display: flex; flex-wrap: wrap; min-width: 0; gap: var(--fs-space-2); }
|
||||
:where(#view)[data-page="admin-system-package-manager"] .controls .control-group input { flex: 1 1 140px; min-width: 0; max-width: 100%; }
|
||||
|
||||
/* The Diagnostics stack is not here: a page name and a viewport are neither of the facts that
|
||||
* matter. Any app can put a field, a select and a button in one header-less
|
||||
* `<div class="table">`, and what decides whether that row fits is the ROOM — at 320px the
|
||||
* row needs 338px, and inside a narrow panel at 900px of viewport it needs the same.
|
||||
* fs-select.js writes `.fs-rowstack` on any such table that overflows, at any width, and
|
||||
* theme/30-tables.css carries the declarations. */
|
||||
|
||||
/* No `table.fs-dt { display: block; width: 100% }` here — it sat here to stop a data table
|
||||
* that still fitted as a table from exceeding its column, and its absence is what makes the
|
||||
* measured design work at phone widths at all: `display: block` on a <table> DISCARDS the
|
||||
* table formatting
|
||||
* context, so the rows are wrapped in an anonymous table sized to the block and the table can
|
||||
* never be wider than its parent — which means it can never overflow, which means
|
||||
* `fit.overflows()` can never see anything below 767px. Measured on Processes at 720px with
|
||||
* such a rule in place: the Command column sat at 126px against a widest token of 353px, and
|
||||
* forcing that column's `overflow-wrap` three different ways produced the same 126px and the
|
||||
* same "the table fits" every time. */
|
||||
|
||||
/* generic caps: an input/select must never exceed its field, and long key/value strings
|
||||
* in the Overview cards must break. */
|
||||
.cbi-value-field input, .cbi-value-field select, .cbi-value-field .cbi-dropdown { max-width: 100%; }
|
||||
/* …and once the label is on its own line the control takes the line it was given — a
|
||||
* field sized to its content left half the row empty and made the form read as a ragged
|
||||
* column (stock does the same on a phone). checkbox/radio/file keep their intrinsic size:
|
||||
* a full-width checkbox is a hit target the size of the screen. */
|
||||
.cbi-value-field select,
|
||||
.cbi-value-field input:not([type="checkbox"]):not([type="radio"]):not([type="file"]),
|
||||
.cbi-value-field .cbi-dropdown:not(.btn):not(.cbi-button),
|
||||
.cbi-value-field .cbi-dynlist,
|
||||
.cbi-value-field .cbi-select { width: 100%; }
|
||||
/* min-width only: breaking a long value is base/40-tables.css's default for every cell now,
|
||||
* and this copy moved nothing when switched off against 126 matching cells. `min-width: 0` is
|
||||
* NOT redundant — switching that off moved 12 — so it stays. */
|
||||
#view .fs-ovl .table .td, #view .fs-ovl .table .th { min-width: 0; }
|
||||
|
||||
/* Stack each field: label on its own line, control and description full-width below. Side by side
|
||||
* on the desktop squeezes the field — and any .cbi-value-description inside it — into a
|
||||
* ~120px column on a phone, so one sentence of help wraps to 8 lines. The row already
|
||||
* flex-wraps; these two full-width children are what stack it.
|
||||
*
|
||||
* Not scoped to #view, and that is the point: ui.js appends a modal to <body>, so an
|
||||
* `#view .cbi-value` rule leaves every DIALOG in the desktop layout and on a phone the
|
||||
* Edit-interface form pushes its inputs past the dialog's right edge. */
|
||||
/* `start` undoes base's `text-align: end` (the label hugs its field when the two share a
|
||||
* row); stacked, it goes back to the reading edge. Logical for the same reason base's is. */
|
||||
.cbi-value > .cbi-value-title { flex: 1 1 100%; text-align: start; padding-top: 0; }
|
||||
.cbi-value > .cbi-value-field { flex: 1 1 100%; min-width: 0; }
|
||||
|
||||
/* The stock phone contract every luci-app-* is written against. These classes are emitted by
|
||||
* LuCI's own JS and by third-party apps that copied them, and they are styled nowhere but
|
||||
* bootstrap's mobile.css — so a theme that ignores them renders a phone layout its own app JS
|
||||
* believes it has already handled. */
|
||||
/* A column the emitting JS asks to DROP on a phone: the wireless Associated Stations table marks
|
||||
* its MAC column .hide-xs, and stock LuCI shows Network/Host/Signal/Rate and no MAC.
|
||||
*
|
||||
* The `.table .td.hide-xs` half is not redundant: the stacking rules select the cell as
|
||||
* `table.fs-dt .td` (0,2,1) and `.cbi-section-table .td` (0,2,0), both outranking a bare
|
||||
* `.hide-xs` (0,1,0), so the cell keeps their
|
||||
* `display: block` and stays visible. Stock LuCI wins this with !important; one class more
|
||||
* wins it without one. */
|
||||
.hide-sm, .hide-xs,
|
||||
.table .td.hide-sm, .table .td.hide-xs,
|
||||
.table .th.hide-sm, .table .th.hide-xs { display: none; }
|
||||
/* The `.col-N` weights used to live here, inside the phone tier. They are UNGUARDED now,
|
||||
* in theme/30-tables.css: `flex` is inert on anything that is not a flex item, and a `.td`
|
||||
* becomes one exactly when its table cards — so one copy covers the phone tier, the
|
||||
* measured stack at any width and the config table's @container, with no second copy to
|
||||
* keep in step. See the block there. */
|
||||
|
||||
/* iOS Safari zooms the page in when a focused control's text is under 16px and never zooms
|
||||
* back out — the theme's 13px inputs did that on every form. Stock LuCI needs !important
|
||||
* for it; here the theme layer is enough. */
|
||||
input, textarea, select, .cbi-dropdown > ul > li { font-size: var(--fs-type-lg); }
|
||||
}
|
||||
|
||||
/* Dropdown list: anchored to its widget, never full-bleed.
|
||||
*
|
||||
* ui.js has a touch branch (`'ontouchstart' in window`) that stretches the open list across the
|
||||
* viewport with INLINE offsets — `ul.style.left = ${-rect.left}px`, `ul.style.right =
|
||||
* ${rect.right - vpWidth}px` — which assume the list's containing block is the
|
||||
* viewport. It is not: .cbi-dropdown is position: relative, so a negative `left` drags the list
|
||||
* off to the side and clips the labels. An author !important is the only thing that outranks an
|
||||
* inline declaration, so pin it back under the widget. Harmless on desktop, where ui.js sets
|
||||
* only top/bottom/max-height.
|
||||
*
|
||||
* Only left/right carry the flag — those are the two properties ui.js writes inline. The widths
|
||||
* never appear in an inline style (ui.js only CLEARS `ul.style.width`, on close), so they win
|
||||
* from this layer on their own. */
|
||||
.cbi-dropdown[open] > ul.dropdown {
|
||||
inset-inline-start: 0 !important;
|
||||
inset-inline-end: auto !important;
|
||||
min-width: 100%;
|
||||
width: max-content;
|
||||
max-width: min(92vw, 420px);
|
||||
}
|
||||
}
|
||||
@@ -1,137 +0,0 @@
|
||||
@layer theme {
|
||||
/* prefers-reduced-motion — a medical accommodation: vestibular disorders make sliding, fading and
|
||||
* spinning UI genuinely nauseating. Honoured globally rather than per component; every
|
||||
* transition and keyframe in this theme is decoration and none carries information.
|
||||
*
|
||||
* The !important here is the documented exception, and not the same kind as the ones that fight
|
||||
* an inline `style=`: a cascade layer cannot help, since styles/base sets transitions too and
|
||||
* !important INVERTS the layer order, so only an important declaration reaches all of them at
|
||||
* once. This is the canonical form as published by the WCAG working group. DO NOT COPY THE FLAG
|
||||
* OUT OF THIS BLOCK.
|
||||
*
|
||||
* .01ms rather than 0s: a zero duration means `transitionend`/`animationend` never fire, and JS
|
||||
* that waits for one (LuCI's modal teardown does) would hang. `scroll-behavior` is on the list
|
||||
* because smooth scrolling is motion too, and a jump is what this user asked for. */
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
*, *::before, *::after {
|
||||
animation-duration: .01ms !important;
|
||||
animation-iteration-count: 1 !important;
|
||||
transition-duration: .01ms !important;
|
||||
scroll-behavior: auto !important;
|
||||
}
|
||||
}
|
||||
|
||||
/* prefers-reduced-transparency — the user asked the OS for opaque surfaces. Every surface in the
|
||||
* theme is opaque already: no blur, an opaque bar, opaque pop surfaces. The one thing left is the
|
||||
* wash over an uploaded photo. */
|
||||
@media (prefers-reduced-transparency: reduce) {
|
||||
:root {
|
||||
/* the uploaded background is a translucent wash over a photo — exactly the effect this
|
||||
* user asked the OS to drop. Make the scrim opaque so the canvas is flat, not a photo
|
||||
* ghosting through (16-login-bg.css lays it over the image as one background layer). */
|
||||
--fs-photo-scrim: var(--fs-bg);
|
||||
}
|
||||
}
|
||||
|
||||
/* prefers-contrast — the user asked the OS for MORE contrast but, unlike forced-colors, left the
|
||||
* palette to us. Same mechanism as reduced-transparency: re-state the tokens and every rule that
|
||||
* reads them follows. What moves and why:
|
||||
* - the hairlines: --fs-border is the most-read line in the theme and sits at ~20% of the
|
||||
* text's contrast, so it is pulled toward --fs-text. The role hairlines (-line/-line-hi, a
|
||||
* 40/55% tint of their role) go to the FULL role colour — a tint exists to be quiet, which
|
||||
* is the opposite of what this user asked for.
|
||||
* - secondary text: --fs-dim toward --fs-text, and --fs-faint most of the way there too
|
||||
* (10-11px eyebrow labels are where AA erodes first). Not all the way ONTO --fs-dim: the two
|
||||
* are the export tier's --text-color-medium and -low, so collapsing them republishes one
|
||||
* colour twice to every app reading the gradation. 82% is a window tools/export-tier.mjs
|
||||
* measures rather than takes on trust: below 80 the fainter ink drops under AA on footstrap
|
||||
* dark's --fs-panel2 (4.51:1 at 80), above 82 the high-to-low ramp falls under the 0.10
|
||||
* spread the tier promises (0.098 at 84); 82 clears both, at 4.68:1 and 0.110.
|
||||
* - --fs-placeholder, in BOTH modes. It is the one token the theme ships deliberately under AA
|
||||
* (3.99-4.48:1 light, 3.43-6.05:1 dark): a hint has to move far enough not to read as a
|
||||
* typed value, and a dark palette has only 6.45:1 of ink to spend. A reader who asked the OS
|
||||
* for more contrast has said which of the two they want, so the mixes go back to the
|
||||
* AA-clearing 62% and 80% — 4.98:1 and 4.61:1, at 37% and 20% of the ink-to-field range
|
||||
* instead of 44% and 34%. Only --fs-placeholder-mix moves: the mix itself is spelt once, in
|
||||
* 03-palettes.css. `placeholder-ink` measures this pass as well.
|
||||
* - the focus ring: --fs-focus-ring is a tint of the accent (--fs-accent-soft, 10% light and
|
||||
* 15% dark), so at "more contrast" it carries the accent at 60% instead. Its sibling
|
||||
* --fs-focus-ring-solo is already the solid accent and needs no restatement here. */
|
||||
@media (prefers-contrast: more) {
|
||||
:root {
|
||||
--fs-border: color-mix(in srgb, var(--fs-text) 45%, var(--fs-bg));
|
||||
--fs-dim: color-mix(in srgb, var(--fs-text) 85%, var(--fs-bg));
|
||||
--fs-faint: color-mix(in srgb, var(--fs-text) 82%, var(--fs-bg));
|
||||
--fs-focus-ring: 0 0 0 3px color-mix(in srgb, var(--fs-accent) 60%, transparent);
|
||||
--fs-accent-line: var(--fs-accent); --fs-accent-line-hi: var(--fs-accent);
|
||||
--fs-good-line: var(--fs-good); --fs-good-line-hi: var(--fs-good);
|
||||
--fs-warn-line: var(--fs-warn); --fs-warn-line-hi: var(--fs-warn);
|
||||
--fs-danger-line: var(--fs-danger); --fs-danger-line-hi: var(--fs-danger);
|
||||
/* the placeholder is the one token shipped under AA (see the note above); this reader
|
||||
* asked for contrast, so both modes buy the AA ink back, at the percentages that clear
|
||||
* it. Light here, dark in the block below — per mode exactly as in 03-palettes.css. */
|
||||
--fs-placeholder-mix: 62%;
|
||||
}
|
||||
:root[data-darkmode="true"] { --fs-placeholder-mix: 80%; }
|
||||
}
|
||||
|
||||
/* forced-colors (Windows High Contrast) — the OS replaces every colour the theme picked, and
|
||||
* background-color on most elements is forced to the system canvas, so any state carried by
|
||||
* BACKGROUND alone vanishes: the active tab pill, the checked toggle and the selected dropdown
|
||||
* row all look exactly like their inactive siblings, which is a correctness bug rather than a
|
||||
* cosmetic one. Re-state those states with a border or outline, which forced-colors keeps, in
|
||||
* system colour keywords so they follow the user's scheme. */
|
||||
@media (forced-colors: active) {
|
||||
/* Active tab, selected dropdown row, checked toggle: outline the state.
|
||||
*
|
||||
* `.ifacebox-head.active` and Apply join the list rather than getting a rule of their own,
|
||||
* being the same KIND of state — carried by a background, with no word to fall back on — and
|
||||
* the same repair. "This port is up" was indistinguishable from a dead port, and Save & Apply
|
||||
* did not read as a BUTTON at all: it is a .cbi-dropdown wrapper, so with its fill forced to
|
||||
* Canvas only the label inside the <li> kept a highlight.
|
||||
*
|
||||
* Not extended to the alert and .label variants: encoding severity in border-style is not a
|
||||
* scale anyone can learn, and the honest repair is a word or an icon in the markup, which is
|
||||
* ui.js's. */
|
||||
#tabmenu ul.tabs > li.active > a,
|
||||
ul.cbi-tabmenu.mode > li.cbi-tab > a,
|
||||
.tabs > li.active > a,
|
||||
.cbi-tabmenu > li.cbi-tab > a,
|
||||
.cbi-dropdown > ul > li[selected],
|
||||
.ifacebox .ifacebox-head.active,
|
||||
.cbi-page-actions .cbi-button-apply {
|
||||
outline: 2px solid Highlight;
|
||||
outline-offset: -2px;
|
||||
color: HighlightText;
|
||||
background: Highlight;
|
||||
forced-color-adjust: none; /* keep the fill: it IS the state */
|
||||
}
|
||||
/* Which page am I on: the menu's active item carries its state in exactly the two things forced
|
||||
* colors drops, a 10%-alpha accent background and the box-shadow rail. Measured with the query
|
||||
* emulated, all twelve #topmenu links reported the same weight, shadow, border and colour, so
|
||||
* the current page was not marked at all. `aria-current="page"` is on the link, so this was a
|
||||
* sighted-user loss only. The rail comes back as a real border, which forced colors keeps. */
|
||||
#topmenu li.active > a {
|
||||
border-inline-start: 3px solid Highlight;
|
||||
padding-inline-start: calc(var(--fs-space-3) - 3px);
|
||||
}
|
||||
/* the toggle switch is a bare rounded box in forced colors — give the knob and
|
||||
* the track an edge so on/off is distinguishable at all. Scoped via `input[type="checkbox"]`,
|
||||
* matching 60-inputs.css, which now draws the switch there: an `<input>` selector cannot
|
||||
* reach ui.Checkbox's `tooltip` label (the hint-icon one, unstyled otherwise, built with no
|
||||
* `for` attribute) by construction, so the old `[for]` discriminator is no longer needed to
|
||||
* keep that label from growing a border it does not own. */
|
||||
.cbi-checkbox > input[type="checkbox"] { border: 1px solid ButtonBorder; }
|
||||
.cbi-checkbox > input[type="checkbox"]:checked {
|
||||
background: Highlight;
|
||||
forced-color-adjust: none;
|
||||
}
|
||||
.cbi-checkbox > input[type="checkbox"]::after { background: ButtonBorder; }
|
||||
.cbi-checkbox > input[type="checkbox"]:checked::after { background: HighlightText; }
|
||||
/* icon-only buttons (rail toggle, search/appearance, logout) lose their hover fill */
|
||||
.fs-railtoggle, .fs-themerow { border-color: ButtonBorder; }
|
||||
/* the focus ring is a box-shadow everywhere in this theme, and box-shadow is
|
||||
* dropped entirely in forced-colors — so keyboard focus would be invisible */
|
||||
:focus-visible { outline: 2px solid Highlight; outline-offset: 1px; }
|
||||
}
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
@layer theme {
|
||||
/* ---- print ----
|
||||
* A LuCI page ends up on paper or in a PDF as documentation, and without this block it prints
|
||||
* the dark chrome, the sticky bar and — in the sidebar layout — ONE page, the shell being
|
||||
* height:100svh with overflow:hidden there.
|
||||
*
|
||||
* No `!important`: tools/audit.py allows the flag only in its listed files, and nothing here
|
||||
* fights an inline style. Where a rule must beat a same-layer
|
||||
* chrome rule it wins on SPECIFICITY — a repeated class at (0,4,0), one step over the layout
|
||||
* guards' (0,3,1) — never on this file sorting after 20-shell.css. */
|
||||
@media print {
|
||||
/* Ink-friendly surfaces whatever palette/mode is active: this block sits in the
|
||||
* theme layer, so it outranks every tokens-layer palette block without naming
|
||||
* data-darkmode or the palettes. Every rule reads the tokens, so one re-statement
|
||||
* re-paints the whole page. */
|
||||
:root {
|
||||
--fs-bg: #fff; --fs-panel: #fff; --fs-panel2: #f4f4f4;
|
||||
--fs-text: #000; --fs-dim: #333; --fs-faint: #555;
|
||||
--fs-border: #bbb; --fs-track: #ddd;
|
||||
--fs-shadow-pop: none;
|
||||
--fs-bar-bg: #fff;
|
||||
}
|
||||
/* Navigation, the search overlay and the action buttons cannot be used on paper. The
|
||||
* Appearance popover was on this list; it is a PAGE now, and a page prints — an admin
|
||||
* printing System -> Appearance wants what is on it. */
|
||||
.fs-sidebar.fs-sidebar.fs-sidebar.fs-sidebar,
|
||||
.fs-skip.fs-skip,
|
||||
.fs-search-ov.fs-search-ov,
|
||||
.cbi-page-actions.cbi-page-actions,
|
||||
.cbi-tabmenu.cbi-tabmenu,
|
||||
footer { display: none; }
|
||||
/* Undo the sidebar layout's scroll frame — the ONE-page bug above. */
|
||||
.fs-shell.fs-shell.fs-shell.fs-shell { height: auto; overflow: visible; }
|
||||
.fs-main.fs-main.fs-main.fs-main { height: auto; overflow: visible; }
|
||||
.fs-content.fs-content { max-width: none; padding: 0; }
|
||||
/* same element as 15-wallpaper.css, later in the layer — the pattern stays off the paper */
|
||||
.fs-pattern.fs-pattern { display: none; }
|
||||
/* and the uploaded photo — ink, not decoration, on paper (16-login-bg.css) */
|
||||
:root[data-wallpaper="file"] :is(.fs-shell, body:not(:has(.fs-shell))) { background-image: none; }
|
||||
/* keep a card in one piece where the page allows it */
|
||||
.cbi-section { break-inside: avoid; }
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user