@takazudo/zdtp 0.4.13 → 0.4.15

package/dist/tabs/color-tab.d.ts

@@ -39,6 +39,7 @@ import type { TabOverrides } from '../apply/tier-resolver';
 import { type PanelConfig } from '../config/panel-config';
 import type { TabConfig } from '../tokens/tier-model';
 import type { PersistColor, PersistSecondary } from '../state/persist';
+import { type TokenAddress } from './flat/types';
 interface ColorTabProps {
     /**
      * The color tab's TabConfig. Provides palette + semantic tiers and
@@ -67,6 +68,14 @@ interface ColorTabProps {
     instanceConfig?: PanelConfig;
     /** Live generic-tab overrides used by ramp preview chips and option labels. */
     tabOverrides?: Record<string, TabOverrides>;
+    /** Header-filter query applied to palette and semantic rows. */
+    searchQuery?: string;
+    /** S2 evaluator callback supplied by the mounted panel shell. */
+    isChanged?: (address: TokenAddress) => boolean;
+    /** Transient active-tab Changed-only filter. */
+    changedOnly?: boolean;
+    /** Shell transaction callback for one-row revert. */
+    onRevert?: (address: TokenAddress) => void;
 }
-export default function ColorTab({ tab, state, persistColor, secondaryTab, secondaryState, persistSecondary, instanceConfig, tabOverrides, }: ColorTabProps): import("preact").JSX.Element;
+export default function ColorTab({ tab, state, persistColor, secondaryTab, secondaryState, persistSecondary, instanceConfig, tabOverrides, searchQuery, isChanged, changedOnly, onRevert, }: ColorTabProps): import("preact").JSX.Element;
 export {};

package/dist/tabs/flat/flat-tab.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentChildren } from 'preact';
+import { type BulkPatchEntry } from '../../bulk';
+import type { TabOverrides } from '../../apply/tier-resolver';
+import type { TabConfig, TierConfig, TierItem } from '../../tokens/tier-model';
+import { type SharedRowRenderer } from './tier-section';
+import type { RowContribution, TokenAddress } from './types';
+export interface FlatTabProps {
+    tab: TabConfig;
+    getValue: (address: TokenAddress, item: TierItem) => string;
+    setValue: (address: TokenAddress, next: string) => void;
+    deleteValue: (address: TokenAddress) => void;
+    overrides?: TabOverrides;
+    contributions?: readonly RowContribution[];
+    /** Header-filter query; implemented as an S3 row contribution. */
+    searchQuery?: string;
+    /** Transient S7 Changed-only filter; never persisted. */
+    changedOnly?: boolean;
+    actions?: ComponentChildren;
+    className?: string;
+    testId?: string;
+    sectionTestId?: (tier: TierConfig) => string;
+    renderTierBody?: (tier: TierConfig, renderRow: SharedRowRenderer) => ComponentChildren;
+    jumpTo?: (address: TokenAddress) => void;
+    /** Enables the shared numeric-selection action bar for this tab. */
+    onBulkApply?: (patch: readonly BulkPatchEntry[]) => void;
+}
+export default function FlatTab({ tab, getValue, setValue, deleteValue, overrides, contributions, searchQuery, changedOnly, actions, className, testId, sectionTestId, renderTierBody, jumpTo, onBulkApply, }: FlatTabProps): import("preact").JSX.Element;

package/dist/tabs/flat/index.d.ts

@@ -0,0 +1,8 @@
+export { default as FlatTab } from './flat-tab';
+export { default as TierSection } from './tier-section';
+export { default as TokenRow } from './token-row';
+export { useTokenController, TokenControllerProvider } from './token-controller';
+export { scrollToTokenRow, TOKEN_ROW_FLASH_CLASS } from './scroll-to-token-row';
+export { tokenAddressKey } from './types';
+export type { FlatTabEntry, RowContribution, TokenAddress } from './types';
+export type { TokenController } from './token-controller';

package/dist/tabs/flat/scroll-to-token-row.d.ts

@@ -0,0 +1,3 @@
+import type { TokenAddress } from './types';
+export declare const TOKEN_ROW_FLASH_CLASS = "tokenpanel-row--flash";
+export declare function scrollToTokenRow(root: ParentNode, address: TokenAddress): HTMLElement | null;

package/dist/tabs/flat/tier-section.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentChildren } from 'preact';
+import type { TabOverrides } from '../../apply/tier-resolver';
+import type { TierConfig, TierItem } from '../../tokens/tier-model';
+import type { FlatTabEntry, RowContribution, TokenAddress } from './types';
+export type SharedRowRenderer = (item: TierItem) => ComponentChildren;
+export interface TierSectionProps {
+    tier: TierConfig;
+    entries: readonly FlatTabEntry[];
+    overrides: TabOverrides;
+    contributions?: readonly RowContribution[];
+    testId?: string;
+    setValue: (address: TokenAddress, next: string) => void;
+    deleteValue: (address: TokenAddress) => void;
+    renderTierBody?: (tier: TierConfig, renderRow: SharedRowRenderer) => ComponentChildren;
+}
+declare function TierSection({ tier, entries, overrides, contributions, testId, setValue, deleteValue, renderTierBody, }: TierSectionProps): import("preact").JSX.Element;
+export default TierSection;

package/dist/tabs/flat/token-controller.d.ts

@@ -0,0 +1,23 @@
+import type { ComponentChildren } from 'preact';
+import type { FlatTabEntry, TokenAddress } from './types';
+export interface TokenController {
+    value: string;
+    setValue: (next: string) => void;
+    revert: () => void;
+    kind: FlatTabEntry['kind'];
+    entry: FlatTabEntry;
+    readonly: boolean;
+    jumpTo?: () => void;
+}
+interface TokenControllerRegistry {
+    entries: ReadonlyMap<string, FlatTabEntry>;
+    setValue: (address: TokenAddress, next: string) => void;
+    deleteValue: (address: TokenAddress) => void;
+    jumpTo?: (address: TokenAddress) => void;
+}
+interface TokenControllerProviderProps extends TokenControllerRegistry {
+    children: ComponentChildren;
+}
+export declare function TokenControllerProvider({ children, ...registry }: TokenControllerProviderProps): import("preact").JSX.Element;
+export declare function useTokenController(address: TokenAddress): TokenController;
+export {};

package/dist/tabs/flat/token-row.d.ts

@@ -0,0 +1,12 @@
+import type { TabOverrides } from '../../apply/tier-resolver';
+import type { FlatTabEntry, RowContribution, TokenAddress } from './types';
+export interface TokenRowProps {
+    entry: FlatTabEntry;
+    overrides: TabOverrides;
+    contributions?: readonly RowContribution[];
+    onChange: (address: TokenAddress, next: string) => void;
+    onDelete: (address: TokenAddress) => void;
+}
+declare function TokenRow({ entry, overrides, contributions, onChange, onDelete, }: TokenRowProps): import("preact").JSX.Element | null;
+declare const _default: typeof TokenRow;
+export default _default;

package/dist/tabs/flat/types.d.ts

@@ -0,0 +1,25 @@
+import type { ComponentChildren } from 'preact';
+import type { TabConfig, TierConfig, TierItem, TierValueKind } from '../../tokens/tier-model';
+export interface TokenAddress {
+    tabId: string;
+    tierId: string;
+    itemId: string;
+}
+export interface FlatTabEntry {
+    address: TokenAddress;
+    tab: TabConfig;
+    tier: TierConfig;
+    item: TierItem;
+    value: string;
+    kind: TierValueKind['kind'];
+}
+export interface RowContribution {
+    id: string;
+    filter?: (entry: FlatTabEntry) => boolean;
+    leading?: (entry: FlatTabEntry) => ComponentChildren;
+    trailing?: (entry: FlatTabEntry) => ComponentChildren;
+    tail?: (entry: FlatTabEntry) => ComponentChildren;
+    className?: (entry: FlatTabEntry) => string | undefined;
+    tierHeadingExtra?: (tier: TierConfig) => ComponentChildren;
+}
+export declare function tokenAddressKey(address: TokenAddress): string;

package/dist/tabs/font-tab.d.ts

@@ -1,21 +1,22 @@
+import type { PanelConfig } from '../config/panel-config';
 import type { TabConfig } from '../tokens/tier-model';
 import type { TokenOverrides } from '../state/tweak-state';
 import type { PersistFont } from '../state/persist';
+import type { RowContribution } from './flat/types';
+import type { BulkPatchEntry } from '../bulk';
 interface FontTabProps {
     tab: TabConfig;
     state: TokenOverrides;
     persistFont: PersistFont;
+    instanceConfig?: PanelConfig;
+    /** Whether the read-only specimen is currently portaled into the host page. */
+    renderOnPage?: boolean;
+    /** Called when the toolbar toggles the page-level specimen. */
+    onRenderOnPageChange?: (enabled: boolean) => void;
+    searchQuery?: string;
+    onBulkApply?: (patch: readonly BulkPatchEntry[]) => void;
+    changedContribution?: RowContribution;
+    changedOnly?: boolean;
 }
-/**
- * Font tab — TabConfig.tiers driven.
- *
- * Renders all tiers flat in declaration order. Each tier has one heading
- * (div role=heading aria-level=3). No progressive disclosure (details/summary).
- * When a tier has `referencesTier`, its items render `TierRefSelector`.
- *
- * The persist path: `state.typography` is a flat `TokenOverrides` map keyed
- * by item id. Reference values store the target item id; apply emits
- * `var(--targetCssVar)`.
- */
-export default function FontTab({ tab, state, persistFont }: FontTabProps): import("preact").JSX.Element;
+export default function FontTab({ tab, state, persistFont, instanceConfig, renderOnPage: renderOnPageProp, onRenderOnPageChange, searchQuery, onBulkApply, changedContribution, changedOnly, }: FontTabProps): import("preact").JSX.Element;
 export {};

package/dist/tabs/generic-tab.d.ts

@@ -1,44 +1,14 @@
-/**
- * GenericTab — renders any TabConfig whose id is not one of the reserved ids
- * (color / font / spacing / size). Reserved ids continue to dispatch to their
- * dedicated tab components until Wave 5 migrates them.
- *
- * Renders the tab's tiers in declaration order. Each tier shows a heading and
- * its items via kind-appropriate controls:
- *
- *   length / number → number input with unit suffix (numeric range)
- *   select          → native <select>
- *   text            → free-form text input
- *   color           → native <input type="color"> by default (emits hex); with format:'oklch' → OKLCH picker emitting an oklch() string. Color values therefore persist as hex OR oklch(), not hex-only.
- *
- * For items in a tier with `referencesTier`, TierRefSelector is rendered
- * instead, so the user can either pick a tier-1 item id (emitted as
- * `var(--target-cssvar)` at apply time) or flip the item back to literal mode.
- */
+import type { TabOverrides } from '../apply/tier-resolver';
 import type { TabConfig } from '../tokens/tier-model';
-import { type TabOverrides } from '../apply/tier-resolver';
+import type { RowContribution } from './flat/types';
+import type { BulkPatchEntry } from '../bulk';
 export interface GenericTabProps {
-    /** The tab configuration to render. Must NOT be a reserved id. */
     tab: TabConfig;
-    /**
-     * Current per-tier, per-item overrides for this tab.
-     *
-     * Shape: { [tierId]: { [itemId]: overrideValue } }
-     *
-     * When an item has no override, its `TierItem.default` is used.
-     */
     overrides: TabOverrides;
-    /** Called when the user commits a change to any item. `next: undefined`
-     *  (only reachable for ref-tier items) means "drop the stored override for
-     *  this item" rather than writing a literal value. */
     onChange: (tierId: string, itemId: string, next: string | undefined) => void;
+    searchQuery?: string;
+    onBulkApply?: (patch: readonly BulkPatchEntry[]) => void;
+    changedContribution?: RowContribution;
+    changedOnly?: boolean;
 }
-/**
- * Renders a non-reserved tab (any TabConfig whose id is not color/font/
- * spacing/size). Dispatches each tier to TierSection, which in turn renders
- * item editors by value kind.
- *
- * Reserved-id tabs (color/font/spacing/size) are handled by their dedicated
- * components until Wave 5 migrates them to consume TabConfig.tiers.
- */
-export default function GenericTab({ tab, overrides, onChange }: GenericTabProps): import("preact").JSX.Element;
+export default function GenericTab({ tab, overrides, onChange, searchQuery, onBulkApply, changedContribution, changedOnly, }: GenericTabProps): import("preact").JSX.Element;

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

@@ -1,8 +1,12 @@
 import type { TabConfig } from '../../tokens/tier-model';
 import type { TabOverrides } from '../../apply/tier-resolver';
+import type { TokenAddress } from '../flat/types';
 export interface PaletteCheckViewProps {
     tab: TabConfig;
     overrides: TabOverrides;
     onChange: (tierId: string, itemId: string, next: string) => void;
+    searchQuery?: string;
+    changedOnly?: boolean;
+    isChanged?: (address: TokenAddress) => boolean;
 }
-export default function PaletteCheckView({ tab, overrides }: PaletteCheckViewProps): import("preact").JSX.Element;
+export default function PaletteCheckView({ tab, overrides, searchQuery, changedOnly, isChanged, }: PaletteCheckViewProps): import("preact").JSX.Element;

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

@@ -36,6 +36,7 @@
  */
 import type { TabConfig } from '../../tokens/tier-model';
 import type { TabOverrides } from '../../apply/tier-resolver';
+import type { TokenAddress } from '../flat/types';
 export interface PaletteEditViewProps {
     tab: TabConfig;
     overrides: TabOverrides;
@@ -51,5 +52,12 @@ export interface PaletteEditViewProps {
      * per-item `onChange`).
      */
     onCommitBatch?: (tierId: string, patch: Record<string, string>) => void;
+    searchQuery?: string;
+    /** Transient active-tab Changed-only filter. */
+    changedOnly?: boolean;
+    /** S2 evaluator callback for palette-step addresses. */
+    isChanged?: (address: TokenAddress) => boolean;
+    jumpAddress?: TokenAddress | null;
+    onJumpAddressHandled?: (address: TokenAddress) => void;
 }
-export default function PaletteEditView({ tab, overrides, onChange, onCommitBatch }: PaletteEditViewProps): import("preact").JSX.Element;
+export default function PaletteEditView({ tab, overrides, onChange, onCommitBatch, searchQuery, changedOnly, isChanged, jumpAddress, onJumpAddressHandled, }: PaletteEditViewProps): import("preact").JSX.Element;

package/dist/tabs/palette/palette-tab.d.ts

@@ -15,6 +15,7 @@
  */
 import type { TabConfig, TierConfig, TierItem } from '../../tokens/tier-model';
 import type { TabOverrides } from '../../apply/tier-resolver';
+import type { TokenAddress } from '../flat/types';
 /** Returns tiers in declaration order — the canonical group ordering. */
 export declare function groupPaletteTiers(tab: TabConfig): readonly TierConfig[];
 /** Returns all items across all tiers flattened into a single array. */
@@ -32,5 +33,15 @@ export interface PaletteTabProps {
      * Optional — Check mode and older callers don't supply it.
      */
     onCommitBatch?: (tierId: string, patch: Record<string, string>) => void;
+    /** Header-filter query shared with the active tab. */
+    searchQuery?: string;
+    /** Transient active-tab Changed-only filter. */
+    changedOnly?: boolean;
+    /** S2 evaluator callback for palette-step addresses. */
+    isChanged?: (address: TokenAddress) => boolean;
+    /** Address selected by the command palette. */
+    jumpAddress?: TokenAddress | null;
+    /** Called after the Edit view has opened and selected the requested step. */
+    onJumpAddressHandled?: (address: TokenAddress) => void;
 }
-export default function PaletteTab({ tab, overrides, onChange, onCommitBatch }: PaletteTabProps): import("preact").JSX.Element;
+export default function PaletteTab({ tab, overrides, onChange, onCommitBatch, searchQuery, changedOnly, isChanged, jumpAddress, onJumpAddressHandled, }: PaletteTabProps): import("preact").JSX.Element;

package/dist/tabs/size-tab.d.ts

@@ -1,19 +1,16 @@
 import type { TabConfig } from '../tokens/tier-model';
 import type { TokenOverrides } from '../state/tweak-state';
 import type { PersistSize } from '../state/persist';
+import type { RowContribution } from './flat/types';
+import type { BulkPatchEntry } from '../bulk';
 interface SizeTabProps {
     tab: TabConfig;
     state: TokenOverrides;
     persistSize: PersistSize;
+    searchQuery?: string;
+    onBulkApply?: (patch: readonly BulkPatchEntry[]) => void;
+    changedContribution?: RowContribution;
+    changedOnly?: boolean;
 }
-/**
- * Size tab — TabConfig.tiers driven.
- *
- * Renders all tiers flat in declaration order. Each tier has one heading
- * (div role=heading aria-level=3). No progressive disclosure (details/summary).
- * When a tier has `referencesTier`, items render TierRefSelector.
- * Pill toggle is preserved: `item.pill` drives a checkbox + disabled slider
- * exactly as the legacy PillSliderRow did.
- */
-export default function SizeTab({ tab, state, persistSize }: SizeTabProps): import("preact").JSX.Element;
+export default function SizeTab({ tab, state, persistSize, searchQuery, onBulkApply, changedContribution, changedOnly, }: SizeTabProps): import("preact").JSX.Element;
 export {};

package/dist/tabs/spacing-tab.d.ts

@@ -1,22 +1,16 @@
 import type { TabConfig } from '../tokens/tier-model';
 import type { TokenOverrides } from '../state/tweak-state';
 import type { PersistSpacing } from '../state/persist';
+import type { RowContribution } from './flat/types';
+import type { BulkPatchEntry } from '../bulk';
 interface SpacingTabProps {
     tab: TabConfig;
     state: TokenOverrides;
     persistSpacing: PersistSpacing;
+    searchQuery?: string;
+    onBulkApply?: (patch: readonly BulkPatchEntry[]) => void;
+    changedContribution?: RowContribution;
+    changedOnly?: boolean;
 }
-/**
- * Spacing tab — TabConfig.tiers driven.
- *
- * Renders all tiers flat in declaration order. Each tier has one heading
- * (div role=heading aria-level=3). No progressive disclosure (details/summary).
- * When a tier has `referencesTier`, its items render `TierRefSelector`
- * instead of the kind-specific control.
- *
- * The persist path remains the same: `state.spacing` is a flat `TokenOverrides`
- * map keyed by item id. Reference values are stored as the target item id; the
- * apply pipeline emits `var(--targetCssVar)`.
- */
-export default function SpacingTab({ tab, state, persistSpacing }: SpacingTabProps): import("preact").JSX.Element;
+export default function SpacingTab({ tab, state, persistSpacing, searchQuery, onBulkApply, changedContribution, changedOnly, }: SpacingTabProps): import("preact").JSX.Element;
 export {};

package/dist/testing.js

@@ -1,6 +1,6 @@
-import { _ as r, c as _, d as i, e as n, f as g, h as R, a as p } from "./panel-config-COHesW2B.js";
-import { a as l, b as y, l as O } from "./tweak-state-BKNxtHzb.js";
-import { F as K, G as E, a as S, S as u } from "./manifest-DCReQE0k.js";
+import { _ as r, c as _, d as i, e as n, f as g, h as R, a as p } from "./panel-config-CRf-ONSV.js";
+import { a as l, b as y, l as O } from "./tweak-state-BGp_7Tfh.js";
+import { F as K, G as E, a as S, S as u } from "./manifest-DvuKi7I4.js";
 async function s(e, a) {
   await e.fill(a), await e.dispatchEvent("input");
 }

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

@@ -17,6 +17,7 @@ export type TierValueKind = {
 } | {
     kind: 'number';
     step: number;
+    unit?: string;
 } | {
     kind: 'select';
     options: readonly string[];
@@ -135,6 +136,11 @@ export interface TierConfig {
         tab?: string;
         tier: string;
     }[];
+    /** Optional visual treatment for this tier's values. Omission preserves the
+     *  ordinary flat token-row rendering. */
+    preview?: 'size' | 'line-height' | 'family' | 'weight' | 'bar' | 'radius' | 'duration';
+    /** Font-size custom property used as the line-height specimen's base size. */
+    previewBase?: string;
 }
 export interface ColorClusterExtras {
     id: string;