diff --git a/luci-theme-footstrap/LICENSE b/luci-theme-footstrap/LICENSE new file mode 100644 index 00000000..d6456956 --- /dev/null +++ b/luci-theme-footstrap/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/luci-theme-footstrap/Makefile b/luci-theme-footstrap/Makefile new file mode 100644 index 00000000..bf93bb20 --- /dev/null +++ b/luci-theme-footstrap/Makefile @@ -0,0 +1,149 @@ +# +# Copyright (C) 2026 +# +# This is free software, licensed under the Apache License, Version 2.0 . +# + +include $(TOPDIR)/rules.mk + +PKG_NAME:=luci-theme-footstrap +# luci.mk keys the Build/Prepare hook name on LUCI_NAME, which defaults to the checkout's +# directory name — a differently-named checkout symlinked into the feed would silently skip +# the CSS build. Pin it. +LUCI_NAME:=luci-theme-footstrap + +# Version is git-derived; never hardcode PKG_VERSION. luci.mk falls back to PKG_SRC_VERSION, +# which it always defines, when nothing here sets it — see docs/package.md for why no override +# lives here. +LUCI_TITLE:=Footstrap Theme +# +luci-base is the WHOLE list. Nothing shipped fetches at run time; `curl` is not in OpenWrt's +# default set (8 MB devices), so fall back to uclient-fetch, jsonfilter, sha256sum or do without. +LUCI_DEPENDS:=+luci-base +LUCI_PKGARCH:=all +# Else luci.mk claims MAINTAINER "OpenWrt LuCI community" and URL openwrt/luci. +LUCI_MAINTAINER:=Ivan Kvashonkin +LUCI_URL:=https://github.com/VizzleTF/luci-theme-footstrap + +# CSS ships verbatim: luci.mk's csstidy mangles :has(), color-mix() and nested calc(). build-css.sh +# minifies. +LUCI_MINIFY_CSS:=0 +# +# JS: the released package is built by owfeed (tools/stage.sh), not by this Makefile through the +# SDK, so LUCI_MINIFY_JS keeps luci.mk's jsmin. jsmin's one-character lookback does not know `n` or +# `>`, so `return /re/` makes it eat the rest of the file AND EXIT 0 (openwrt/luci#8299); eslint's +# `wrap-regex` bans the shape and tools/jsmin-verify.mjs proves the output token-identical. + +# Apache-2.0, not a free choice: styles/base began as a fork of luci-theme-bootstrap's cascade.css, +# the ucode templates derive from LuCI's and a few JS helpers are verbatim copies; the notices +# travel with it. No OFL-1.1: the theme ships no Font Software. +PKG_LICENSE:=Apache-2.0 +PKG_LICENSE_FILES:=LICENSE + +# /etc/config/footstrap is SHIPPED as an empty stub and WRITTEN AT RUNTIME: Appearance -> +# "Save as default" has rpcd uci-set the router-wide axes into that very file. Without this define +# the package manager owns it as an ordinary file and REPLACES it on upgrade, so the admin's saved +# defaults are wiped by the theme's own one-click Update, silently and reported as success. +# OpenWrt honours the define for BOTH formats (include/package-pack.mk), so one covers 24.10's opkg +# and 25.12's apk alike. Any future root/etc/config/* must be listed here too. +define Package/luci-theme-footstrap/conffiles +/etc/config/footstrap +endef + +# No `rpcd reload`: it re-execs rpcd, which drops a plugin that is absent mid-write until the next +# reload, and this package registers no rpcd object (rpcd re-reads acl.d at every login). The postinst +# ends a session only when a fresh login would grant it more. Comments inside a define ship into the +# router's script store (1984 of 3239 B), so the bodies are code only (`set -f`: the unquoted +# `$$(uci -q get …)` lists must split, not glob a `*`). docs/package.md, "Why postinst/postrm never +# call `rpcd reload`". +define Package/luci-theme-footstrap/postinst +#!/bin/sh +[ -n "$${IPKG_INSTROOT}" ] || { + rm -f /tmp/luci-indexcache* /tmp/luci-modulecache/* >/dev/null 2>&1 || true + set -f + ubus list 2>/dev/null | grep -qx session && { + for s in $$(ubus call session list 2>/dev/null | grep -o '"ubus_rpc_session": "[a-f0-9]*"' | cut -d'"' -f4); do + case "$$s" in *[!0]*) ;; *) continue ;; esac + ubus call session access "{\"ubus_rpc_session\":\"$$s\",\"scope\":\"uci\",\"object\":\"footstrap\",\"function\":\"write\"}" 2>/dev/null | grep -q true && continue + u=$$(ubus call session get "{\"ubus_rpc_session\":\"$$s\"}" 2>/dev/null | grep -o '"username": *"[^"]*"' | cut -d'"' -f4) + [ -n "$$u" ] || continue + perm=$$(uci show rpcd 2>/dev/null | grep -F .username= | while read -r kv; do + sect=$${kv%%.username=*} + un=$${kv#*.username=} + un=$${un#\'} + un=$${un%\'} + [ "$$un" = "$$u" ] || continue + for grp in $$(uci -q get "$$sect.write"); do + [ "$$grp" = luci-theme-footstrap ] && { echo write; break 2; } + done + for grp in $$(uci -q get "$$sect.read"); do + [ "$$grp" = luci-theme-footstrap ] && { echo read; break 2; } + done + done) + [ -n "$$perm" ] || continue + [ "$$perm" = read ] && ubus call session access "{\"ubus_rpc_session\":\"$$s\",\"scope\":\"uci\",\"object\":\"footstrap\",\"function\":\"read\"}" 2>/dev/null | grep -q true && continue + ubus call session destroy "{\"ubus_rpc_session\":\"$$s\"}" >/dev/null 2>&1 || true + done + } +} +exit 0 +endef + +# opkg runs the OLD package's postrm with "upgrade" on a version upgrade; it must change nothing +# there, since reverting mediaurlbase flipped upgrading 24.10 users back to bootstrap (apk never +# runs it on upgrade). Removal restores bootstrap only if its media dir and header.ut exist, drops +# /etc/footstrap (the uploaded login background) and, as in the postinst, no rpcd reload. +define Package/luci-theme-footstrap/postrm +#!/bin/sh +case "$$1" in *upgrade*) exit 0 ;; esac +[ -n "$${IPKG_INSTROOT}" ] || { + uci -q delete luci.themes.Footstrap + case "$$(uci -q get luci.main.mediaurlbase)" in + /luci-static/footstrap*) + [ -d /www/luci-static/bootstrap ] && \ + [ -f /usr/share/ucode/luci/template/themes/bootstrap/header.ut ] && \ + uci set luci.main.mediaurlbase=/luci-static/bootstrap ;; + esac + uci commit luci + rm -rf /etc/footstrap >/dev/null 2>&1 || true + rm -f /tmp/luci-indexcache* /tmp/luci-modulecache/* >/dev/null 2>&1 || true +} +endef + +# Runs right after luci.mk copies the sources into PKG_BUILD_DIR, so it rewrites the build copy +# only. cascade.css is generated, not committed, and styles/ is not in luci.mk's copy list: +# build-css.sh reads it from $(CURDIR) (cat and awk only, so it runs on a buildbot). The git-derived +# version is stamped into fs-version.js unconditionally; only an un-built checkout keeps +# '0.0.0-dev'. The catalogue is luci.mk's business: `po/` is what LUCI_LANGUAGES globs. +define Build/Prepare/luci-theme-footstrap + # PKG_LICENSE_FILES resolves against $(PKG_BUILD_DIR), which luci.mk fills with only src/ luasrc/ + # htdocs/ root/ ucode/; the copy is metadata only, luci.mk never installs it. + $(CP) $(CURDIR)/LICENSE $(PKG_BUILD_DIR)/ + $(SHELL) $(CURDIR)/build-css.sh $(PKG_BUILD_DIR)/htdocs/luci-static/footstrap/cascade.css + # Private `--fs-*` names are 13% of the sheet; runs BEFORE the templates and probes strips, which + # take the comments it reads. + $(SHELL) $(CURDIR)/mangle-tokens.sh \ + $(PKG_BUILD_DIR)/htdocs/luci-static/footstrap/cascade.css \ + $(PKG_BUILD_DIR)/htdocs/luci-static/resources $(PKG_BUILD_DIR)/ucode + # Strips `{# … #}`, whole-line `/* … */` and the indentation from the templates (-27.2 KB of 47.2). + # dev-sync.sh does not run this, so a router being debugged keeps its comments and indentation. + $(SHELL) $(CURDIR)/strip-build.sh templates $(PKG_BUILD_DIR)/ucode + # The gate-only `/* fs:probe */` exports: the functions stay, the export line goes. + $(SHELL) $(CURDIR)/strip-build.sh probes $(PKG_BUILD_DIR)/htdocs/luci-static/resources + # The same for the shell under root/ (about half of uci-defaults and the CGI are comments); + # whole-line `#` only. + $(SHELL) $(CURDIR)/strip-build.sh shell $(PKG_BUILD_DIR)/root + # The SVG favicon's comment and the manifest's indentation; awk only, so no node on a buildbot. + $(SHELL) $(CURDIR)/strip-build.sh assets $(PKG_BUILD_DIR)/htdocs/luci-static/footstrap + $(SED) "s#const FS_VERSION *= *'[^']*'#const FS_VERSION = '$(if $(PKG_VERSION),$(PKG_VERSION),$(PKG_SRC_VERSION))'#" \ + $(PKG_BUILD_DIR)/htdocs/luci-static/resources/fs-version.js +endef + +# Absolute, not a relative path: the usual ../../luci.mk resolves only inside the luci feed. +include $(TOPDIR)/feeds/luci/luci.mk + +# Load-bearing, not boilerplate: include/scan.mk finds packages by GREPPING Makefiles for +# `call (Build/DefaultTargets|BuildPackage|KernelPackage)`. luci.mk calls BuildPackage, which the +# grep cannot see, so without the literal line below the package gets no CONFIG_PACKAGE_* symbol and +# `make package//compile` fails with "No rule to make target". tools/scan-marker.sh re-derives +# the grep and fails the build if it goes missing. +# call BuildPackage - OpenWrt buildroot signature diff --git a/luci-theme-footstrap/README.md b/luci-theme-footstrap/README.md new file mode 100644 index 00000000..f9291621 --- /dev/null +++ b/luci-theme-footstrap/README.md @@ -0,0 +1,67 @@ +# luci-theme-footstrap (the package) + +A LuCI theme for OpenWrt **24.10.3 and newer** (ucode templates). Installing and using it: +[the repository README](../README.md). Developer documentation: [`../docs/`](../docs/README.md). + +Internal name: `footstrap`. Media path: `/luci-static/footstrap`. + +## One theme, one entry + +`luci.themes` carries **exactly one** entry, `Footstrap` → `/luci-static/footstrap`. Layout (top bar +by default, or the side menu), mode, palette, density, wallpaper, rounding and every colour — accent, +the three status colours, the four surfaces — are **client** axes on the System → Footstrap page: +`localStorage` plus attributes and inline properties on `:root`, and nothing is written to the +router until "Save as default" is pressed. There are no per-layout or per-mode themes; every legacy +name (`FootstrapSidebar`, `FootstrapOnTop`, `…-dark`/`…-light`) is deleted by +`root/etc/uci-defaults/30_luci-theme-footstrap`. + +There is one menu renderer too, `renderMainMenu` in `fs-chrome.js`. The top bar is its own markup, morphed by CSS +through `:root[data-layout]`. No second template, no second renderer, no `footstrap-top` symlink. + +**The theme's boundary:** it supplies the chrome and the design language; page content is drawn by +the view JS of `luci-mod-*`. The one exception is `fs-overview.js`, which draws no content of its own +and only re-arranges the stock overview sections. + +## Layout + +``` +Makefile luci.mk; LUCI_MINIFY_CSS:=0; Build/Prepare (CSS, mangle, strip, + version, po2lmo) +styles/ CSS SOURCE: layers tokens / base / theme / pages +build-css.sh styles/ → htdocs/luci-static/footstrap/cascade.css +mangle-tokens.sh shorten the private --fs-* names in a built sheet, then join it to one line +strip-build.sh build-tree strip, one mode each: templates, shell, probes, assets +po/ translation catalogue (Weblate translates this) +ucode/template/themes/footstrap/ header.ut, footer.ut, sysauth.ut, partials/ +htdocs/luci-static/footstrap/ cascade.css (generated), logo.svg — no webfonts, and no + wallpaper: the Pattern is one the admin uploads, and a font + is one the admin installs (repo: fonts/set-font.sh) +htdocs/luci-static/resources/ menu-footstrap.js (footer entry), menu-footstrap-common.js, + fs-{fit,menutree,prefs,widgets,chrome,router,sheets,search, + select,appearance,version,overview}.js +root/etc/uci-defaults/ registration and legacy-name migration +root/usr/share/rpcd/acl.d/ ACL: uci footstrap (Save as default) + login-background upload +``` + +There is no update checker: the theme is installed from the package feed (`install.sh` adds it), so +`apk upgrade` / `opkg upgrade` carries it forward like everything else on the router. The Footstrap +tab shows the version it is running and makes no network call to do it. + +**Do not edit `cascade.css`** — it is generated by `build-css.sh` from `styles/` and is gitignored. +Colours go in `styles/03-palettes.css`, scales and tokens in `styles/02-tokens.css`. + +## Working on a router + +The normal dev stand is the disposable routers `../owlab.yaml` defines, driven by `owlab` — see +[`../docs/development.md`](../docs/development.md). `dev-sync.sh` targets a **hardware** router over +ssh: + +```sh +./dev-sync.sh # push to `ssh router` (registers the theme but does NOT activate it) +ssh router 'uci set luci.main.mediaurlbase=/luci-static/footstrap; uci commit luci; rm -f /tmp/luci-indexcache*' +ssh router 'uci set luci.main.mediaurlbase=/luci-static/bootstrap; uci commit luci' # roll back +``` + +Before pushing, run `npm run check` from the repository root. The rules and the traps are in +[`../docs/conventions.md`](../docs/conventions.md); packaging is in +[`../docs/package.md`](../docs/package.md). diff --git a/luci-theme-footstrap/build-apk.sh b/luci-theme-footstrap/build-apk.sh new file mode 100755 index 00000000..fe9fe915 --- /dev/null +++ b/luci-theme-footstrap/build-apk.sh @@ -0,0 +1,107 @@ +#!/bin/sh +# Build luci-theme-footstrap as an OpenWrt .apk via the SDK. The theme is noarch, so the package +# installs on any router of that release whatever its CPU architecture. +# +# ./build-apk.sh # download SDK if needed, then build +# BUILD_DIR=~/x ./build-apk.sh +# +# NOT how the release is built (`./tools/stage.sh && owfeed build` is). This exercises the other +# path: the Makefile, luci.mk, jsmin and the SDK's packaging, for anyone building without owfeed. +set -eu + +# Release and gcc string are baked into the SDK filename and downloads.openwrt.org keeps only the +# current point release, so this goes stale: keep it at owfeed.lock's 25.12 `point:`. Override with +# OPENWRT_RELEASE and OPENWRT_SDK_FILE. +REL="${OPENWRT_RELEASE:-25.12.5}" +SDK_BASE="https://downloads.openwrt.org/releases/${REL}/targets/mediatek/filogic" +SDK_FILE="${OPENWRT_SDK_FILE:-openwrt-sdk-${REL}-mediatek-filogic_gcc-14.3.0_musl.Linux-x86_64.tar.zst}" +SDK_URL="$SDK_BASE/$SDK_FILE" +# MUST be a case-sensitive fs (ext4/…), NOT an NTFS/9p Windows mount. +BUILD_DIR="${BUILD_DIR:-/tmp/ow-footstrap-build}" +# FORCE=1 overrides buildroot's host-prereq bail-outs (see step 4). +export FORCE=1 +THEME_DIR="$(cd "$(dirname "$0")" && pwd)" # this package +REPO="$(cd "$THEME_DIR/.." && pwd)" # repo root (holds tools/, .github/) +SDK_DIR="$BUILD_DIR/sdk" +# the SDK signing channel, derived from REL (25.12.2 -> 25.12) +CHANNEL="${REL%.*}" + +mkdir -p "$BUILD_DIR" +cd "$BUILD_DIR" + +# 1. SDK +if [ ! -d "$SDK_DIR" ]; then + echo ">> downloading SDK $REL ..." + # --https-only: GNU wget follows https -> http redirects + wget -q --https-only -O sdk.tar.zst "$SDK_URL" + + # Signature first, checksum under it: the toolchain lands inside the built package. `sha256sums` + # alone proves nothing, it is served unsigned beside the tarball (docs/conventions.md). The + # ed25519 signature, checked with a key pinned from another host (github.com/openwrt/keyring), + # is what holds. Fails CLOSED. Every pin comes from luci-upstream.pin. + . "$THEME_DIR/luci-upstream.pin" + [ -n "${OPENWRT_KEYRING_PIN:-}" ] || { echo "build-apk: OPENWRT_KEYRING_PIN missing from luci-upstream.pin" >&2; exit 1; } + + # OPENWRT_SDK_KEY_, through eval: /bin/sh has no associative arrays + CH_VAR="$(printf '%s' "$CHANNEL" | tr -d .)" + eval "SDK_KEY=\${OPENWRT_SDK_KEY_$CH_VAR:-}" + eval "SDK_KEY_SHA256=\${OPENWRT_SDK_KEY_${CH_VAR}_SHA256:-}" + [ -n "$SDK_KEY" ] && [ -n "$SDK_KEY_SHA256" ] \ + || { echo "build-apk: no SDK signing key for channel $CHANNEL in luci-upstream.pin" >&2; exit 1; } + + echo ">> verifying SDK signature (key $SDK_KEY, channel $CHANNEL) ..." + rm -rf "$BUILD_DIR/usign" + U="$("$REPO/tools/build-usign.sh" "$BUILD_DIR/usign")" + wget -q --https-only -O sha256sums "$SDK_BASE/sha256sums" + wget -q --https-only -O sha256sums.sig "$SDK_BASE/sha256sums.sig" + wget -q --https-only -O openwrt.pub \ + "https://raw.githubusercontent.com/openwrt/keyring/$OPENWRT_KEYRING_PIN/usign/$SDK_KEY" + echo "$SDK_KEY_SHA256 openwrt.pub" | sha256sum -c - >/dev/null \ + || { echo "build-apk: OpenWrt's $CHANNEL key does not match its pin — refusing to verify with it" >&2; exit 1; } + "$U" -V -m sha256sums -p openwrt.pub -x sha256sums.sig \ + || { echo "build-apk: BAD SIGNATURE on OpenWrt's sha256sums — refusing to build with this SDK." >&2; exit 1; } + echo ">> signature verified; now the checksum means something." + + WANT="$(grep -F " *$SDK_FILE" sha256sums | cut -d' ' -f1)" + [ -n "$WANT" ] || { echo "build-apk: no sha256 published for $SDK_FILE" >&2; exit 1; } + GOT="$(sha256sum sdk.tar.zst | cut -d' ' -f1)" + [ "$WANT" = "$GOT" ] || { echo "build-apk: SDK checksum mismatch: want $WANT, got $GOT" >&2; exit 1; } + rm -f sha256sums sha256sums.sig openwrt.pub + echo ">> SDK verified." + + echo ">> extracting ..." + mkdir -p "$SDK_DIR" + tar --zstd -xf sdk.tar.zst -C "$SDK_DIR" --strip-components=1 + rm -f sdk.tar.zst +fi +cd "$SDK_DIR" + +# 2. feeds (need luci for luci.mk + BuildPackage macros) +if [ ! -f feeds/luci.index ] && [ ! -d feeds/luci ]; then + ./scripts/feeds update base luci +fi +./scripts/feeds install -a -p luci >/dev/null 2>&1 || true + +# 3. drop our theme into the luci themes feed (fresh copy) +DEST="feeds/luci/themes/luci-theme-footstrap" +rm -rf "$DEST" +cp -a "$THEME_DIR" "$DEST" +# a worktree can hold 0600/0700 (git stores 100644); uhttpd answers 403 on a file that is not world-readable +chmod -R u=rwX,go=rX "$DEST" +rm -rf "$DEST/build-apk.sh" "$DEST/dev-sync.sh" "$DEST/.git" 2>/dev/null || true + +./scripts/feeds update -i luci +./scripts/feeds install luci-theme-footstrap + +# 4. build. ncurses is only needed for interactive menuconfig, not for a noarch +# theme, so satisfy the host prereq stamp to skip that check. +mkdir -p staging_dir/host +touch staging_dir/host/.prereq-build +make defconfig FORCE=1 +make package/luci-theme-footstrap/clean FORCE=1 V=s >/dev/null 2>&1 || true +make package/luci-theme-footstrap/compile FORCE=1 V=s + +# 5. locate the artifact +echo +echo ">> built packages:" +find bin -name 'luci-theme-footstrap*' \( -name '*.apk' -o -name '*.ipk' \) -print diff --git a/luci-theme-footstrap/build-css.sh b/luci-theme-footstrap/build-css.sh new file mode 100755 index 00000000..c4a6c22d --- /dev/null +++ b/luci-theme-footstrap/build-css.sh @@ -0,0 +1,330 @@ +#!/bin/sh +# Concatenate the styles/ tree into a single cascade.css. +# +# ./build-css.sh [outfile] [--dev] +# +# Directory order is layer order (styles/, base/, theme/, pages/); filename order is source order +# within a directory. A later layer beats an earlier one whatever the specificity, so nothing needs +# !important to override base. +# +# Minified unless --dev: uhttpd serves CSS with no gzip, so every byte is a wire byte. Comments and +# whitespace go, and five spellings shrink (docs/css.md, "The build"): [a="b"] -> [a=b], the space +# before !important, ::before -> :before, the spaces beside * and / in a declaration, and a flex +# triple with a keyword form (1 1 auto -> auto). Nothing else in a selector or declaration is +# rewritten, which is why csstidy stays off (it mangles :has() and color-mix()). Needs only cat and +# awk, so an OpenWrt buildbot can run it. +set -eu + +D="$(cd "$(dirname "$0")" && pwd)" +OUT="" +DEV=0 +for a in "$@"; do + case "$a" in + --dev) DEV=1 ;; + # Else a typo like `--devv` becomes the output file name. + -*) echo "build-css: unknown option: $a" >&2; exit 1 ;; + *) OUT="$a" ;; + esac +done +[ -n "$OUT" ] || OUT="$D/htdocs/luci-static/footstrap/cascade.css" + +for d in styles styles/base styles/theme styles/pages; do + [ -d "$D/$d" ] || { echo "build-css: $D/$d missing" >&2; exit 1; } +done + +TMP="$OUT.tmp.$$" +# $TMP.min too: an awk failure leaves it behind. +trap 'rm -f "$TMP" "$TMP.min" "$TMP.layer"' EXIT +trap 'exit 130' INT TERM +mkdir -p "$(dirname "$OUT")" + +# One `@layer X{` per LAYER, not per FILE: 37 file wrappers are 542 bytes. The wrapper comes from +# the DIRECTORY, so each file must open with the layer its directory means or it is silently +# re-layered. A file with no wrapper (00-header.css: banner and layer-order statement) is copied +# through and must come before the wrapped ones, or it lands inside the block. +emit_layer() { + layer="$1"; shift + body="$TMP.layer" + : > "$body" + for f in "$@"; do + if head -1 "$f" | grep -q '^@layer '; then + head -1 "$f" | grep -q "^@layer $layer {\$" || { + echo "build-css: $f is in a $layer directory but does not open with '@layer $layer {'" >&2 + exit 1; } + # the file's own wrapper: its first line, and the bare `}` where brace depth returns to 0. + # Anything but blank or comment after that `}` is refused: the source leaves it unlayered + # and the build would move it into the block, a silent cascade change. + awk -v F="$f" 'NR == FNR { + if (end) { + l = $0 + if (inc) { if (sub(/^.*\*\//, "", l)) inc = 0; else next } + gsub(/\/\*.*\*\//, "", l) + if (match(l, /\/\*/)) { inc = 1; l = substr(l, 1, RSTART - 1) } + if (!bad && l ~ /[^ \t\r]/) bad = NR + next + } + # depth, string- and comment-aware: a `{` in a multi-line comment or in content:"{" + # is not a block (the same walk as brace_count below) + l = $0; n = length(l) + for (i = 1; i <= n; i++) { + ch = substr(l, i, 1) + if (inc) { if (ch == "*" && substr(l, i + 1, 1) == "/") { inc = 0; i++ } continue } + if (q != "") { if (ch == "\\") i++; else if (ch == q) q = ""; continue } + if (ch == "\"" || ch == "'"'"'") { q = ch; continue } + if (ch == "/" && substr(l, i + 1, 1) == "*") { inc = 1; i++; continue } + if (ch == "{") d++; else if (ch == "}") d-- + } + if (NR > 1 && d == 0) end = NR; next } + END { if (bad) { printf "build-css: %s:%d: a rule after the @layer wrapper would be moved into the layer; put it inside\n", F, bad > "/dev/stderr"; exit 1 } } + FNR > 1 && FNR != end' "$f" "$f" >> "$body" + elif [ -s "$body" ]; then + echo "build-css: $f has no @layer wrapper but follows one that does — it would be" >&2 + echo "build-css: swallowed into the $layer block instead of staying above it." >&2 + exit 1 + else + cat "$f" + fi + done + if [ -s "$body" ]; then + printf '@layer %s {\n' "$layer" + cat "$body" + printf '}\n' + fi + # not covered by the EXIT trap: the success path runs `trap - EXIT` first + rm -f "$body" +} + +# glob expands in filename order +{ + emit_layer tokens "$D"/styles/*.css + emit_layer base "$D"/styles/base/*.css + emit_layer theme "$D"/styles/theme/*.css + emit_layer page "$D"/styles/pages/*.css +} > "$TMP" + +# Comments, and — unless told not to — the whitespace CSS ignores anyway, in one string-aware +# pass rather than two chained ones. squeeze=0 (the pre-compression rule count below; a +# `--dev` build skips the pass and keeps the raw sheet) strips comments and trims each line; +# squeeze=1 also does the ~9.5 KB whitespace pass. Why a scan has to be string-aware, what the +# whitespace pass leaves alone and why, and the sed bug this replaced: docs/css.md, "The build". +squeeze() { + awk -v SQUEEZE="$2" ' + # The exact flex triples that have a shorter keyword form (shorthand initial values: grow 1 + # shrink 1 basis auto). Bare 0 is left alone, since `flex:0` means grow 0. + function flexv(v, imp) { + if (v ~ /!important$/) { imp = "!important"; v = substr(v, 1, length(v) - 10) } + if (v == "0 0 auto") v = "none" + else if (v == "1 1 auto") v = "auto" + else if (v == "0 1 auto") v = "0 auto" + else if (v ~ /^1 1 ([0-9]+\.?[0-9]*|\.[0-9]+)(%|[A-Za-z]+)$/) v = substr(v, 5) + return v imp + } + BEGIN { q = ""; inc = 0; banner = 0; lastc = ""; buf = ""; lastreal = ""; d = 0; st = 0; fl = 0 } + { + line = $0 + # a banner already open on an earlier line: nothing on a pure continuation line can + # change q or inc, so the whole line is banner content until its own closing "*/". + if (banner) { + trimmed = line + sub(/^[ \t]+/, "", trimmed); sub(/[ \t]+$/, "", trimmed) + print trimmed + lastc = ""; lastreal = "" + if (index(line, "*/")) banner = 0 + next + } + # The line BREAK a squeeze pass is about to swallow is whitespace, and a declaration + # may be wrapped across it. Feed it to the whitespace-run logic below as a leading + # space: it survives only where a space would and is dropped next to { } ; , : — + # lastc == "" means output is already at the start of a line, with nothing to glue to. + if (SQUEEZE && lastc != "" && q == "" && !inc) line = " " line + out = ""; i = 1; n = length(line); opened = 0 + while (i <= n) { + c = substr(line, i, 1) + if (inc) { # inside a stripped /* ... */ + if (c == "*" && substr(line, i + 1, 1) == "/") { inc = 0; i += 2; continue } + i++; continue + } + if (q != "") { # inside a "..." or '"'"'...'"'"' string + out = out c + if (c == "\\") { out = out substr(line, i + 1, 1); i += 2; continue } + if (c == q) q = "" + lastreal = "" + i++; continue + } + if (c == "\"" || c == "'"'"'") { + # [attr="ident"] -> [attr=ident]: the same selector, 2 bytes less, 394 sites. Only a + # whole ident closed on this line right before `]`; "--" stays quoted, since + # mangle-tokens.sh reads an unquoted --fs- as a name to rename. + if (SQUEEZE) { + j = index(substr(line, i + 1), c) + v = substr(line, i + 1, j - 1) + if (j && substr(line, i + j + 1, 1) == "]" && out ~ /\[[-A-Za-z0-9_]+[~|^$*]?=$/ && + v ~ /^-?[A-Za-z_][-A-Za-z0-9_]*$/ && !index(v, "--")) { + out = out v; lastreal = ""; i += j + 1; continue + } + } + q = c; out = out c; lastreal = ""; i++; continue + } + if (c == "/" && substr(line, i + 1, 1) == "*") { + if (substr(line, i + 2, 1) == "!") { + # a genuine banner open: reached only with q=="" and inc==0 AT THIS + # CHARACTER, the same guard strip_comments used before this pass absorbed + # it — so a "/*!" that is really bytes inside a string or an already-open + # ordinary comment never lands here. Copied raw from the marker on, byte + # for byte: it is an Apache-2.0 attribution, not formatting. + banner = 1 + rest = substr(line, i) + out = out rest + if (index(rest, "*/")) banner = 0 + opened = 1 + break + } + inc = 1; i += 2; continue + } + if (SQUEEZE) { + if (c == " " || c == "\t") { # collapse a run of whitespace to one space + while (i <= n && (substr(line, i, 1) == " " || substr(line, i, 1) == "\t")) i++ + # the last char EMITTED, which on a continuation line lives on the + # previous output line — hence lastc, not just `out`. + prev = (length(out) ? substr(out, length(out), 1) : lastc) + nxt = (i <= n ? substr(line, i, 1) : "") + # Drop the space next to a delimiter; otherwise it may be a combinator. `>` joins: + # outside a string it is the child combinator or a range `>` + # (`@container (width > 560px)`), both valid unspaced. `~` and `+` do not: + # `[attr~=v]` and `calc(100% - 10px)` are ambiguous without bracket depth. + # `!` joins too: `red!important` is the same declaration (35 sites). + if (prev == "" || prev == "{" || prev == "}" || prev == ";" || prev == "," || prev == ":" || prev == ">") + continue + if (nxt == "{" || nxt == "}" || nxt == ";" || nxt == "," || nxt == "" || nxt == ">" || nxt == "!") + continue + # Inside a declaration only + and - need their spaces: calc(1px * 2) -> calc(1px*2), + # 16 / 9 -> 16/9. Not before a comment opener, and `/*` or `*/` is never joined. + if (bk[d] == "D" && (prev == "*" || prev == "/" || nxt == "*" || (nxt == "/" && substr(line, i + 1, 1) != "*")) && + (prev nxt) != "/*" && (prev nxt) != "*/") + continue + out = out " "; lastreal = " " + continue + } + # ::before/::after -> :before/:after, the CSS2 form every engine still parses and + # serialises as `::`; the first colon of 93 pseudo-elements. Not `::before-x`. + if (c == ":" && substr(line, i + 1, 1) == ":") { + w = (substr(line, i + 2, 6) == "before") ? 6 : (substr(line, i + 2, 5) == "after") ? 5 : 0 + if (w && substr(line, i + 2 + w, 1) !~ /[-A-Za-z0-9_]/) { i++; continue } + } + # bk[d] is the kind of the open block: G holds rules (@layer @media @supports @container + # @keyframes), D holds declarations (a style rule, @font-face, a keyframe step). st: a + # statement has started, pk: its kind. The value rewrites cannot tell a nested rule from a + # declaration, so a rule inside a D block fails the build. + if (c == "{") { + if (bk[d] == "D") { printf "build-css: a rule nested in a declaration block (docs/css.md, \"The build\")\n" > "/dev/stderr"; exit 1 } + bk[++d] = (st ? pk : "D"); st = 0 + } else if (c == "}") { d--; st = 0 } + else if (c == ";") st = 0 + else if (!st) { + st = 1 + pk = (substr(line, i, 24) ~ /^@(layer|media|supports|container|scope|starting-style|[-a-z]*keyframes)/) ? "G" : "D" + } + # flex: vs is the offset of the value in buf out; it is rewritten when the declaration ends + if (c == ":" && bk[d] == "D" && out ~ /flex$/ && (buf out) ~ /(^|[{;])flex$/) { fl = 1; vs = length(buf) + length(out) + 1 } + if (fl && (c == ";" || c == "}")) { + fl = 0; ft = buf out; fv = substr(ft, vs + 1); fw = flexv(fv) + if (fw != fv) { buf = ""; out = substr(ft, 1, vs) fw } + } + # The last `;` of a block is dropped here, inside the string-aware scanner: a sed + # `s/;}/}/` cannot see strings and turns `content: ";}"` into `content: "}"`. + # The `;` may already sit in the previous output line, so text is held in `buf` + # until the rule closes. + if (c == "}") { + if (length(out) && substr(out, length(out), 1) == ";") + out = substr(out, 1, length(out) - 1) + else if (!length(out) && length(buf) && substr(buf, length(buf), 1) == ";") + buf = substr(buf, 1, length(buf) - 1) + } + out = out c; lastreal = c; i++ + } else { + out = out c; i++ + } + } + if (opened) { + trimmed = out + sub(/^[ \t]+/, "", trimmed); sub(/[ \t]+$/, "", trimmed) + print trimmed + lastc = ""; lastreal = "" + next + } + if (SQUEEZE) { + buf = buf out + if (length(out)) lastc = substr(out, length(out), 1) + # newline only after a closing brace — one rule per line. lastreal, not lastc: a + # line ending in a QUOTED `}` (content: "}") is not the end of a rule, and + # flushing there would split the rule and lose the space before its next token. + if (lastreal == "}") { print buf; buf = ""; lastc = ""; lastreal = "" } + } else { + sub(/^[ \t]+/, "", out) + sub(/[ \t]+$/, "", out) + if (length(out)) print out + } + } + END { if (SQUEEZE) { if (length(buf)) print buf; else printf "\n" } } + ' "$1" +} + +# Fail loudly rather than let an unbalanced block ship. +# +# String-aware, for the same reason the comment stripper is: a brace inside a CSS STRING is not a +# block, so a counter that gsub()s over the raw line makes a perfectly valid rule fail the build. +# Measured, all three shapes: `content: ";}"`, `content: "{"`, and a data-URI carrying `;}`. It +# fails closed, so nothing is ever corrupted; what it costs is a hunt for an imbalance that is not +# there. +brace_count() { + awk ' + BEGIN { q = "" } + { + line = $0; n = length(line); i = 1 + while (i <= n) { + ch = substr(line, i, 1) + if (q != "") { # inside a string + if (ch == "\\") { i += 2; continue } # escape: skip the pair + if (ch == q) q = "" + i++; continue + } + if (ch == "\"" || ch == "'"'"'") { q = ch; i++; continue } + if (ch == "{") o++ + else if (ch == "}") c++ + i++ + } + } + END { + if (o != c) { printf "build-css: %s: unbalanced braces (%d { vs %d })\n", FILENAME, o, c > "/dev/stderr"; exit 1 } + if (o < 100) { printf "build-css: %s: suspiciously few rules (%d)\n", FILENAME, o > "/dev/stderr"; exit 1 } + print o + }' "$1" +} + +# Always brace-check a COMMENT-STRIPPED, UNSQUEEZED copy, --dev included: counting braces in the +# raw file made a stray "{" in prose fail the build on perfectly valid CSS. +squeeze "$TMP" 0 > "$TMP.min" +RULES_BEFORE=$(brace_count "$TMP.min") || exit 1 +rm -f "$TMP.min" + +if [ "$DEV" -eq 0 ]; then + squeeze "$TMP" 1 > "$TMP.min" + mv "$TMP.min" "$TMP" + + # Recount on what ships: the squeeze is the pass most able to corrupt the sheet. The rule COUNT, + # not brace balance, catches a truncated write: a cut right after the base layer closes is still + # balanced against the true rule count, and RULES_BEFORE comes from the untruncated sheet. + RULES_AFTER=$(brace_count "$TMP") || exit 1 + if [ "$RULES_BEFORE" != "$RULES_AFTER" ]; then + echo "build-css: the squeeze changed the rule count ($RULES_BEFORE -> $RULES_AFTER)." >&2 + exit 1 + fi +fi +# --dev: $TMP is still the raw concatenation — comments and formatting intact, for reading on a +# router rather than shipping. + +SIZE=$(wc -c < "$TMP" | tr -d ' ') +mv "$TMP" "$OUT" +trap - EXIT + +echo "build-css: $SIZE bytes -> $OUT" diff --git a/luci-theme-footstrap/dev-sync.sh b/luci-theme-footstrap/dev-sync.sh new file mode 100755 index 00000000..2dbcde47 --- /dev/null +++ b/luci-theme-footstrap/dev-sync.sh @@ -0,0 +1,124 @@ +#!/bin/sh +# Push the footstrap theme to a HARDWARE router over ssh (containers use owlab). +# ONE theme, one luci.themes entry; layout (top/sidebar) is a client axis on the +# System -> Footstrap page, not a theme entry. This registers the theme; it does NOT activate it. +set -eu + +R="${1:-router2512}" +N=footstrap +D="$(cd "$(dirname "$0")" && pwd)" + +# cascade.css is generated from styles/ and is not in git. --dev keeps the comments so the +# file on the router still reads like the source. +"$D"/build-css.sh "$D/htdocs/luci-static/$N/cascade.css" --dev + +ssh "$R" "mkdir -p /usr/share/ucode/luci/template/themes/$N \ + /www/luci-static/$N \ +" + +# the ONE template (+ partials/). Sidebar and top bar are the same markup, morphed by +# :root[data-layout] — there is no second theme dir to copy. +scp -q "$D"/ucode/template/themes/$N/*.ut "$R":/usr/share/ucode/luci/template/themes/$N/ +ssh "$R" "mkdir -p /usr/share/ucode/luci/template/themes/$N/partials" +scp -q "$D"/ucode/template/themes/$N/partials/*.ut \ + "$R":/usr/share/ucode/luci/template/themes/$N/partials/ + +# shared static: cascade.css, the logo (SVG + PNGs), the app icon and the manifest; no wallpapers. +scp -qr "$D"/htdocs/luci-static/$N/* "$R":/www/luci-static/$N/ +# scp carries a worktree's 0600 across, and uhttpd answers 403 on a file that is not world-readable +ssh "$R" "chmod -R u=rwX,go=rX /www/luci-static/$N /usr/share/ucode/luci/template/themes/$N" + +# Every resource JS goes as a TAR OF THE TREE, never by name or `scp *.js`: luci.mk copies htdocs/ +# wholesale, so a file listed by hand, or one in a subdirectory, ships in the package and never +# reaches the dev router. Every path under resources/ is ours to place. --mode is GNU tar (a +# checkout's umask would otherwise set the router's modes); bsdtar on macOS refuses it, so use gtar. +tar -C "$D/htdocs/luci-static/resources" --mode=u=rwX,go=rX -cf - . | + ssh "$R" "mkdir -p /www/luci-static/resources && tar -C /www/luci-static/resources -xf -" + +# stamp the git-derived version into the deployed fs-version.js (the package does the same in +# Build/Prepare) so the System -> Footstrap page shows a real version instead of "(dev)". The FILE +# NAME is part of the contract: FS_VERSION lives in fs-version.js, so moving it changes every sed. +FS_V="$(git -C "$D" describe --tags --always 2>/dev/null | sed 's/^v//')" +# if-form, not `[ -n ] && ssh`: under `set -e` a bare `&&`-list whose LAST command fails is what +# aborts, so `[ -n "$FS_V" ] && ssh …` would take the sync down whenever git describe yielded +# nothing (a copied tree without .git). An `&&` guarding an ASSIGNMENT is a different shape and is +# safe. expr refuses a tag with sed- or shell-special characters rather than interpolating it. +if [ -n "$FS_V" ] && expr "$FS_V" : '[0-9A-Za-z._-]*$' >/dev/null; then + ssh "$R" "sed -i \"s#const FS_VERSION *= *'[^']*'#const FS_VERSION = '$FS_V'#\" \ + /www/luci-static/resources/fs-version.js" +fi + +# The catalogue: owfeed bundles it in the release, so a dev router gets it only from this sync. +# po2lmo is a luci-base host tool, so this is best-effort: without it strings stay English. Build it +# with make -C modules/luci-base/src po2lmo (plural_formula.c is generated by contrib/lemon). +# The basename is `footstrap`, as luci.mk and owfeed.yml ship it (luci-i18n-footstrap-); the +# old `footstrap-theme.*.lmo` of an earlier dev sync is removed, or a stale catalogue could win. +if command -v po2lmo >/dev/null 2>&1; then + ssh "$R" "mkdir -p /usr/lib/lua/luci/i18n && rm -f /usr/lib/lua/luci/i18n/footstrap-theme.*.lmo" + for po in "$D"/po/*/*.po; do + [ -e "$po" ] || continue + lang="$(basename "$(dirname "$po")")" + po2lmo "$po" "/tmp/footstrap.$lang.lmo" + scp -q "/tmp/footstrap.$lang.lmo" "$R":/usr/lib/lua/luci/i18n/ + rm -f "/tmp/footstrap.$lang.lmo" + done +else + echo " (po2lmo not found — skipping the translation catalogue; strings stay English)" +fi + +# root/ -> / as a TREE with a GLOB of top-level dirs, never a list of names (luci.mk installs root/ +# wholesale; a hand-written `usr` list missed root/etc/config/footstrap). tar, not `scp -r`: its +# merge onto an existing /usr is ambiguous. Two subtrees are excluded by behaviour, handled below: +# - etc/uci-defaults runs from /tmp; in /etc/uci-defaults the next boot would run and DELETE it. +# - etc/config holds conffiles, which the package manager keeps on upgrade and so must we: the +# live file holds the admin's "Save as default". +set -- +for _d in "$D"/root/*/; do set -- "$@" "$(basename "$_d")"; done +tar -C "$D/root" --mode=u=rwX,go=rX --exclude=etc/uci-defaults --exclude=etc/config -cf - "$@" | + ssh "$R" "tar -C / -xf -" + +# conffiles: install only when ABSENT, which is exactly what the package manager does with them. +for _f in "$D"/root/etc/config/*; do + [ -f "$_f" ] || continue + _b=$(basename "$_f") + scp -q "$_f" "$R":"/tmp/.fs-conf-$_b" + ssh "$R" "[ -f /etc/config/$_b ] || { mv /tmp/.fs-conf-$_b /etc/config/$_b; \ + echo ' installed /etc/config/$_b (was absent)'; }; rm -f /tmp/.fs-conf-$_b" +done +# No rpcd reload here — same race as the Makefile's postinst note (Package/luci-theme- +# footstrap/postinst): this copies files onto a router where the theme registers no rpcd object, +# rpcd re-reads acl.d/*.json at LOGIN (not only on reload), and a developer's root session already +# carries read='*' write='*', so the theme's ACL group is irrelevant to it regardless. + +ssh "$R" " +# Sweep every pre-consolidation name, $N-top included: a stale mediaurlbase on its media dir renders +# a theme LuCI no longer lists. rm -rf, not rm -f (it refuses directories and this block has no +# set -e); every path is a literal built from \$N. +cd /www/luci-static +rm -rf $N/$N $N-top $N-dark $N-light $N-top-dark $N-top-light +cd /usr/share/ucode/luci/template/themes +rm -rf $N/$N $N-top $N-dark $N-light $N-top-dark $N-top-light +# The overview layout must not be left in luci-mod-status's global include dir, where LuCI loads +# every *.js under any theme: it is a chrome module now. A package upgrade drops the old file, but +# dev-sync copies rather than installs, so it has to be swept by name — otherwise the dev router +# runs both copies and the grid is arranged twice. +rm -f /www/luci-static/resources/view/status/include/05_footstrap_overview_layout.js +" + +# Register by running the package's own uci-defaults script — the single source of truth +# (ONE entry, luci.themes.Footstrap; layout, mode and palette are client-side toggles). +# PKG_UPGRADE=1 forces its upgrade branch, so the dev router's active theme is left alone. +scp -q "$D"/root/etc/uci-defaults/30_luci-theme-footstrap "$R":/tmp/30_luci-theme-footstrap +ssh "$R" "PKG_UPGRADE=1 sh /tmp/30_luci-theme-footstrap; rm -f /tmp/30_luci-theme-footstrap" + + +# ---- last: drop LuCI's menu cache and bust the browser cache ---- +# +# LuCI's index cache is rebuilt from the files and the registration above. head.ut versions assets +# with `?v={{ pkgs_update_time }}`, the mtime of the PACKAGE DATABASE. An install moves it, scp does +# not, so a dev deploy keeps the URL while the bytes change and a browser may serve a stylesheet +# several deploys old. Touching the file is what an install would do. +ssh "$R" 'rm -f /tmp/luci-indexcache*; + touch /lib/apk/db/installed 2>/dev/null || touch /usr/lib/opkg/status 2>/dev/null || true' + +echo "synced to $R (single Footstrap theme registered, active theme unchanged)" diff --git a/luci-theme-footstrap/htdocs/luci-static/footstrap/app-icon-192.png b/luci-theme-footstrap/htdocs/luci-static/footstrap/app-icon-192.png new file mode 100644 index 00000000..fbcbf068 Binary files /dev/null and b/luci-theme-footstrap/htdocs/luci-static/footstrap/app-icon-192.png differ diff --git a/luci-theme-footstrap/htdocs/luci-static/footstrap/logo.svg b/luci-theme-footstrap/htdocs/luci-static/footstrap/logo.svg new file mode 100644 index 00000000..93302ff6 --- /dev/null +++ b/luci-theme-footstrap/htdocs/luci-static/footstrap/logo.svg @@ -0,0 +1,17 @@ + + + + + + + + diff --git a/luci-theme-footstrap/htdocs/luci-static/footstrap/logo_48.png b/luci-theme-footstrap/htdocs/luci-static/footstrap/logo_48.png new file mode 100644 index 00000000..ae7a6461 Binary files /dev/null and b/luci-theme-footstrap/htdocs/luci-static/footstrap/logo_48.png differ diff --git a/luci-theme-footstrap/htdocs/luci-static/footstrap/manifest.json b/luci-theme-footstrap/htdocs/luci-static/footstrap/manifest.json new file mode 100644 index 00000000..974777ad --- /dev/null +++ b/luci-theme-footstrap/htdocs/luci-static/footstrap/manifest.json @@ -0,0 +1,15 @@ +{ + "name": "LuCI", + "start_url": "/cgi-bin/luci/", + "display": "standalone", + "background_color": "#f6f8fa", + "theme_color": "#f6f8fa", + "icons": [ + { + "src": "app-icon-192.png", + "sizes": "192x192", + "type": "image/png", + "purpose": "any maskable" + } + ] +} diff --git a/luci-theme-footstrap/htdocs/luci-static/resources/fs-appearance.js b/luci-theme-footstrap/htdocs/luci-static/resources/fs-appearance.js new file mode 100644 index 00000000..eecfe041 --- /dev/null +++ b/luci-theme-footstrap/htdocs/luci-static/resources/fs-appearance.js @@ -0,0 +1,639 @@ +'use strict'; +'require baseclass'; +'require ui'; +'require fs-prefs as prefs'; +'require fs-axes as axes'; +'require fs-router as router'; +'require fs-assets as assets'; +'require fs-version as ver'; + +/* The Appearance controls: the DOM that presents the axes. It owns no preference: fs-prefs.js and + * fs-axes.js hold the axes and fs-version.js the version string. `view/footstrap/appearance.js` + * calls `renderStandalone()`, the whole surface this file ships. + * + * The version line makes no request and must not grow one: which version is installed is what this + * page answers, and which is available is the package manager's question. */ + +/* Colour readout. Two questions no stored value answers: what colour a role is right now (the + * palette's own while the axis is off) and what contrast it lands at. */ +let _probe = null; +function probeColor(expr) { + if (!_probe) { + /* Off-screen rather than display:none, so the reading does not depend on a display:none element + * computing `color` in every engine. Every declaration is !important: an app's CSS can style a + * plain
. */ + _probe = E('span', { 'id': 'fs-appearance-probe', 'aria-hidden': 'true' }); + _probe.style.cssText = 'position:fixed!important;left:-9999px!important;top:0!important;' + + 'width:0!important;height:0!important;overflow:hidden!important;' + + 'pointer-events:none!important;'; + document.body.appendChild(_probe); + } + /* cleared first: an expression the engine rejects leaves the previous colour standing, which + * would report a stale answer as a fresh one */ + _probe.style.setProperty('color', ''); + _probe.style.setProperty('color', expr, 'important'); + return getComputedStyle(_probe).color; +} + +/* A computed colour -> [r,g,b] 0..255, or null. Rasterised, not parsed: a computed `color` keeps the + * space it was authored in, so `oklch(0.54 0.19 300)` parses as three numbers in the wrong units + * (measured: #010078, graded "Too faint to read"). Painting one pixel makes the engine convert. */ +let _cx = null; +function rasterCtx() { + if (!_cx) { + const cv = document.createElement('canvas'); + cv.width = cv.height = 1; + _cx = cv.getContext('2d', { willReadFrequently: true }); + } + return _cx; +} +function parseColor(s) { + const cx = rasterCtx(); + /* fillStyle keeps the last value it could parse, so a colour this engine rejects would + * report the previous one as a fresh reading — the trap probeColor() clears for */ + cx.fillStyle = '#000'; + cx.fillStyle = String(s || ''); + cx.clearRect(0, 0, 1, 1); + cx.fillRect(0, 0, 1, 1); + const d = cx.getImageData(0, 0, 1, 1).data; + /* translucent: composite over nothing is meaningless for a readout */ + return d[3] === 255 ? [ d[0], d[1], d[2] ] : null; +} + +/* WCAG 2.x relative luminance and contrast ratio, on sRGB. Used only to report: the theme states + * what a colour costs and leaves the choice with the user, never correcting it (03-palettes.css + * derives the ink over a fill, which is a different question). */ +function luminance(rgb) { + const c = rgb.map((v) => { + const x = v / 255; + return (x <= .03928) ? (x / 12.92) : Math.pow((x + .055) / 1.055, 2.4); + }); + return (.2126 * c[0]) + (.7152 * c[1]) + (.0722 * c[2]); +} +function contrastRatio(fgExpr, bgExpr) { + const fg = parseColor(probeColor(fgExpr)), bg = parseColor(probeColor(bgExpr)); + if (!fg || !bg) return null; + const a = luminance(fg), b = luminance(bg); + return (Math.max(a, b) + .05) / (Math.min(a, b) + .05); +} + +function toHex(s) { + const rgb = parseColor(s) || [ 0, 0, 0 ]; + return '#' + rgb.map((v) => v.toString(16).padStart(2, '0')).join(''); +} + +/* One colour axis: a native swatch, a hex field and a button back to the palette's own colour. + * Reports through onPick as a hex string, or 0 for "back to the palette". */ +function colorControl(onPick, label, o) { + const swatch = E('input', { 'type': 'color', 'class': 'fs-color-swatch', 'aria-label': label }); + const field = E('input', { + 'type': 'text', 'class': 'fs-color-hex', 'spellcheck': 'false', 'autocomplete': 'off', + 'inputmode': 'text', 'maxlength': '7', 'aria-label': label + }); + const clear = E('button', { 'class': 'btn fs-color-clear', 'type': 'button' }, [ _('Palette', 'footstrap') ]); + const ratio = o.contrast ? E('div', { 'class': 'cbi-value-description fs-color-contrast' }) : null; + + let typed = false; + + /* Repaint everything that mirrors the axis. Called after every edit, and through the returned + * refresh() after a preset, palette switch or dark-mode flip — each changes what the palette's + * own colour is while this axis stays off. */ + function reflect(v) { + const live = probeColor(o.probe); + const hex = (typeof v === 'string') ? v : toHex(live); + swatch.value = hex; + /* do not fight the user mid-edit: `#0` is a legal prefix, and overwriting the field on + * every keystroke made the input impossible to type into */ + if (document.activeElement !== field) { field.value = hex; typed = false; } + /* the button back to the palette doubles as the axis state readout: enabled means the axis + * holds a colour of its own, disabled means the field shows the palette's */ + clear.disabled = !v; + if (!ratio) return; + const r = contrastRatio(o.contrast.fg, o.contrast.bg); + if (r === null) { ratio.textContent = ''; ratio.removeAttribute('title'); return; } + /* The readout states what the ratio means; the number itself stays in the title. Thresholds are + * WCAG AA: 4.5:1 for body text, 3:1 for large text and for a UI shape. */ + const where = o.contrast.label; + const grade = (o.contrast.kind === 'shape') + ? ((r >= 3) + ? { cls: 'fs-contrast-aa', text: _('Clearly visible %s', 'footstrap').format(where) } + : { cls: 'fs-contrast-aa-large', text: _('Barely visible %s', 'footstrap').format(where) }) + : (r >= 4.5) + ? { cls: 'fs-contrast-aa', text: _('Easy to read %s', 'footstrap').format(where) } + : (r >= 3) + ? { cls: 'fs-contrast-aa-large', text: _('Hard to read %s — large text only', 'footstrap').format(where) } + : { cls: 'fs-contrast-low', text: _('Too faint to read %s', 'footstrap').format(where) }; + ratio.className = 'fs-color-contrast ' + grade.cls; + ratio.textContent = grade.text; + ratio.title = _('Contrast %s:1 (WCAG AA wants %s:1 here)', 'footstrap') + .format(r.toFixed(1), (o.contrast.kind === 'shape') ? '3' : '4.5'); + } + + const pick = (v) => { onPick(v); reflect(v); }; + + swatch.addEventListener('input', () => pick(swatch.value.toLowerCase())); + /* commit on blur and Enter, not per keystroke: a half-typed `#0096` would repaint the page + * under the cursor. An unparseable value snaps back to what the axis holds, so the field + * cannot claim a colour the page is not painted in. An untouched field returns first, so a + * bare Tab-through never pins the shown palette colour on any of the 9 axes. */ + const commit = () => { + if (!typed) return; + const v = field.value.trim().toLowerCase(); + if ((/^#[0-9a-f]{6}$/).test(v)) pick(v); + /* re-read rather than a cached copy: the page can change what the axis holds behind this + * control (a preset, Reset to default), which a snapshot taken at build time would miss */ + else reflect(o.read()); + }; + field.addEventListener('input', () => { typed = true; }); + field.addEventListener('blur', commit); + field.addEventListener('keydown', (ev) => { if (ev.key === 'Enter') { ev.preventDefault(); commit(); } }); + clear.addEventListener('click', () => pick(0)); + + const wrap = E('div', { 'class': 'fs-colorctl' }, [ + E('div', { 'class': 'fs-color-row' }, [ swatch, field, clear ]) + ].concat(ratio ? [ ratio ] : [])); + /* the caller decides when this runs: probeColor() needs the document, and this control is not + * in it yet */ + wrap.fsRefresh = () => reflect(o.read()); + return wrap; +} + +/* Every stamp that moves a colour lands on :root, including head.ut's OS listener and an app + * rewriting data-darkmode, neither of which calls back here. */ +let _watch = null; +function unwatchColours() { + if (_watch) _watch.disconnect(); + _watch = null; +} +router.onNavigate(unwatchColours); +function watchColours(refresh) { + unwatchColours(); + _watch = new MutationObserver(refresh); + _watch.observe(document.documentElement, { + attributes: true, attributeFilter: [ 'data-darkmode', 'data-palette', 'data-wallpaper' ] + }); +} + +/* Build the whole form; renderStandalone() hands it to the page. Everything applies immediately and + * there is nothing to save: every axis is this browser's, in localStorage. Only "Save to router" + * writes anything, pushing the current look to the router for other browsers. */ +function build() { + /* 24.10.0-24.10.2 have no ui.RangeSlider and a package from the feed still installs there (opkg does + * not version luci-base); one readable line beats the raw "not a constructor" TypeError. */ + if (!ui.RangeSlider) + return E('p', { 'class': 'alert-message warning' }, [ _('Footstrap needs OpenWrt 24.10.3 or newer.', 'footstrap') ]); + + /* every saved axis re-checks the Save button after applying, so it greys the moment this + * browser matches the saved default and un-greys when it diverges. Wrapped around the appliers + * because the controls call them directly and have no other seam back here. */ + const bump = (fn) => (v) => { fn(v); refreshSave(); }; + + /* Every colour control mirrors something it does not own: the palette's colour while its own + * axis is off, and the contrast that colour lands at. A palette switch or dark-mode flip moves + * all of it under controls nobody touched, so they refresh together. */ + const colourCtls = []; + const refreshColours = () => colourCtls.forEach((c) => c.fsRefresh()); + const repaint = (fn) => (v) => { fn(v); refreshColours(); }; + + /* One captioned row in LuCI's own shape: `.cbi-value` > `label.cbi-value-title` + + * `.cbi-value-field`, which base/30-forms.css and theme/60-inputs.css already lay out. `make` is + * handed the caption because each control needs it again as the aria-label of its inner + * input/select (a stock widget's wrapper div cannot carry a name). `extra` carries rows with more + * than a control, `opts.cls` marks the rows CSS singles out. */ + const group = (label, make, opts) => { + const o = opts || {}; + return E('div', { 'class': 'cbi-value' + (o.cls ? ' ' + o.cls : '') }, [ + E('label', { 'class': 'cbi-value-title' }, [ label ]), + E('div', { 'class': 'cbi-value-field' }, [ make(label) ].concat(o.extra || [])) + ]); + }; + + /* the three literals every colour row repeats; a string literal survives minification intact */ + const CARD_BG = 'var(--fs-panel)', INK = 'var(--fs-text)', ON_CARD = _('on a card', 'footstrap'); + + /* Every enum axis is a `ui.Select` and every number a `ui.RangeSlider`, already dressed by + * base/30-forms.css and theme/60-inputs.css (`ui.RangeSlider` reached openwrt-24.10 in 24.10.3). Listen + * for `widget-change`, the seam UIElement publishes, not an event on the inner element. + * RangeSlider also emits `widget-update` while the handle moves, which resizes the page under the + * drag; the appliers are idempotent, so wiring both costs nothing. */ + const selectCtl = (current, choices, apply, label) => { + /* an array of [value, label] pairs when a key is integer-like: Object.keys hoists it ahead of + * the authored order ('2020' rendered above Footstrap, the default); `sort` pins the order */ + const pairs = Array.isArray(choices) ? choices : Object.entries(choices); + const w = new ui.Select(String(current), Object.fromEntries(pairs), { widget: 'select', sort: pairs.map((p) => p[0]) }); + const node = w.render(); + node.querySelector('select, input').setAttribute('aria-label', label); + node.addEventListener('widget-change', () => apply(w.getValue())); + return node; + }; + + const sliderCtl = (axis, apply, label, opts) => { + const o = opts || {}; + const w = new ui.RangeSlider(String(axis.current()), { + min: axis.min, max: axis.max, step: o.step || 1 + }); + const node = w.render(); + node.querySelector('select, input').setAttribute('aria-label', label); + const push = () => apply(parseInt(w.getValue(), 10)); + /* `live: false` for an axis whose value moves this control: Content width widens the column the + * page is drawn in, so applying mid-drag slides the handle from under the pointer and one small + * drag runs to the maximum. A keyboard user still applies at once (an arrow key fires `change`). */ + if (o.live !== false) node.addEventListener('widget-update', push); + node.addEventListener('widget-change', push); + return node; + }; + + const colourGroup = (label, axis, probe, contrast, opts = {}) => group(label, (lbl) => { + const ctl = colorControl(bump(axis.apply), lbl, { + probe: probe, + read: axis.current, + contrast: contrast + }); + colourCtls.push(ctl); + return ctl; + }, opts); + + /* Every label here carries the 'footstrap' context: LuCI serves one merged catalogue and the first + * archive holding the hash wins, so a bare msgid is a global name any luci-app can win. */ + + /* ---- section 1: the shell ---- */ + const shell = [ + group(_('Layout', 'footstrap'), (label) => selectCtl(prefs.currentLayout(), { + sidebar: _('Sidebar', 'footstrap'), + top: _('Top', 'footstrap') + }, bump(prefs.applyLayout), label)), + + group(_('Theme', 'footstrap'), (label) => selectCtl(prefs.currentMode(), { + auto: _('Auto', 'footstrap'), + light: _('Light', 'footstrap'), + dark: _('Dark', 'footstrap') + }, bump(prefs.applyMode), label)), + + group(_('Palette', 'footstrap'), (label) => selectCtl(axes.palette.current(), [ + [ 'footstrap', 'Footstrap' ], + [ 'hicontrast', 'Hi-Contrast' ], + [ 'bootstrap', 'Bootstrap' ], + /* names another package, luci-theme-openwrt-2020, whose colourway this is */ + [ '2020', 'OpenWrt 2020' ], + [ 'forum', 'Forum' ] + ], bump(axes.palette.apply), label)), + + group(_('Density', 'footstrap'), (label) => selectCtl(axes.density.current(), { + compact: _('Compact', 'footstrap'), + normal: _('Normal', 'footstrap'), + large: _('Large', 'footstrap') + }, bump(axes.density.apply), label)), + + /* the content column's own cap, separate from Density. The slider starts at the 1280px every + * page was designed against and only widens, which also keeps --fs-content-min (500px, what + * the sidebar-to-bar fold is measured against) out of reach by construction. */ + group(_('Content width', 'footstrap'), + (label) => sliderCtl(axes.contentWidth, bump(axes.contentWidth.apply), label, { step: 40, live: false })), + + group(_('Rounding', 'footstrap'), + (label) => sliderCtl(axes.radius, bump(axes.radius.apply), label)), + + /* always built and hidden by CSS in the top layout (:root[data-layout="top"] .fs-ap-submenus): + * the page is built once, so a currentLayout() branch would freeze it to the layout the page + * loaded in while CSS morphs the chrome live */ + group(_('Submenus', 'footstrap'), (label) => selectCtl( + prefs.currentAutoCollapse() ? 'on' : 'off', { + off: _('Keep open', 'footstrap'), + on: _('Auto-collapse', 'footstrap') + }, bump(prefs.applyAutoCollapse), label), + { cls: 'fs-ap-submenus' }) + ]; + + /* ---- section 2: colours ---- */ + const colours = [ + colourGroup(_('Tint (router identification)', 'footstrap'), axes.tint, 'var(--fs-bg)', { + fg: 'var(--fs-text)', bg: 'var(--fs-bg)', label: _('on the canvas', 'footstrap') + }, { cls: 'fs-ap-tint' }), + + /* the strength half of the Tint, meaningful only in hue mode (a hex canvas has no chroma of + * ours to scale); CSS hides it otherwise. Not named "Density": the string is also the + * aria-label, so a screen reader would announce two rows under one name. */ + group(_('Tint strength', 'footstrap'), + (label) => sliderCtl(axes.tintStrength, bump(repaint(axes.tintStrength.apply)), label, { + step: 5 + }), { cls: 'fs-ap-tint fs-ap-tintstr' }), + + /* Accent recolours the accented controls (buttons, toggles, sliders, focus rings), not the + * canvas; any #rrggbb is taken. Four roles, one shape: the role's colour read as text on a + * card, the use that fails first (as a fill it carries derived ink). The rows are data + * because a string literal repeated eight times is not mangled by the minifier. */ + ...[ + [ _('Accent', 'footstrap'), axes.accent, 'var(--fs-accent)' ], + [ _('Good', 'footstrap'), axes.good, 'var(--fs-good)' ], + [ _('Warning', 'footstrap'), axes.warn, 'var(--fs-warn)' ], + [ _('Danger', 'footstrap'), axes.danger, 'var(--fs-danger)' ] + ].map(([ label, axis, ink ]) => + colourGroup(label, axis, ink, { fg: ink, bg: CARD_BG, label: ON_CARD })) + ]; + + /* The surfaces: the sheet the UI is drawn on. Body text is read on each, so each reports + * --fs-text against itself; no ink is derived, since moving --fs-text would recolour what is + * measured against. The hairline takes the 3:1 UI-component threshold (a border is a shape) and + * the readout states the number and leaves the call to the admin. */ + const surfaces = [ + ...[ + [ _('Cards', 'footstrap'), axes.card, CARD_BG, INK, CARD_BG, ON_CARD ], + [ _('Controls', 'footstrap'), axes.control, 'var(--fs-panel2)', INK, 'var(--fs-panel2)', _('on a control', 'footstrap') ], + [ _('Sidebar and bar', 'footstrap'), axes.bar, 'var(--fs-bar-bg)', INK, 'var(--fs-bar-bg)', _('in the sidebar', 'footstrap') ], + [ _('Borders', 'footstrap'), axes.line, 'var(--fs-border)', 'var(--fs-border)', CARD_BG, ON_CARD, 'shape' ] + ].map(([ label, axis, probe, fg, bg, where, kind ]) => + colourGroup(label, axis, probe, { fg, bg, label: where, kind })) + ]; + + /* ---- section 3: the wallpaper and the rows each value brings ---- + * The rows a value brings are siblings of the Wallpaper row: nested in its `.cbi-value-field` + * they started 216px right of every other control (measured on the router). They are hidden as + * a group, as stock pages do with a dependent field. The select is the per-browser switch that + * keeps the Save button honest; Choose/Remove only swap the picture and never touch the axis. */ + const REMOVE = _('Remove', 'footstrap'); + const wallpaper = (() => { + const err = E('div', { 'class': 'fs-ap-err', 'role': 'alert', 'hidden': '' }); + const preview = E('img', { 'class': 'fs-ap-bgprev', 'alt': '', 'hidden': '' }); + const fileInput = E('input', { 'type': 'file', 'accept': 'image/*', 'style': 'display:none' }); + const chooseLabel = _('Choose image', 'footstrap'); + const chooseBtn = E('button', { 'class': 'btn cbi-button', 'type': 'button' }, [ chooseLabel ]); + const removeBtn = E('button', { 'class': 'btn cbi-button-remove', 'type': 'button', 'hidden': '' }, [ REMOVE ]); + + const patErr = E('div', { 'class': 'fs-ap-err', 'role': 'alert', 'hidden': '' }); + const patPreview = E('img', { 'class': 'fs-ap-bgprev', 'alt': '', 'hidden': '' }); + const patInput = E('input', { 'type': 'file', 'accept': 'image/svg+xml,.svg', 'style': 'display:none' }); + const patChooseLabel = _('Choose SVG', 'footstrap'); + const patChoose = E('button', { 'class': 'btn cbi-button', 'type': 'button' }, [ patChooseLabel ]); + const patRemove = E('button', { 'class': 'btn cbi-button-remove', 'type': 'button', 'hidden': '' }, [ REMOVE ]); + + /* Dim is an ordinary saved axis, so it is bump()-ed or the Save button misreports its status */ + const dimLabel = _('Dim', 'footstrap'); + const scaleLabel = _('Scale', 'footstrap'); + const strengthLabel = _('Strength', 'footstrap'); + const inkLabel = _('Colours', 'footstrap'); + + /* Colours decides whether the file's own palette is kept or replaced by the theme's: a mask + * uses the alpha only, right for line art and wrong for artwork with its own colours. */ + const patRows = [ + group(_('Pattern', 'footstrap'), + () => E('div', { 'class': 'fs-ap-bgrow' }, [ patChoose, patRemove ]), + { extra: [ patInput, patPreview, patErr ] }), + group(scaleLabel, (lbl) => sliderCtl(axes.patternSize, bump(axes.patternSize.apply), lbl, { step: 20 })), + group(strengthLabel, (lbl) => sliderCtl(axes.patternStrength, bump(axes.patternStrength.apply), lbl, { step: 5 })), + group(inkLabel, (lbl) => selectCtl(axes.patternInk.current(), { + theme: _('Theme', 'footstrap'), + original: _('As in file', 'footstrap') + }, bump(axes.patternInk.apply), lbl)) + ]; + const fileRows = [ + group(_('File', 'footstrap'), + () => E('div', { 'class': 'fs-ap-bgrow' }, [ chooseBtn, removeBtn ]), + { extra: [ fileInput, preview, err ] }), + group(dimLabel, (lbl) => sliderCtl(axes.photoDim, bump(axes.photoDim.apply), lbl, { step: 5 })) + ]; + + function reflect(tok) { + if (tok) { preview.src = axes.loginBg.url(tok); preview.hidden = false; removeBtn.hidden = false; } + else { preview.removeAttribute('src'); preview.hidden = true; removeBtn.hidden = true; } + } + function reflectPattern(tok) { + if (tok) { patPreview.src = axes.pattern.url(tok); patPreview.hidden = false; patRemove.hidden = false; } + else { patPreview.removeAttribute('src'); patPreview.hidden = true; patRemove.hidden = true; } + } + /* `hidden` on the row, which base/10-reset.css restates with !important (the UA's bare + * `[hidden]` loses to `.cbi-value`'s display). Hidden, not removed: each row holds a live + * control that a rebuild would freeze to its construction-time state. */ + function togglePanel(v) { + patRows.forEach((r) => { r.hidden = (v !== 'pattern'); }); + fileRows.forEach((r) => { r.hidden = (v !== 'file'); }); + } + reflect(axes.loginBg.current()); + reflectPattern(axes.pattern.current()); + togglePanel(axes.wallpaper.current()); + + const setWallpaper = (v) => { axes.wallpaper.apply(v); refreshSave(); togglePanel(v); }; + + /* Both uploads share one wiring (pick, upload, report, remove) and never move the Wallpaper + * dropdown, which the user may change mid-upload. The input is cleared on every change so + * re-picking the same file fires `change`; the label is restored in `finally`, or a failed + * upload leaves "Uploading…" standing. */ + const wireUploader = (u) => { + const fail = (e) => { u.err.textContent = String((e && e.message) || e); u.err.hidden = false; }; + u.choose.addEventListener('click', () => { u.err.hidden = true; u.input.click(); }); + u.input.addEventListener('change', () => { + const f = u.input.files && u.input.files[0]; + u.input.value = ''; + if (!f) return; + u.err.hidden = true; u.choose.disabled = true; + u.choose.textContent = _('Uploading…', 'footstrap'); + u.upload(f) + .then(u.reflect) + .catch(fail) + .finally(() => { u.choose.disabled = false; u.choose.textContent = u.label; }); + }); + u.remove.addEventListener('click', () => { + u.err.hidden = true; u.remove.disabled = true; + u.drop().then(() => u.reflect('')).catch(fail) + .finally(() => { u.remove.disabled = false; }); + }); + }; + + wireUploader({ + choose: patChoose, remove: patRemove, input: patInput, err: patErr, + label: patChooseLabel, reflect: reflectPattern, + upload: assets.uploadPattern, drop: assets.removePattern + }); + + wireUploader({ + choose: chooseBtn, remove: removeBtn, input: fileInput, err: err, + label: chooseLabel, reflect: reflect, + upload: assets.uploadLoginBg, drop: assets.removeLoginBg + }); + + const wallRow = group(_('Wallpaper', 'footstrap'), (label) => selectCtl(axes.wallpaper.current(), { + off: _('Off', 'footstrap'), + pattern: _('Pattern', 'footstrap'), + file: _('File', 'footstrap') + }, setWallpaper, label)); + + return [ wallRow ].concat(patRows, fileRows); + })(); + + /* ---- section 4: the router default and the version ---- + * Save writes the current look to /etc/config/footstrap over the scoped uci ACL. It does not + * change this browser (localStorage keeps overriding), so it only shows on a fresh browser. */ + /* each label is said twice in build(); hoisted, a msgid is paid once (24 B x2 -> 30 B) */ + const SAVE_TO_ROUTER = _('Save to router', 'footstrap'); + const RESET_TO_ROUTER = _('Reset to router', 'footstrap'); + const RESET_TO_BUILTIN = _('Reset to built-in', 'footstrap'); + const saveBtn = E('button', { 'class': 'btn cbi-button-action', 'type': 'button' }, [ SAVE_TO_ROUTER ]); + /* Two resets, because two things sit underneath a browser's tweaks: "Reset to router" clears them + * and lets every axis fall back to the router, "Reset to built-in" writes the theme's defaults + * explicitly. Neither touches /etc/config/footstrap. "Default" is not a label: it named the + * router's look in "Save as default" and the theme's in "Reset to default", three names for two + * states (forum topic 251930, post 92). */ + const resetSavedBtn = E('button', { 'class': 'btn', 'type': 'button' }, [ RESET_TO_ROUTER ]); + const resetBtn = E('button', { 'class': 'btn cbi-button-negative', 'type': 'button' }, [ RESET_TO_BUILTIN ]); + /* Save's only visible failure surface: the rpc rejecting (expired session 403, missing ACL, ubus + * down). A deleted config is not caught: commit no-ops and returns success (measured on the + * router); the package owns that file and the read side falls back to built-in defaults. */ + const saveErr = E('div', { 'class': 'fs-ap-err', 'role': 'alert', 'hidden': '' }); + + /* The Save button is the status: matching disables it, diverging enables it. A browser that + * refuses storage keeps its choices in fs-prefs's in-memory map, so the comparison stays honest; + * the note waits while a failed Save's error shows, or the .finally below would overwrite it. */ + function refreshSave() { + if (prefs.storageBroken() && saveErr.hidden) { + saveErr.textContent = _('This browser is not storing preferences (site data is blocked), so a change here lasts until you reload. Saving to the router still works and applies to every browser.', 'footstrap'); + saveErr.hidden = false; + } + const saved = axes.matchesSavedDefault(); + saveBtn.disabled = saved; + saveBtn.textContent = saved ? _('Saved to router', 'footstrap') : SAVE_TO_ROUTER; + } + saveBtn.addEventListener('click', () => { + saveBtn.disabled = true; + saveErr.hidden = true; + saveErr.title = ''; /* a stale rpc error would tooltip the storage note (measured: 'ubus code 6' over it) */ + axes.saveAsDefault() + /* on failure refreshSave re-enables the button so the user can retry; the usual cause + * is a stale session, which a reload fixes. The raw rpc error stays in a title + * tooltip. */ + .catch((e) => { + saveErr.textContent = _('Could not save to the router. Reload the page and try again.', 'footstrap'); + saveErr.title = String((e && e.message) || e); + saveErr.hidden = false; + }) + .finally(refreshSave); + }); + /* Two-click confirm on both: discarding local tweaks is destructive and a native confirm() is + * banned in this UI. Arming one disarms the other, so a primed button cannot be fired by a + * click meant for its neighbour. */ + let armed = null; + function disarm() { + if (!armed) return; + armed.btn.textContent = armed.label; + armed.btn.classList.remove('fs-ap-armed'); + armed = null; + } + function twoClick(btn, label, run) { + btn.addEventListener('click', () => { + if (armed && armed.btn === btn) { + disarm(); + run(); + location.reload(); + return; + } + disarm(); + armed = { btn: btn, label: label }; + btn.textContent = _('Confirm reset', 'footstrap'); + btn.classList.add('fs-ap-armed'); + }); + } + twoClick(resetSavedBtn, RESET_TO_ROUTER, axes.resetToSaved); + twoClick(resetBtn, RESET_TO_BUILTIN, axes.resetToBuiltin); + refreshSave(); /* correct label and enabled state before the first paint */ + + const versionLink = E('a', { + 'class': 'fs-ap-version', + 'href': ver.REPO_URL, + 'target': '_blank', + /* `noreferrer` alone: it implies noopener, and the theme's other outward links spell it + * that way */ + 'rel': 'noreferrer' + }, [ ver.label() ]); + + const buttonHelp = E('div', { 'class': 'cbi-value-description' }, [ + _('Save to router — store this look on the router. Browsers with a look of their own keep it.', 'footstrap'), + E('br'), + _('Reset to router — drop this browser\'s changes and follow the router.', 'footstrap'), + E('br'), + _('Reset to built-in — go back to the look the theme ships with.', 'footstrap') + ]); + + const defaults = [ + /* the one row whose control is a pair of buttons, each named by its own text, so `make` + * ignores the caption rather than re-using it as an aria-label */ + group(_('Saved look', 'footstrap'), + () => E('div', { 'class': 'fs-ap-actrow' }, [ saveBtn, E('span', { 'class': 'fs-ap-actgap', 'aria-hidden': 'true' }), resetSavedBtn, resetBtn ]), + { extra: [ buttonHelp, saveErr ] }) + ]; + + + /* The theme's translations are their own packages, and nothing in a package manager can read `uci + * luci.main.lang` to fetch the right one. */ + const lang = (document.documentElement.getAttribute('lang') || '').trim(); + const untranslated = lang && lang !== 'en' && lang !== 'auto' && + _('Layout', 'footstrap') === 'Layout'; + const missing = untranslated ? E('div', { 'class': 'fs-ap-verrow fs-ap-i18n' }, [ + E('span', {}, [ _('This theme is not translated on this router yet.', 'footstrap') + ' ' ]), + E('code', {}, [ 'luci-i18n-footstrap-' + lang ]) + ]) : ''; + + defaults.push(E('div', { 'class': 'fs-ap-footer' }, [ + E('div', { 'class': 'fs-ap-verrow' }, [ versionLink ]), + missing + ])); + + const section = (title, rows) => E('div', { 'class': 'fs-ap-section' }, [ + E('div', { 'class': 'fs-ap-head' }, [ E('h2', {}, [ title ]) ]) + ].concat(rows)); + + /* Folded groups: nine colour fields and an uploader are the widest rows and rarely touched, so + * each group is a closed-by-default disclosure that applies and disables nothing. */ + let foldSeq = 0; + function foldable(title, rows, key) { + const id = 'fs-ap-fold-' + (++foldSeq); + let open = (prefs.lsGet(key) === 'on'); + /* id only: `aria-controls` needs one, and no rule has ever styled the panel itself */ + const body = E('div', { 'id': id }, rows); + const btn = E('button', { + 'type': 'button', 'class': 'fs-ap-fold', 'aria-expanded': String(open), 'aria-controls': id + }, [ + title, + E('span', { 'class': 'fs-ap-chev', 'aria-hidden': 'true' }) + ]); + const paint = () => { + body.hidden = !open; + btn.setAttribute('aria-expanded', String(open)); + }; + btn.addEventListener('click', () => { + open = !open; + prefs.lsSet(key, open ? 'on' : 'off'); + paint(); + if (open) refreshColours(); + }); + paint(); + return E('div', { 'class': 'fs-ap-section' }, [ + E('div', { 'class': 'fs-ap-head' }, [ E('h2', {}, [ btn ]) ]), body + ]); + } + + const note = E('div', { 'class': 'alert-message fs-ap-note' }, [ + E('p', {}, [ _('Footstrap theme settings apply at once and are stored permanently in this browser.', 'footstrap') ]) + ]); + + const page = E('div', { 'class': 'fs-ap' }, [ + note, + section(_('Interface', 'footstrap'), shell), + foldable(_('Colours', 'footstrap'), + colours.concat([ E('div', { 'class': 'fs-ap-head fs-ap-sub' }, [ E('h3', {}, [ _('Surfaces', 'footstrap') ]) ]) ], surfaces), + 'fs-ui-colours'), + foldable(_('Background', 'footstrap'), wallpaper, 'fs-ui-background'), + section(_('Saving', 'footstrap'), defaults) + ]); + + Promise.resolve().then(refreshColours); + + watchColours(refreshColours); + return page; +} + +return baseclass.extend({ + /* the dispatched page's whole render(), called by view/footstrap/appearance.js */ + renderStandalone: () => Promise.resolve().then(build), + + /* test-only: the observer's lifetime is a navigation, which a test can fire and cannot reach + * through build() */ + watchColours, /* fs:probe */ +}); diff --git a/luci-theme-footstrap/htdocs/luci-static/resources/fs-assets.js b/luci-theme-footstrap/htdocs/luci-static/resources/fs-assets.js new file mode 100644 index 00000000..8238907c --- /dev/null +++ b/luci-theme-footstrap/htdocs/luci-static/resources/fs-assets.js @@ -0,0 +1,294 @@ +'use strict'; +'require baseclass'; +'require rpc'; +'require ui'; +'require fs-axes as axes'; + +/* fs-assets — putting a file on the router and taking it off again: the pattern and login-photo uploads, + * the SVG sanitizer, the rollback. A module of its own: only the Appearance page needs these ~4 KB. */ + +/* Hoisted: a string literal is not mangled, so each repeat is paid on flash; msgid stays literal + * for update-po.sh. */ +const MSG_UPLOAD_FAILED = _('Upload failed.', 'footstrap'); +const MSG_NOT_SVG = _('That file is not an SVG image.', 'footstrap'); +const MSG_BAD_IMAGE = _('Could not process the image.', 'footstrap'); +const MSG_PICK_SVG = _('Please choose an SVG file.', 'footstrap'); +/* One template, two numbers: a translator places both %d in one sentence instead of agreeing + * plurals. */ +const MSG_SANITIZED = _('Cleaned before upload: removed %d unsafe element(s) and %d external reference(s).', 'footstrap'); +const MSG_NOTHING_LEFT = _('That SVG had nothing left once the unsafe parts were removed.', 'footstrap'); + +/* ---- the pattern: an SVG the admin uploads, tiled and recoloured ---- + * Fixed path matched by the rpcd ACL, under /etc so an upgrade keeps it. Not the security boundary: a + * `curl` to cgi-upload skips every check below; a direct open is stopped by the CGI's + * `Content-Security-Policy: default-src 'none'; sandbox`. */ +const PAT_PATH = '/etc/footstrap/pattern.svg'; /* cgi-upload target; the ACL grants exactly this */ +const PAT_MAX = 512 * 1024; /* a tile that has to reach a router's flash and then every page load */ +/* What `_sanitizeSvg` removes, judged on the parsed document, not the text. Painted as an image nothing + * loads; these rules cover a direct open of the file: + * - elements: only the SVG namespace stays (`` ran same-origin), minus + * script, foreignObject, a ` + {% endif %} + + + {# + Lets an admin install this page as an app (icon, own window, no address bar), worth more + than a tab on the phone LuCI is opened from when the network is broken. Both files are + static, a theme having no dispatcher node to render them per request: start_url is + /cgi-bin/luci/, uhttpd's default (a moved LuCI opens the standard path), and + background/theme_color is the default palette's page colour, read once at install time. + .json, not .webmanifest: uhttpd's compiled-in MIME map has no entry for that extension, + so it answers application/octet-stream. + #} + + {# + iOS reads this link and never the manifest's icons array, and it scales the 192 square the + manifest also uses down to its own 180. One raster serves both. + #} + + {% if (dispatched?.css): %} + {# + The `css` property of the dispatched menu.d node: a stylesheet the server links for the + page instead of the view injecting one at module eval. `dispatched`, not `node`: the + dispatcher exports the resolved node as `dispatched` and never binds `node`, so no ucode + theme emitted this link until openwrt/luci#8920. That commit also adds `css: 'string'` to + the node schema; without it the property is filtered out and this stays false, as on 24.10 + and 25.12. Versioned, as uhttpd sends no Cache-Control. Not `data-fs-shell`: the sheet + belongs to one page, so the SPA router must judge and contain it like any app sheet. + #} + + {% endif %} + {% if (css): %} + {# + no `title` attribute: on a + {% endif %} + {# + The catalogue is a CGI spawn on the critical path (30 ms on the router) that delivers 13 + bytes at lang=en, where no en catalogue exists because the msgids already are English. + The process is the cost, so emit those bytes inline when the language has no catalogue + and keep the tag when it has. The probe mirrors the server: load_catalog() reads every + `*..lmo` in /usr/lib/lua/luci/i18n, so a router shipping an en catalogue still gets + the tag; deciding by language NAME would drop it. Fails open: a throwing probe keeps the + tag, as a missing catalogue renders English and reports nothing. + #} + {%- let has_catalog = true; + try { has_catalog = length(require('fs').glob(`/usr/lib/lua/luci/i18n/*.${dispatcher.lang}.lmo`)) > 0; } catch (e) {} %} + {% if (has_catalog): %} + + {% else %} + + {% endif %} + {# + the one asset stock LuCI leaves without a cache key. Must stay synchronous and un-deferred: + luci.js captures `window.cbi_init` in its constructor, and `defer` is not an option for the + catalogue above either — footer.ut runs `L.require('menu-footstrap')` inline while the + parser is still running, so a module's `_()` would race a deferred window.TR. + #} + + diff --git a/luci-theme-footstrap/ucode/template/themes/footstrap/partials/notice.ut b/luci-theme-footstrap/ucode/template/themes/footstrap/partials/notice.ut new file mode 100644 index 00000000..c6227eab --- /dev/null +++ b/luci-theme-footstrap/ucode/template/themes/footstrap/partials/notice.ut @@ -0,0 +1,16 @@ +{# + One top-of-content warning notice: heading, sentence and an optional "go fix it" button. The + `dispatcher.lookup` guard must not drift: `path` is looked up before it is linked, so a build + without that page, or a user without rights to it, gets the warning and no dead link. + include(…, { title, text }) for a plain notice; add { path, label } for the button. + title/text are emitted unescaped: they are `_()` results over strings this theme ships, not + request data. + Licensed to the public under the Apache License 2.0. +-#} +
+

{{ title }}

+

{{ text }}

+ {% if (path && dispatcher.lookup(path)): %} +
{{ label }}
+ {% endif %} +
diff --git a/luci-theme-footstrap/ucode/template/themes/footstrap/sysauth.ut b/luci-theme-footstrap/ucode/template/themes/footstrap/sysauth.ut new file mode 100644 index 00000000..f10e7cb7 --- /dev/null +++ b/luci-theme-footstrap/ucode/template/themes/footstrap/sysauth.ut @@ -0,0 +1,186 @@ +{# + The LOGIN page. + + Copyright 2008 Steven Barth + Copyright 2008-2012 Jo-Philipp Wich + Licensed to the public under the Apache License 2.0. + + It exists because the generic template includes the header WITHOUT `blank_page: true`: with no + theme-local sysauth the whole chrome renders around the login form with every control dead. + No departure here may drop a field the backend posts. + Do not re-introduce a `