@takazudo/zdtp 0.7.0 → 0.8.1

package/dist/state/tweak-state.d.ts

@@ -495,9 +495,10 @@ export declare function initColorFromScheme(cluster?: ColorClusterDataConfig, cf
  */
 export declare function getActiveColorIdentity(cluster?: ColorClusterDataConfig, cfg?: PanelConfig): string;
 /**
- * Palette entry sanitiser. Raw `oklch(...)` values are preserved verbatim so
+ * Palette entry sanitiser. Complete `light-dark(...)` pairs and raw `oklch(...)`
+ * values are preserved verbatim so mode defaults and
  * wide-gamut chroma survives (and they never touch the canvas → no '#000000'
- * under jsdom / engines whose 2D canvas can't parse oklch). Every NON-oklch entry
+ * under jsdom / engines whose 2D canvas can't parse oklch). Other entries
  * goes through cssColorToHex() — the exact pre-OKLCH behaviour — which
  * canonicalises valid hex/rgb and, crucially, turns an unparseable string into a
  * safe '#000000' rather than leaking it into a CSS custom property. Without this,
@@ -559,6 +560,13 @@ export declare function resolvePerModeLiteral(value: {
  * default-mode color, while the applied CSS var still emits `light-dark()`.
  */
 export declare function resolveSemanticPreviewColor(mapping: SemanticValue, state: ColorTweakState, cluster?: ColorClusterDataConfig, currentTab?: TabConfig, tabs?: readonly TabConfig[]): string;
+/**
+ * Apply only explicit manifest mode pairs, without painting scheme seeds or
+ * changing other host declarations. Used at cold start and after Reset All.
+ * `colorOnly` restores color defaults when the active scheme has no saved slot;
+ * the independent generic-tab overrides remain applied by their normal path.
+ */
+export declare function applyManifestModeDefaults(cfg?: PanelConfig, colorOnly?: boolean): void;
 /**
  * Apply a single `ColorTweakState` to the DOM using the given cluster config.
  *
@@ -616,8 +624,11 @@ export declare function applyTokenOverrides(tokens: readonly TokenDef[], overrid
  * instance actually wrote (`clearOwnedColorSchemeFromDocument`) so a host that
  * owns `<html style="color-scheme">` is never clobbered; the sink path stays
  * unconditional (sink targets are panel-owned) but drops the ownership claim.
+ * A color-only pass preserves the fallback serving generic manifest mode rows.
+ * `applyFullState` disables that preservation because its following generic
+ * pass resolves whether those rows have active single-color overrides.
  */
-export declare function applyColorSlices(color: ColorTweakState, secondary: ColorTweakState | undefined, cfg?: PanelConfig): void;
+export declare function applyColorSlices(color: ColorTweakState, secondary: ColorTweakState | undefined, cfg?: PanelConfig, preserveNonColorModes?: boolean): void;
 /**
  * Apply the full unified `TweakState` — primary color cluster + token
  * overrides + optional secondary cluster.
@@ -636,10 +647,9 @@ export declare function applyColorSlices(color: ColorTweakState, secondary: Colo
  */
 export declare function applyFullState(state: TweakState, cfg?: PanelConfig): void;
 /**
- * Apply ONLY the non-color slices (spacing / typography / size / generic-tab
- * overrides), leaving the color clusters and aggregate `color-scheme` decision
- * untouched. Complement of `applyColorSlices`; together they compose
- * `applyFullState`.
+ * Apply the non-color slices (spacing / typography / size / generic-tab
+ * overrides), plus explicit manifest color mode defaults. Dense scheme seeds
+ * remain untouched, while mode pairs receive the required color-scheme fallback.
  *
  * Extracted (#509 audit) so the persisted-overrides reapply paths
  * (`reapplyPersistedOverrides`, the panel first-open effect) can, when a v4

package/dist/tabs/_generic-item-editor.d.ts

@@ -17,6 +17,9 @@ export interface GenericItemEditorProps {
     value: string;
     /** Called with (itemId, newValue). */
     onChange: (itemId: string, next: string) => void;
+    /** Stored override, if any. Distinct from `value` so a loaded override
+     *  equal to `item.default` still wins over the manifest pair. */
+    override?: string;
 }
 declare function GenericItemEditor(props: GenericItemEditorProps): import("preact").JSX.Element;
 declare const _default: typeof GenericItemEditor;

package/dist/tabs/modes-row.d.ts

@@ -0,0 +1,58 @@
+import type { ComponentChildren } from 'preact';
+import type { TierItem } from "../tokens/tier-model.js";
+import type { TokenAddress } from "./flat/types.js";
+export interface ModeSides {
+    light: string;
+    dark: string;
+}
+/**
+ * Resolve the pair shown by a mode row. A stored override is an effective
+ * value, so a complete light-dark() override is split for display and a
+ * plain override is shown on both sides. With no override the manifest pair
+ * is authoritative; this keeps the presentation independent of the ordinary
+ * `default` fallback used by generic consumers.
+ */
+export declare function resolveModeRowSides(item: TierItem, value?: string, preferValue?: boolean): ModeSides;
+export interface ModesValuePairProps {
+    sides: ModeSides;
+    /** Prefix used for stable test and automation selectors. */
+    testIdPrefix?: string;
+}
+/** Render the two authored values with mode-labelled swatches. */
+export declare function ModesValuePair({ sides, testIdPrefix }: ModesValuePairProps): import("preact").JSX.Element;
+/**
+ * Commit one side of a mode pair as `light-dark(light, dark)`. The untouched
+ * side is copied byte-for-byte so a mixed-format pair such as
+ * `light-dark(rgb(10, 20, 30), oklch(0.8 0.1 240))` keeps the other side's
+ * authored syntax.
+ */
+export declare function commitModePair(sides: ModeSides, side: keyof ModeSides, next: string): string;
+export interface ModesEditorFieldsProps {
+    item: TierItem;
+    sides: ModeSides;
+    onChange: (next: string) => void;
+}
+/**
+ * Compact light/dark ColorField pair for a manifest `modes` row. Palette Check
+ * reuses this without ModesRow chrome. Manifest `modes` is always a pair — no
+ * SemanticLiteralRow "Per-mode" checkbox.
+ */
+export declare function ModesEditorFields({ item, sides, onChange }: ModesEditorFieldsProps): import("preact").JSX.Element;
+export interface ModesRowProps {
+    item: TierItem;
+    sides?: ModeSides;
+    className?: string;
+    dataTestId?: string;
+    address?: TokenAddress;
+    leading?: ComponentChildren;
+    trailing?: ComponentChildren;
+    tail?: ComponentChildren;
+    /** Parents close over address/ids. Absent or a readonly item keeps chips. */
+    onChange?: (next: string) => void;
+}
+/**
+ * Row for a manifest `modes` item. With `onChange` (and not readonly) the pair
+ * is edited via `ModesEditorFields`; otherwise chips stay and the row keeps
+ * `tokenpanel-row--editor-disabled` while retaining ordinary row actions.
+ */
+export declare function ModesRow({ item, sides, className, dataTestId, address, leading, trailing, tail, onChange, }: ModesRowProps): import("preact").JSX.Element;

package/dist/tabs/palette/palette-check-view.d.ts

@@ -9,4 +9,4 @@ export interface PaletteCheckViewProps {
     changedOnly?: boolean;
     isChanged?: (address: TokenAddress) => boolean;
 }
-export default function PaletteCheckView({ tab, overrides, searchQuery, changedOnly, isChanged, }: PaletteCheckViewProps): import("preact").JSX.Element;
+export default function PaletteCheckView({ tab, overrides, onChange, searchQuery, changedOnly, isChanged, }: PaletteCheckViewProps): import("preact").JSX.Element;

package/dist/testing.js

@@ -1,5 +1,5 @@
-import { _ as r, b as i, c as n, d as _, e as g, f as l, h as R, a as f } from "./panel-config-Crn5QJGy.js";
-import { a as P, b as y, l as O } from "./tweak-state-Dhjqig0C.js";
+import { _ as r, b as i, c as n, d as _, e as g, f as l, h as R, a as f } from "./panel-config-DKfob-1r.js";
+import { a as P, b as y, l as O } from "./tweak-state-BiaKbhXN.js";
 import { F as E, G as S, a as V, S as d } from "./manifest-DvuKi7I4.js";
 async function s(a, e) {
   await a.fill(e), await a.dispatchEvent("input");

package/dist/tokens/mode-dependence.d.ts

@@ -0,0 +1,23 @@
+import type { SemanticValue, TierItem } from "./tier-model.js";
+interface ModeSides {
+    light: string;
+    dark: string;
+}
+/**
+ * Split a complete `light-dark(light, dark)` declaration into its two
+ * top-level arguments.
+ *
+ * The scanner deliberately understands nested parentheses so values such as
+ * `light-dark(rgb(0, 0, 0), #fff)` remain a single pair. It only recognizes a
+ * single outer call: a second top-level value, an extra argument, an
+ * unbalanced parenthesis, or a nested `light-dark()` call is rejected.
+ */
+export declare function splitLightDark(value: string): ModeSides | null;
+/**
+ * Resolve the direct mode pair for one item. References are propagated by
+ * consumers that have the surrounding token graph; this helper covers the
+ * item, semantic-literal, and parsed-default precedence rules.
+ */
+export declare function resolveModeSides(item: TierItem, semanticOverride?: SemanticValue): ModeSides | null;
+export declare function isModeDependent(item: TierItem, semanticOverride?: SemanticValue): boolean;
+export {};

package/dist/tokens/tier-model.d.ts

@@ -100,6 +100,15 @@ export interface TierItem {
     label: string;
     default: string;
     type: TierValueKind;
+    /**
+     * Optional light/dark color pair for a mode-dependent row. Both sides are
+     * CSS colors because downstream emission uses `light-dark()`. The ordinary
+     * `default` remains the fallback value used by non-mode consumers.
+     */
+    modes?: {
+        light: string;
+        dark: string;
+    };
     pill?: PillSpec;
     readonly?: true;
 }