@vectoriox/iox-ui 5.22.0 → 5.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectoriox/iox-ui",
-  "version": "5.22.0",
+  "version": "5.23.0",
   "peerDependencies": {
     "@angular/common": ">=20.0.0",
     "@angular/core": ">=20.0.0",

package/src/design-core/design-apply.ts

@@ -2,7 +2,7 @@ import { deriveBrandTokens } from './brand';
 import { SPEC_LEGACY_ALIASES } from './flavor-spec.generated';
 import { SWISS_FLAVOR } from './flavor';
 import { buildFlavorTokens } from './flavor-tokens';
-import { FlavorSeedPlan, planFlavorSeed, SeedBaseline, SeedExpectation } from './flavor-seed';
+import { FlavorRevertPlan, FlavorSeedPlan, planFlavorRevert, planFlavorSeed, SeedBaseline, SeedExpectation } from './flavor-seed';
 import { DesignChoices, DesignTokenRow, flavorSourceStamp, StoredDesignTokenRow } from './design-token.model';
 import { fontFamilyKey, FontFamilyToken, fontRoleReferences, parseFontFamilies } from './fonts';
 import { flavorPackById, isRetiredFlavorId, packDesignChoices, StoredDesign } from './design-settings';
@@ -65,6 +65,19 @@ export function planDesignApply(
     return planFlavorSeed(designTokenRows(next), existing, flavorSourceStamp(pack.id), designBaseline(previous));
 }
 
+/**
+ * "Revert to previous look" over the org's rows — the ONE plan the Revert executes and its hint counts
+ * (`kept`: the author's edits since the apply, left as they are). The apply's record of what it wrote
+ * decides what an edit since is; a snapshot stored before that record existed (DS8.1) is judged against
+ * the rows the applied design writes — the look's own author rows (a chosen font) still go back.
+ * `null` when the design holds no snapshot.
+ */
+export function planDesignRevert(current: ReadonlyArray<StoredDesignTokenRow>, design: StoredDesign): FlavorRevertPlan | null {
+    const snapshot = design?.revert;
+    if (!snapshot) return null;
+    return planFlavorRevert(current, snapshot.tokens, snapshot.wrote ?? designTokenRows(design.choices));
+}
+
 /** The rows a design is missing by name — the builder-load top-up (never touches an existing row). */
 export function missingDesignRows(existing: ReadonlyArray<{ name: string }>, choices: DesignChoices): DesignTokenRow[] {
     const have = new Set((existing ?? []).map(r => r.name));

package/src/design-core/flavor-seed.ts

@@ -25,13 +25,21 @@ export interface FlavorRevertSnapshot {
     /** The design row's identity BEFORE the apply, restored with the tokens. */
     from: { flavorId: string | null; flavorVersion: string | null; brandSeed: string | null };
     tokens: Array<Pick<DesignTokenRow, 'name' | 'type' | 'value' | 'values' | 'source' | 'group' | 'tier'>>;
+    /** What the apply left in every row it wrote (`flavorSeedWrites`). A row holding something else
+     *  since, as the author's (`source: user`), was edited AFTER the apply — the revert keeps it. */
+    wrote?: FlavorRevertWrite[];
 }
 
+/** One row as an apply left it — the value and dark half the revert compares a live row against. */
+export type FlavorRevertWrite = Pick<DesignTokenRow, 'name' | 'value' | 'values'>;
+
 export interface FlavorRevertPlan {
     create: DesignTokenRow[];
     update: Array<{ id: string; data: Partial<DesignTokenRow> }>;
     /** Rows the apply created (flavor-stamped, absent from the snapshot) — removed on revert. */
     remove: string[];
+    /** The author's edits made after the apply, left as they are (names) — what the Revert hint counts. */
+    kept: string[];
 }
 
 export const REVERT_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
@@ -49,19 +57,30 @@ export function revertAvailable(appliedAt: number | null | undefined, now: numbe
 }
 
 /**
- * Restore the snapshot EXACTLY: snapshot rows come back to their stored value/dark/source
- * (update when present, recreate when deleted); rows the apply CREATED (flavor-stamped and
- * absent from the snapshot) are removed. Hand-made rows born after the apply are not ours
- * to touch — a revert undoes the FLAVOR, not the author's week.
+ * Restore the snapshot: snapshot rows come back to their stored value/dark/source (update when
+ * present, recreate when deleted); rows the apply CREATED (flavor-stamped and absent from the
+ * snapshot) are removed. A revert undoes the FLAVOR, not the author's week: hand-made rows born after
+ * the apply are not touched, and a row the author EDITED after the apply is kept (DS8: an edit makes
+ * the row the author's, and a pack switch keeps it — so does going back). Edited-after = `source: user`,
+ * differing from the snapshot, and holding something other than what the apply wrote (`wrote` — the
+ * apply's own author rows, a chosen font or an Element-styles edit, still go back with it). With no
+ * `wrote` at all, every author row that differs from the snapshot is judged edited after.
  */
 export function planFlavorRevert(
     current: ReadonlyArray<StoredDesignTokenRow>,
     snapshot: FlavorRevertSnapshot['tokens'],
+    wrote?: ReadonlyArray<FlavorRevertWrite> | null,
 ): FlavorRevertPlan {
     const byName = new Map<string, StoredDesignTokenRow>();
     for (const row of current ?? []) byName.set(row.name, row);
+    const written = new Map((wrote ?? []).map(w => [w.name, w]));
+    const editedAfter = (live: StoredDesignTokenRow) => {
+        if (live.source !== USER_TOKEN_SOURCE) return false;
+        const w = written.get(live.name);
+        return !w || !sameValue(live, { value: w.value, dark: w.values?.dark });
+    };
     const snapNames = new Set<string>();
-    const plan: FlavorRevertPlan = { create: [], update: [], remove: [] };
+    const plan: FlavorRevertPlan = { create: [], update: [], remove: [], kept: [] };
     for (const snap of snapshot ?? []) {
         snapNames.add(snap.name);
         const live = byName.get(snap.name);
@@ -72,18 +91,33 @@ export function planFlavorRevert(
         const differs = live.value !== snap.value
             || (live.values?.dark ?? null) !== (snap.values?.dark ?? null)
             || (live.source ?? null) !== (snap.source ?? null);
+        if (!differs || !live._id) continue;
+        if (editedAfter(live)) { plan.kept.push(live.name); continue; }
         // `values` is ALWAYS sent: an absent key is dropped by JSON and a `$set` then keeps the
         // apply's dark override — a snapshot row with no dark must clear it, so it sends `{}`.
-        if (differs && live._id) {
-            plan.update.push({ id: live._id, data: { value: snap.value, values: snap.values ?? {}, source: snap.source } });
-        }
+        plan.update.push({ id: live._id, data: { value: snap.value, values: snap.values ?? {}, source: snap.source } });
     }
     for (const row of current ?? []) {
-        if (!snapNames.has(row.name) && row._id && isSeeded(row)) plan.remove.push(row._id);
+        if (snapNames.has(row.name) || !row._id) continue;
+        if (isSeeded(row)) plan.remove.push(row._id);
+        else if (written.has(row.name) && editedAfter(row)) plan.kept.push(row.name);
     }
     return plan;
 }
 
+/** What a seed plan leaves in each row it writes, by name — the snapshot's `wrote`. */
+export function flavorSeedWrites(plan: FlavorSeedPlan, existing: ReadonlyArray<StoredDesignTokenRow>): FlavorRevertWrite[] {
+    const byId = new Map((existing ?? []).filter(r => r._id).map(r => [r._id as string, r]));
+    const out: FlavorRevertWrite[] = (plan?.create ?? []).map(r => ({ name: r.name, value: r.value, ...(r.values ? { values: r.values } : {}) }));
+    for (const u of plan?.update ?? []) {
+        const row = byId.get(u.id);
+        if (!row) continue;
+        const values = u.data.values ?? row.values;
+        out.push({ name: row.name, value: u.data.value ?? row.value, ...(values ? { values } : {}) });
+    }
+    return out;
+}
+
 /** What a previous seed wrote for one row — the "untouched" comparison base. */
 export interface SeedExpectation {
     value: string;