dsh-background-by-model 0.5.4 → 0.6.0

package/lib/index.js

@@ -1,6 +1,50 @@
 import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+//#region src/holiday.ts
+const HOLIDAYS = [{
+	id: "mid-autumn",
+	slot: "h-midautumn",
+	asset: "mid-autumn.webp",
+	color: "#384A77",
+	kind: "lunar"
+}, {
+	id: "national-day",
+	slot: "h-nationalday",
+	asset: "national-day.webp",
+	color: "#FFF6EB",
+	kind: "gregorian"
+}];
+//#endregion
 //#region src/schema.ts
+/**
+* The persisted configuration shape — declared exactly ONCE, for both halves.
+*
+* This shape used to be written out twice: the node half owns persistence and
+* sanitizes every write, the browser half owns the UI and its own reading of the
+* same file. A field added to only one side was silently dropped by the other
+* side's sanitizer — the matching slider stayed live in memory, `writeConfig`
+* wrote a config without it, and the next load fell back to the default.
+* `blurs.rightbar` / `rightbarOpacity` in 0.3.2 was exactly that bug, and the key
+* lists were duplicated 6 times across the two halves, so it was due to happen.
+*
+* The types, the key lists, the defaults and the pure normalizers therefore live
+* here and both halves import them: adding a field means editing this file, and
+* the two halves cannot disagree about the shape. The host additionally logs one
+* warning per unknown key while sanitizing a write (see `warnUnknownConfigKeys`
+* in `src/index.ts`), so a field that reaches the node half without being
+* declared here shows up in the host log instead of quietly disappearing.
+*
+* Nothing in this module may touch the DOM, Node or the Cordis context: it is
+* imported by the browser bundle and by the node half alike.
+*/
+const DEFAULT_BG_STATE = {
+	zoom: 1,
+	x: 0,
+	y: 0,
+	iw: 0,
+	ih: 0
+};
 /** Every accepted `bgMode`, in UI order. */
 const BG_MODES = [
 	"fit",
@@ -60,6 +104,63 @@ const DEFAULT_PART_BLURS = {
 	rightbar: 0,
 	input: 0
 };
+/**
+* `#RRGGBB` → the `[h, s, l]` triple every rule stores (`s` and `l` in 0..1), or
+* null when the string is not a hex color.
+*
+* A holiday names its color as hex because that is how a color is quoted, and a
+* hand-converted triple is a magic number nothing downstream can check. The
+* conversion lives here rather than in ./holiday because `[h, s, l]` is this
+* module's own rule shape.
+*/
+function hexToHsl(hex) {
+	const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+	if (m === null) return null;
+	const n = parseInt(m[1], 16);
+	const r = (n >> 16 & 255) / 255;
+	const g = (n >> 8 & 255) / 255;
+	const b = (n & 255) / 255;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const l = (max + min) / 2;
+	const d = max - min;
+	if (d === 0) return [
+		0,
+		0,
+		l
+	];
+	const s = d / (1 - Math.abs(2 * l - 1));
+	let h;
+	if (max === r) h = 60 * ((g - b) / d % 6);
+	else if (max === g) h = 60 * ((b - r) / d + 2);
+	else h = 60 * ((r - g) / d + 4);
+	if (h < 0) h += 360;
+	return [
+		clamp(h, 0, 360, 0),
+		clamp01(s, 0),
+		clamp01(l, .5)
+	];
+}
+/**
+* One holiday's appearance, untouched.
+*
+* Holidays default to `fill` rather than a rule's `fit`: these are full-bleed
+* festival wallpapers, and `fit` would letterbox them on every aspect ratio the
+* art was not cut for.
+*/
+function defaultHolidayRule(def) {
+	return {
+		id: def.id,
+		slot: def.slot,
+		match: "",
+		enabled: true,
+		color: hexToHsl(def.color),
+		bgMode: "fill",
+		wallpaperOpacity: 1,
+		blur: 0,
+		bgState: { ...DEFAULT_BG_STATE }
+	};
+}
 /** Slot names reach the filesystem, so they are strictly whitelisted. */
 const SLOT_RE = /^[A-Za-z0-9_-]{1,32}$/;
 function clamp(n, lo, hi, def) {
@@ -105,6 +206,41 @@ function normalizeRule(raw) {
 		bgState: normalizeBgState(r.bgState)
 	};
 }
+/**
+* Coerce one persisted holiday entry.
+*
+* `id`, `slot` and `color` come from the DEFINITION, never from disk: a holiday's
+* slot is the only thing tying it to its bytes, and its theme color is a fixed
+* part of what that holiday looks like — so a stale or hand-edited value would
+* either orphan the wallpaper, point the holiday at a rule's image, or paint a
+* festival in a color it does not have. Everything else is sanitized exactly like
+* a rule's field.
+*/
+function normalizeHolidayRule(def, raw) {
+	const r = raw ?? {};
+	const base = defaultHolidayRule(def);
+	return {
+		...base,
+		enabled: r.enabled !== false,
+		bgMode: BG_MODES.includes(r.bgMode) ? r.bgMode : base.bgMode,
+		wallpaperOpacity: clamp01(r.wallpaperOpacity, base.wallpaperOpacity),
+		blur: clamp(r.blur, 0, 60, base.blur),
+		bgState: normalizeBgState(r.bgState)
+	};
+}
+/** Coerce the whole holiday block; unknown ids are dropped, missing ones defaulted. */
+function normalizeHolidays(raw) {
+	const r = raw ?? {};
+	const stored = /* @__PURE__ */ new Map();
+	if (Array.isArray(r.items)) for (const item of r.items) {
+		const id = item?.id;
+		if (typeof id === "string") stored.set(id, item);
+	}
+	return {
+		enabled: r.enabled !== false,
+		items: HOLIDAYS.map((def) => normalizeHolidayRule(def, stored.get(def.id)))
+	};
+}
 /** Coerce an unknown persisted value into a valid ThemeConfig, falling back per-field. */
 function normalizeConfig(raw) {
 	const r = raw ?? {};
@@ -123,7 +259,8 @@ function normalizeConfig(raw) {
 		chatTextOpacity: clamp01(r.chatTextOpacity, 0),
 		trajectoryOpacity: clamp01(r.trajectoryOpacity, 1),
 		rightbarOpacity: typeof r.rightbarOpacity === "number" && isFinite(r.rightbarOpacity) ? clamp01(r.rightbarOpacity, 1) : null,
-		autoExtract: r.autoExtract !== false
+		autoExtract: r.autoExtract !== false,
+		holidays: normalizeHolidays(r.holidays)
 	};
 }
 //#endregion
@@ -294,17 +431,52 @@ function sniffImageMime(buf) {
 	if (buf.length >= 2 && buf[0] === 66 && buf[1] === 77) return "image/bmp";
 	return "image/jpeg";
 }
-/** Read one rule image as a data URL, or null when the slot is empty. */
+/**
+* Read one slot as a data URL, or null when it has nothing to serve.
+*
+* A holiday slot is answered from the package and from nowhere else — the data
+* directory is never consulted for it, which is what makes the festival art
+* impossible to swap. Everything else is the user's own bytes. Both are resolved
+* lazily, so nothing about the bundled art is loaded — or even looked for — until
+* a holiday actually reaches for it.
+*/
 async function readImage(slot) {
+	const asset = bundledAssetFor(slot);
+	if (asset !== null) {
+		const bundled = await readFileOrNull(bundledAssetPath(asset));
+		return bundled === null ? null : toDataUrl(bundled);
+	}
+	const own = await readFileOrNull(imagePath(slot));
+	return own === null ? null : toDataUrl(own);
+}
+async function readFileOrNull(path) {
 	try {
-		const buf = await readFile(imagePath(slot));
-		return `data:${sniffImageMime(buf)};base64,${buf.toString("base64")}`;
+		return await readFile(path);
 	} catch {
 		return null;
 	}
 }
+function toDataUrl(buf) {
+	return `data:${sniffImageMime(buf)};base64,${buf.toString("base64")}`;
+}
+/** Absolute path of one wallpaper bundled inside the package. */
+function bundledAssetPath(asset) {
+	return fileURLToPath(new URL(`../holiday/${asset}`, import.meta.url));
+}
+/**
+* The wallpaper bundled for one slot, or null when the slot is not a holiday's.
+*
+* This mapping is the ONLY thing that makes a holiday slot read-only and
+* package-served, so both `readImage` and `writeImage` go through it rather than
+* each testing the holiday list on their own. It reads no config: the bundled art
+* has stopped being a fallback that a flag could disable.
+*/
+function bundledAssetFor(slot) {
+	return HOLIDAYS.find((h) => h.slot === slot)?.asset ?? null;
+}
 /** Persist one rule image (null removes it); false keeps the previous file. */
 async function writeImage(slot, dataUrl) {
+	if (bundledAssetFor(slot) !== null) return false;
 	await ensureDir();
 	try {
 		if (dataUrl === null) {
@@ -333,6 +505,10 @@ async function listSlots() {
 * Returns { ok, dataUrl?, error? }; never throws.
 */
 async function fetchImageUrl(slot, url) {
+	if (bundledAssetFor(slot) !== null) return {
+		ok: false,
+		error: "read-only slot"
+	};
 	if (url === null) {
 		const ok = await writeImage(slot, null);
 		return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-background-by-model",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Appearance plugin for DeepSeek Harness: an ordered list of model rules, each carrying its own wallpaper, theme color, layout mode, opacity and blur — the background follows the model you switch to.",
   "keywords": [
     "deepseek-harness",
@@ -49,13 +49,17 @@
     "CHANGELOG.md",
     "CHANGELOG.zh.md",
     "cordis.patch.yml",
-    "example_img"
+    "example_img",
+    "holiday"
   ],
   "scripts": {
     "bundle": "tsdown",
     "watch": "tsdown --watch",
     "typecheck": "tsc -p tsconfig.json",
-    "test": "tsdown && tsc -p tsconfig.json"
+    "check:holiday": "node scripts/holiday-check.ts",
+    "check:ui": "node scripts/ui-strings-check.ts",
+    "check:node": "node scripts/node-half-check.mjs",
+    "test": "tsdown && tsc -p tsconfig.json && node scripts/holiday-check.ts && node scripts/ui-strings-check.ts && node scripts/node-half-check.mjs"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6",