@womp/kookie-ui 0.36.0 → 0.37.0

package/src/components/_internal/shell-pane.tsx

@@ -9,10 +9,8 @@ import {
   notifyShellStore,
   tableAttributes,
   tableOf,
-  usePeeking,
   useShellStore,
   useStableKey,
-  warnOnce,
   type OpenChangeReason,
   type PaneEntry,
   type PaneValue,
@@ -28,8 +26,8 @@ export type UsePaneOptions = {
   /** The prop names a warning should use: `open`/`defaultOpen`, or `state`/`defaultState`. */
   propNames: { controlled: string; default: string };
   id: string | undefined;
-  /** The controlled value. A responsive object is deprecated: it is resolved against the current breakpoint. */
-  controlled: ResponsiveValue | undefined;
+  /** The controlled value. */
+  controlled: PaneValue | undefined;
   /**
    * The uncontrolled default. A single value fixes where the pane starts. A
    * responsive object leaves the pane untouched (`auto`), with that object as
@@ -44,8 +42,6 @@ export type UsePaneOptions = {
   onChange: ((value: PaneValue, reason: OpenChangeReason) => void) | undefined;
   /** The value a toggle moves to. Defaults to open and closed in turn. */
   toggleNext?: (current: PaneValue, defaultHere: PaneValue | undefined) => PaneValue;
-  onExpand: (() => void) | undefined;
-  onCollapse: (() => void) | undefined;
   /** The pane's designed open width, published for the panes beside it. */
   size: number;
 };
@@ -54,15 +50,6 @@ export type PaneController = ReturnType<typeof usePane>;
 
 const isMap = (value: ResponsiveValue | undefined): value is Partial<Record<Breakpoint, PaneValue>> => typeof value === 'object' && value !== null;
 
-/** The first value a responsive object states, smallest breakpoint first. */
-function firstStated(map: Partial<Record<Breakpoint, PaneValue>>): PaneValue {
-  for (const bp of ['initial', 'xs', 'sm', 'md', 'lg', 'xl'] as const) {
-    const value = map[bp];
-    if (value !== undefined) return value;
-  }
-  return 'closed';
-}
-
 /** Everything the togglable panes share: their state, their registry entry and their callbacks. */
 export function usePane(options: UsePaneOptions) {
   const { name, label, propNames, presentationTable, builtIn } = options;
@@ -71,34 +58,21 @@ export function usePane(options: UsePaneOptions) {
   const id = options.id ?? `shell-${name}${generatedId}`;
 
   const controlled = options.controlled !== undefined;
-  const controlledIsMap = isMap(options.controlled);
-  if (controlledIsMap) {
-    warnOnce(
-      `Shell.${label}: a responsive \`${propNames.controlled}\` is deprecated and is removed in 1.0. ` +
-        `Pass a boolean and decide it from your own state, or use \`${propNames.default}\` with a responsive object.`,
-    );
-  }
-
-  // A responsive controlled value is resolved the way a responsive default
-  // is: it becomes the table an untouched pane follows, so the stylesheet
-  // answers it at each breakpoint (right in the server HTML, with no
-  // callback on a crossing) and the app's prop is still the only writer.
-  const controlledMap = controlledIsMap ? (options.controlled as Partial<Record<Breakpoint, PaneValue>>) : undefined;
-  const autoSource = controlledMap ?? (isMap(options.defaultValue) ? options.defaultValue : undefined);
+  const autoSource = isMap(options.defaultValue) ? options.defaultValue : undefined;
   const autoKey = useStableKey(autoSource);
   const [inner, setInner] = React.useState<'auto' | PaneValue>(() => (typeof options.defaultValue === 'string' ? options.defaultValue : 'auto'));
 
   // What an untouched pane shows at each breakpoint: a responsive default
   // where it states one, the pane's own default where it does not.
   const autoTable = React.useMemo(
-    () => (controlledMap ? tableOf<PaneValue>(controlledMap, () => firstStated(controlledMap)) : tableOf<PaneValue>(autoSource, (bp) => builtIn(presentationTable[bp]))),
+    () => tableOf<PaneValue>(autoSource, (bp) => builtIn(presentationTable[bp])),
     // `autoKey` stands for the responsive object, which is usually a new literal each render.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [autoKey, controlledIsMap, presentationTable, builtIn],
+    [autoKey, presentationTable, builtIn],
   );
 
   let state: 'auto' | PaneValue = inner;
-  if (controlled) state = controlledMap ? 'auto' : (options.controlled as PaneValue);
+  if (options.controlled !== undefined) state = options.controlled;
 
   // Only a pane whose answer depends on the window subscribes to it, so a
   // pane with one presentation and one default never re-renders on a resize.
@@ -194,23 +168,6 @@ export function usePane(options: UsePaneOptions) {
     };
   }, [store, name, id, value, presentation, presentationTable, overlayLive, options.size, setValue, toggle]);
 
-  // onExpand/onCollapse fire when the pane's state changes and that changes
-  // whether it is shown: a user's toggle, or a controlled prop. Never on
-  // mount, and never because the window crossed a breakpoint.
-  const callbacks = React.useRef({ onExpand: options.onExpand, onCollapse: options.onCollapse });
-  useLayoutEffect(() => {
-    callbacks.current = { onExpand: options.onExpand, onCollapse: options.onCollapse };
-  });
-  const previous = React.useRef({ state, shown });
-  React.useEffect(() => {
-    const before = previous.current;
-    if (before.state !== state && before.shown !== undefined && shown !== undefined && before.shown !== shown) {
-      if (shown) callbacks.current.onExpand?.();
-      else callbacks.current.onCollapse?.();
-    }
-    previous.current = { state, shown };
-  }, [state, shown]);
-
   // Development guards. Once per mount, not once per render.
   useLayoutEffect(() => {
     if (process.env.NODE_ENV === 'production') return;
@@ -229,8 +186,6 @@ export function usePane(options: UsePaneOptions) {
     }
   }, [controlled, label, propNames.controlled]);
 
-  const peeking = usePeeking(store, name) && shown === false && !overlaying;
-
   return {
     store,
     id,
@@ -240,7 +195,6 @@ export function usePane(options: UsePaneOptions) {
     presentation,
     overlaying,
     overlayLive,
-    peeking,
     ready,
     breakpoint,
     autoTable,
@@ -253,16 +207,13 @@ export function usePane(options: UsePaneOptions) {
 
 /** The data attributes every togglable pane renders. */
 export function paneAttributes(pane: PaneController, presentationAttributes: Record<string, string>) {
-  const { state, value, presentation, shown } = pane;
+  const { state, value, presentation } = pane;
   return {
     ...presentationAttributes,
     'data-state': state,
     ...(state === 'auto' ? tableAttributes('auto', pane.autoTable) : {}),
     'data-presentation': presentation,
     'data-mode': value === undefined ? undefined : value === 'closed' ? 'collapsed' : 'expanded',
-    // Kept for stylesheets written against 0.7: set while a stacked pane is open.
-    'data-open': presentation === 'stacked' && shown ? '' : undefined,
-    'data-peek': pane.peeking ? '' : undefined,
   } as const;
 }
 

package/src/components/_internal/shell-resizable.tsx

@@ -3,7 +3,7 @@
 import * as React from 'react';
 import { useLayoutEffect } from 'radix-ui/internal';
 import { normalizeToPx } from '../../helpers/normalize-to-px.js';
-import type { PaneName, PaneSizePersistence } from '../shell.types.js';
+import type { PaneName } from '../shell.types.js';
 import type { PaneResizeContextValue } from './shell-resize.js';
 
 export type SizeChangeMeta = { reason: 'init' | 'resize' | 'controlled' };
@@ -30,16 +30,10 @@ export type ResizableOptions = {
   onResize: ((size: number) => void) | undefined;
   onResizeStart: ((size: number) => void) | undefined;
   onResizeEnd: ((size: number) => void) | undefined;
-  snapPoints: number[] | undefined;
-  snapTolerance: number | undefined;
-  collapseThreshold: number | undefined;
-  paneId: string | undefined;
-  persistence: PaneSizePersistence | undefined;
-  /** Whether the pane is presented as an overlay right now. An overlay keeps its designed size and persists nothing. */
+  /** Whether the pane is presented as an overlay right now. An overlay keeps its designed size. */
   overlaying: boolean;
   /** The same question asked at effect time, for a pane whose presentation is learnt after its first render. */
   overlayingNow: () => boolean;
-  requestCollapse: () => void;
   requestToggle: () => void;
 };
 
@@ -63,9 +57,9 @@ export function useInitialPaneSize(size: number | string | undefined, defaultSiz
   return initial;
 }
 
-/** Everything a resizable pane shares: size props, persistence, and the handle's context. */
+/** Everything a resizable pane shares: size props and the handle's context. */
 export function useResizablePane(options: ResizableOptions): PaneResizeContextValue {
-  const { name, elementRef, cssVarName, orientation, minSize, maxSize, resizable, size, defaultSize, paneId, persistence } = options;
+  const { name, elementRef, cssVarName, orientation, minSize, maxSize, size, defaultSize } = options;
 
   // The latest callbacks, so the size emitter does not change identity when a
   // consumer passes an inline function. A controlled `size` is reported again
@@ -107,7 +101,7 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
   /**
    * The one way a size reaches the pane: the size variable, and the value
    * every handle of this pane announces. Once anything but `expandedSize` has
-   * written a size (a default, a controlled value, a persisted value or a
+   * written a size (a default, a controlled value or a
    * resize), the pane owns that size and a new `expandedSize` leaves it alone.
    */
   const ownedRef = React.useRef(false);
@@ -154,65 +148,6 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
     emitSizeChange(clamped, { reason: 'controlled' });
   }, [size, minSize, maxSize, options.overlaying, toPx, writeSize, emitSizeChange]);
 
-  // A persistence adapter from `paneId` when none is given. A given one is read through
-  // `latest`, so an inline object (the documented shape) does not reload the size every render.
-  const hasPersistence = persistence !== undefined;
-  const adapter = React.useMemo<PaneSizePersistence | undefined>(() => {
-    if (hasPersistence) {
-      return {
-        load: () => latest.current.persistence?.load?.(),
-        save: (value: number) => latest.current.persistence?.save?.(value),
-      };
-    }
-    if (!paneId) return undefined;
-    const key = `kookie-ui:shell:${name}:${paneId}`;
-    return {
-      load: () => {
-        if (typeof window === 'undefined') return undefined;
-        try {
-          const stored = window.localStorage.getItem(key);
-          return stored ? Number(stored) : undefined;
-        } catch (err) {
-          if (process.env.NODE_ENV !== 'production') console.warn(`Shell.${name}: failed to load persisted size`, err);
-          return undefined;
-        }
-      },
-      save: (value: number) => {
-        if (typeof window === 'undefined') return;
-        try {
-          window.localStorage.setItem(key, String(value));
-        } catch (err) {
-          if (process.env.NODE_ENV !== 'production') console.warn(`Shell.${name}: failed to save persisted size`, err);
-        }
-      },
-    };
-  }, [name, paneId, hasPersistence]);
-
-  // Persisted size, loaded in a layout effect and clamped, so a reload does
-  // not paint the default and then jump. Only where the pane is in the frame:
-  // an overlay keeps its designed size.
-  useLayoutEffect(() => {
-    if (!resizable || !adapter?.load || latest.current.overlayingNow()) return undefined;
-    let mounted = true;
-    const apply = (value: number | undefined) => {
-      if (!mounted || typeof value !== 'number' || !Number.isFinite(value)) return;
-      const clamped = clampTo(value, minSize, maxSize);
-      writeSize(clamped, true);
-      latest.current.onResize?.(clamped);
-    };
-    const loaded = adapter.load();
-    if (loaded instanceof Promise) {
-      loaded.then(apply).catch((err) => {
-        if (process.env.NODE_ENV !== 'production') console.warn(`Shell.${name}: failed to load persisted size`, err);
-      });
-    } else {
-      apply(loaded);
-    }
-    return () => {
-      mounted = false;
-    };
-  }, [resizable, adapter, options.overlaying, writeSize, minSize, maxSize, name]);
-
   // What the handle announces before any effect has run: the same starting size the pane's
   // first render uses, so the server HTML already states a value.
   const [startSize] = React.useState(() => {
@@ -230,11 +165,9 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
     (value: number) => {
       latest.current.onResizeEnd?.(value);
       emitSizeChange(value, { reason: 'resize' });
-      adapter?.save?.(value);
     },
-    [emitSizeChange, adapter],
+    [emitSizeChange],
   );
-  const requestCollapse = React.useCallback(() => latest.current.requestCollapse(), []);
   const requestToggle = React.useCallback(() => latest.current.requestToggle(), []);
 
   return React.useMemo(
@@ -254,10 +187,6 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
       onResizeEnd,
       target: name,
       collapsible: options.collapsible,
-      snapPoints: options.snapPoints,
-      snapTolerance: options.snapTolerance ?? 8,
-      collapseThreshold: options.collapseThreshold,
-      requestCollapse,
       requestToggle,
     }),
     [
@@ -276,10 +205,6 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
       onResizeEnd,
       name,
       options.collapsible,
-      options.snapPoints,
-      options.snapTolerance,
-      options.collapseThreshold,
-      requestCollapse,
       requestToggle,
     ],
   );

package/src/components/_internal/shell-resize.tsx

@@ -24,10 +24,6 @@ export interface PaneResizeContextValue {
   onResizeEnd?: (size: number) => void;
   target: PaneName;
   collapsible: boolean;
-  snapPoints?: number[];
-  snapTolerance: number;
-  collapseThreshold?: number;
-  requestCollapse?: () => void;
   requestToggle?: () => void;
 }
 

package/src/components/_internal/shell-rest.ts

@@ -4,6 +4,8 @@ import type { PaneValue } from './shell-store.js';
 type ResponsiveBoolean = boolean | Partial<Record<Breakpoint, boolean>>;
 
 /** `open`/`defaultOpen` as the pane's own value type. */
+export function toPaneValue(value: boolean | undefined): PaneValue | undefined;
+export function toPaneValue(value: ResponsiveBoolean | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined;
 export function toPaneValue(value: ResponsiveBoolean | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined {
   if (value === undefined) return undefined;
   if (typeof value === 'boolean') return value ? 'open' : 'closed';
@@ -32,14 +34,3 @@ export const endAnchoredGrowth = (isRtl: boolean): 1 | -1 => (isRtl ? 1 : -1);
 
 /** A pane anchored at the block end grows as its top edge moves up. */
 export const bottomAnchoredGrowth = (): 1 | -1 => -1;
-
-/**
- * `height` and `resizer` left PaneBaseProps in 0.8.0: no pane ever read them.
- * A call site written against 0.7 can still pass them, so they are dropped
- * here rather than reaching the DOM as invalid attributes.
- */
-export function withoutRemovedPaneProps<T extends object>(props: T): T {
-  if (!('height' in props) && !('resizer' in props)) return props;
-  const { height: _height, resizer: _resizer, ...rest } = props as T & { height?: unknown; resizer?: unknown };
-  return rest as T;
-}

package/src/components/_internal/shell-sidebar.tsx

@@ -7,15 +7,15 @@ import { PaneResizeContext } from './shell-resize.js';
 import { PaneHandle, SidebarHandle } from './shell-handles.js';
 import { usePane, paneAttributes, usePresentationTable } from './shell-pane.js';
 import { splitHandles, useInitialPaneSize, useResizablePane, type SizeChangeMeta } from './shell-resizable.js';
-import { useFrameRegistration, warnOnce, type PaneValue } from './shell-store.js';
-import { navigationRest, startAnchoredGrowth, withoutRemovedPaneProps } from './shell-rest.js';
+import { useFrameRegistration, type PaneValue } from './shell-store.js';
+import { navigationRest, startAnchoredGrowth } from './shell-rest.js';
 import { readBreakpoint } from '../../hooks/use-breakpoint.js';
 import { PaneChromeScope } from './pane-chrome.js';
 import { PageScope } from './page-scope.js';
-import type { Breakpoint, CSSPropertiesWithVars, PaneBaseProps, Responsive, SidebarMode } from '../shell.types.js';
+import type { Breakpoint, CSSPropertiesWithVars, PaneBaseProps, PaneOpenChangeReason, Responsive, SidebarMode } from '../shell.types.js';
 
-type SidebarStateChangeMeta = { reason: 'init' | 'toggle' | 'responsive' | 'dismiss' };
-type SidebarControlledProps = { state: Responsive<SidebarMode>; onStateChange?: (state: SidebarMode, meta: SidebarStateChangeMeta) => void; defaultState?: never };
+type SidebarStateChangeMeta = { reason: PaneOpenChangeReason };
+type SidebarControlledProps = { state: SidebarMode; onStateChange?: (state: SidebarMode, meta: SidebarStateChangeMeta) => void; defaultState?: never };
 type SidebarUncontrolledProps = { defaultState?: SidebarMode | Partial<Record<Breakpoint, SidebarMode>>; onStateChange?: (state: SidebarMode, meta: SidebarStateChangeMeta) => void; state?: never };
 type SidebarPublicProps = PaneBaseProps & {
   size?: number | string;
@@ -37,6 +37,8 @@ type SidebarComponent = React.ForwardRefExoticComponent<SidebarPublicProps & Rea
 const toValue = (mode: SidebarMode): PaneValue => (mode === 'collapsed' ? 'closed' : 'open');
 const toMode = (value: PaneValue): SidebarMode => (value === 'closed' ? 'collapsed' : 'expanded');
 
+function modeToValue(state: SidebarMode | undefined): PaneValue | undefined;
+function modeToValue(state: Responsive<SidebarMode> | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined;
 function modeToValue(state: Responsive<SidebarMode> | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined {
   if (state === undefined) return undefined;
   if (typeof state === 'string') return toValue(state);
@@ -62,16 +64,9 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
     maxSize = 400,
     resizable = false,
     collapsible = true,
-    onExpand,
-    onCollapse,
     onResize,
     onResizeStart,
     onResizeEnd,
-    snapPoints,
-    snapTolerance,
-    collapseThreshold,
-    paneId,
-    persistence,
     children,
     style,
     state,
@@ -98,17 +93,10 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
     presentationTable: table,
     builtIn: navigationRest,
     onChange: (value, reason) => onStateChange?.(toMode(value), { reason }),
-    onExpand,
-    onCollapse,
     size: expandedSize,
   });
   useFrameRegistration('sidebar', flush);
 
-  React.useEffect(() => {
-    if (snapPoints !== undefined || collapseThreshold !== undefined || paneId !== undefined || persistence !== undefined) {
-      warnOnce('Shell.Sidebar: `snapPoints`, `collapseThreshold`, `paneId` and `persistence` are deprecated and are removed in 1.0. Keep the size in your own state with `size`/`onSizeChange`.');
-    }
-  }, [snapPoints, collapseThreshold, paneId, persistence]);
 
   const elementRef = React.useRef<HTMLElement | null>(null);
   const composedRef = useComposedRefs(ref, pane.setElement, elementRef);
@@ -134,14 +122,8 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
     onResize,
     onResizeStart,
     onResizeEnd,
-    snapPoints,
-    snapTolerance,
-    collapseThreshold,
-    paneId,
-    persistence,
     overlaying: pane.overlaying,
     overlayingNow: () => table[readBreakpoint()] === 'overlay',
-    requestCollapse: () => pane.setValue('closed', 'toggle'),
     requestToggle: () => pane.toggle('toggle'),
   });
 
@@ -151,13 +133,10 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
       <PaneResizeContext.Provider value={resize}>{handles.length > 0 ? handles : <PaneHandle />}</PaneResizeContext.Provider>
     ) : null;
 
-  // A peek previews the width the next toggle opens to.
-  const peekWidth = pane.peeking ? `var(--sidebar-size, ${expandedSize}px)` : undefined;
-
   const initialSize = useInitialPaneSize(size, defaultSize, minSize, maxSize);
   return (
     <div
-      {...withoutRemovedPaneProps(domProps)}
+      {...domProps}
       role={domProps.role ?? 'navigation'}
       id={pane.id}
       ref={composedRef}
@@ -172,7 +151,6 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
           ...(initialSize ? { '--sidebar-size': initialSize } : {}),
           '--sidebar-min-size': `${minSize}px`,
           '--sidebar-max-size': `${maxSize}px`,
-          ...(peekWidth ? { '--peek-sidebar-width': peekWidth } : {}),
         } as CSSPropertiesWithVars
       }
     >

package/src/components/_internal/shell-store.tsx

@@ -117,12 +117,10 @@ export type ShellStore = {
    * it, would be a new identity on every read.
    */
   version: number;
-  /** The pane a hovered Trigger is previewing, if any. Layout only. */
-  peek: PaneName | null;
 };
 
 export function createShellStore(): ShellStore {
-  return { entries: new Map(), listeners: new Set(), version: 0, peek: null };
+  return { entries: new Map(), listeners: new Set(), version: 0 };
 }
 
 export function notifyShellStore(store: ShellStore) {
@@ -137,12 +135,6 @@ export function subscribeShellStore(store: ShellStore, listener: () => void) {
   };
 }
 
-export function setShellPeek(store: ShellStore, peek: PaneName | null) {
-  if (store.peek === peek) return;
-  store.peek = peek;
-  notifyShellStore(store);
-}
-
 export const ShellStoreContext = React.createContext<ShellStore | null>(null);
 
 export function useShellStore(part: string): ShellStore {
@@ -158,19 +150,6 @@ export function usePaneEntry(store: ShellStore, name: PaneName): PaneEntry | und
   return React.useSyncExternalStore(subscribe, getSnapshot, () => undefined);
 }
 
-/**
- * Whether this pane is the one being previewed. A boolean per pane rather than
- * the peek target itself, so hovering one Trigger re-renders one pane, not all.
- */
-export function usePeeking(store: ShellStore, name: PaneName): boolean {
-  const subscribe = React.useCallback((listener: () => void) => subscribeShellStore(store, listener), [store]);
-  return React.useSyncExternalStore(
-    subscribe,
-    () => store.peek === name,
-    () => false,
-  );
-}
-
 /* ── Off the frame ─────────────────────────────────────────────────────────── */
 
 export type FramePaneId = 'rail' | 'panel' | 'sidebar' | 'content' | 'inspector' | 'bottom';
@@ -191,15 +170,3 @@ export function useFrameRegistration(id: FramePaneId, flush: boolean) {
     return () => unregisterOffFrame(id);
   }, [id, flush, registerOffFrame, unregisterOffFrame]);
 }
-
-/* ── Development warnings ──────────────────────────────────────────────────── */
-
-const warned = new Set<string>();
-
-/** A deprecation warning, once per message per page load. Development only. */
-export function warnOnce(message: string) {
-  if (process.env.NODE_ENV === 'production') return;
-  if (warned.has(message)) return;
-  warned.add(message);
-  console.warn(`[kookie-ui] ${message}`);
-}

package/src/components/checkbox-group.primitive.tsx

@@ -37,16 +37,6 @@ interface CheckboxGroupProps extends PrimitiveDivProps {
   required?: React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>['required'];
   disabled?: React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>['disabled'];
   dir?: 'ltr' | 'rtl';
-  /**
-   * @deprecated Has no effect. Each checkbox is its own tab stop, as with native checkboxes,
-   * so there is no arrow-key navigation to orient.
-   */
-  orientation?: 'horizontal' | 'vertical';
-  /**
-   * @deprecated Has no effect. Each checkbox is its own tab stop, as with native checkboxes,
-   * so there is no arrow-key navigation to loop.
-   */
-  loop?: boolean;
   defaultValue?: string[];
   value?: CheckboxGroupContextValue['value'];
   onValueChange?: (value: string[]) => void;
@@ -61,9 +51,7 @@ const CheckboxGroup = React.forwardRef<CheckboxGroupElement, CheckboxGroupProps>
       value: valueProp,
       required = false,
       disabled = false,
-      orientation: _orientation,
       dir,
-      loop: _loop,
       onValueChange,
       ...groupProps
     } = props;

package/src/components/context-menu.tsx

@@ -38,7 +38,7 @@ import {
 } from './_internal/base-menu.utils.js';
 
 import type { ComponentPropsWithout, RemovedProps } from '../helpers/component-props.js';
-import type { GetPropDefTypes, Responsive } from '../props/prop-def.js';
+import type { GetPropDefTypes } from '../props/prop-def.js';
 
 interface ContextMenuRootProps
   extends React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Root> {}
@@ -95,10 +95,6 @@ interface ContextMenuContentProps
    * Use this when rendering virtualized lists inside the context menu.
    */
   virtualized?: boolean;
-  /**
-   * @deprecated Has no effect. ContextMenu submenus always cascade.
-   */
-  submenuBehavior?: Responsive<'cascade' | 'drill-down'>;
 }
 const ContextMenuContent = React.forwardRef<ContextMenuContentElement, ContextMenuContentProps>(
   (ownProps, forwardedRef) => {
@@ -113,7 +109,6 @@ const ContextMenuContent = React.forwardRef<ContextMenuContentElement, ContextMe
       color,
       container,
       forceMount,
-      submenuBehavior: _submenuBehavior,
       virtualized = false,
       ...contentProps
     } = extractProps(props, contextMenuContentPropDefs);

package/src/components/schemas/index.ts

@@ -74,7 +74,6 @@ export type {
   ResponsiveMode,
   ResponsiveSidebarMode,
   ResponsivePresentation,
-  PaneSizePersistence,
 } from './shell.schema.js';
 
 /**

package/src/components/schemas/shell.schema.ts

@@ -24,7 +24,7 @@ const PaneModeSchema = z.enum(['expanded', 'collapsed']).describe('Pane state mo
 const SidebarModeSchema = z.enum(['collapsed', 'expanded']).describe('Sidebar state');
 const PresentationValueSchema = z.enum(['fixed', 'overlay', 'stacked']).describe('Presentation mode');
 const _BreakpointSchema = z.enum(['initial', 'xs', 'sm', 'md', 'lg', 'xl']).describe('Responsive breakpoint');
-const PaneTargetSchema = z.enum(['left', 'rail', 'panel', 'sidebar', 'inspector', 'bottom']).describe('Pane target. `left` is deprecated: use `rail`.');
+const PaneTargetSchema = z.enum(['rail', 'panel', 'sidebar', 'inspector', 'bottom']).describe('Pane target');
 const TriggerActionSchema = z.enum(['toggle', 'expand', 'collapse']).describe('Trigger action');
 const OpenChangeReasonSchema = z.enum(['toggle', 'dismiss']).describe('Why the state changed: `toggle` for a trigger or the resize handle, `dismiss` for Escape or the scrim');
 const SizeChangeReasonSchema = z.enum(['init', 'resize', 'controlled']).describe('Why the size changed');
@@ -49,21 +49,13 @@ const ResponsiveSidebarModeSchema = responsive(SidebarModeSchema).describe('Resp
 const ResponsivePresentationSchema = responsive(PresentationValueSchema).describe('Responsive presentation configuration');
 const ResponsiveOpenSchema = responsive(z.boolean()).describe('Responsive open state');
 
-// Size persistence adapter (deprecated)
-const PaneSizePersistenceSchema = z
-  .object({
-    load: z.function({ output: z.union([z.number(), z.promise(z.number()), z.undefined()]) }).optional(),
-    save: z.function({ input: [z.number()], output: z.union([z.void(), z.promise(z.void())]) }).optional(),
-  })
-  .describe('Deprecated, removed in 1.0. Keep the size in your own state with `size`/`onSizeChange`.');
-
 const StyleSchema = z
   .record(z.string(), z.union([z.string(), z.number()]))
   .optional()
   .describe('Inline styles');
 
 const OpenPropsSchema = {
-  open: z.union([z.boolean(), ResponsiveOpenSchema]).optional().describe('The open state, when controlled. A responsive object is deprecated.'),
+  open: z.boolean().optional().describe('The open state, when controlled'),
   defaultOpen: z
     .union([z.boolean(), ResponsiveOpenSchema])
     .optional()
@@ -80,8 +72,6 @@ const PaneBaseShape = {
   presentation: ResponsivePresentationSchema.optional(),
   expandedSize: z.number().optional(),
   flush: z.boolean().optional().describe('Whether the pane joins the app frame. Defaults to true. `false` pulls it off the frame as a card.'),
-  onExpand: z.function({ output: z.void() }).optional().describe('Deprecated: use `onOpenChange`'),
-  onCollapse: z.function({ output: z.void() }).optional().describe('Deprecated: use `onOpenChange`'),
   className: z.string().optional().describe('Additional CSS class name'),
   style: StyleSchema,
   children: z.any().optional(),
@@ -107,11 +97,6 @@ const ResizeShape = {
     .describe('Called during a drag, at most once per animation frame'),
   onResizeStart: z.function({ input: [z.number()], output: z.void() }).optional(),
   onResizeEnd: z.function({ input: [z.number()], output: z.void() }).optional(),
-  snapPoints: z.array(z.number()).optional().describe('Deprecated, removed in 1.0'),
-  snapTolerance: z.number().optional().describe('Deprecated, removed in 1.0'),
-  collapseThreshold: z.number().optional().describe('Deprecated, removed in 1.0'),
-  paneId: z.string().optional().describe('Deprecated, removed in 1.0'),
-  persistence: PaneSizePersistenceSchema.optional(),
 };
 
 /**
@@ -183,7 +168,7 @@ export const ShellSidebarSchema = z
   .object({
     ...PaneBaseShape,
     ...ResizeShape,
-    state: z.union([SidebarModeSchema, ResponsiveSidebarModeSchema]).optional().describe('The state, when controlled. A responsive object is deprecated.'),
+    state: SidebarModeSchema.optional().describe('The state, when controlled'),
     defaultState: ResponsiveSidebarModeSchema.optional().describe('The starting state. With no value the sidebar is open where it is in the frame and closed where it is an overlay.'),
     onStateChange: z
       .function({ input: [SidebarModeSchema, z.object({ reason: OpenChangeReasonSchema })], output: z.void() })
@@ -251,7 +236,6 @@ export const ShellTriggerSchema = z
   .object({
     target: PaneTargetSchema.describe('Which pane to drive'),
     action: TriggerActionSchema.default('toggle').describe('Action to perform'),
-    peekOnHover: z.boolean().default(false).describe('Deprecated, removed in 1.0. Shows a preview of a closed pane on hover.'),
     type: z.enum(['button', 'submit', 'reset']).default('button').describe('The button type'),
     className: z.string().optional().describe('Additional CSS class name'),
     style: StyleSchema,
@@ -298,7 +282,6 @@ export type TriggerAction = z.infer<typeof TriggerActionSchema>;
 export type ResponsiveMode = z.infer<typeof _ResponsiveModeSchema>;
 export type ResponsiveSidebarMode = z.infer<typeof ResponsiveSidebarModeSchema>;
 export type ResponsivePresentation = z.infer<typeof ResponsivePresentationSchema>;
-export type PaneSizePersistence = z.infer<typeof PaneSizePersistenceSchema>;
 
 /**
  * Development-only helper to validate and normalize Shell props