@kitlangton/knobs 0.1.0 → 0.3.0

package/dist/types/core/keys.d.ts

@@ -19,3 +19,5 @@ export declare function matchesCombo(combo: string, event: KeyboardEvent): boole
  */
 export declare function comboParts(combo: string, apple?: boolean): string[];
 export declare function comboLabel(combo: string, apple?: boolean): string;
+/** Whether a key goes to what has focus: a text field, a select or editable text. */
+export declare function isTypingTarget(target: EventTarget | null): boolean;

package/dist/types/core/random.d.ts

@@ -1,2 +1,62 @@
-import { type Schema, type Values } from "./schema.js";
+import { type CurvePoint, type GradientStop } from "./ramp.js";
+import { type Schema, type ValueField, type Values } from "./schema.js";
+/** One field's roll across its whole range (see `randomValues`). */
+export declare function pick(field: ValueField, random: () => number): string | number | boolean | number[] | readonly [0.25, 0.1, 0.25, 1] | readonly [0.42, 0, 1, 1] | readonly [0, 0, 0.58, 1] | readonly [0.42, 0, 0.58, 1] | readonly [0, 0, 1, 1] | readonly [0.65, 0, 0.35, 1] | readonly [0.32, 0.72, 0, 1] | readonly [0.34, 1.56, 0.64, 1] | GradientStop[] | CurvePoint[] | {
+    duration: number;
+    bounce: number;
+    l?: undefined;
+    c?: undefined;
+    h?: undefined;
+    x?: undefined;
+    y?: undefined;
+    z?: undefined;
+} | {
+    l: number;
+    c: number;
+    h: number;
+    duration?: undefined;
+    bounce?: undefined;
+    x?: undefined;
+    y?: undefined;
+    z?: undefined;
+} | {
+    x: number;
+    y: number;
+    duration?: undefined;
+    bounce?: undefined;
+    l?: undefined;
+    c?: undefined;
+    h?: undefined;
+    z?: undefined;
+} | {
+    x: number;
+    y: number;
+    z: number;
+    duration?: undefined;
+    bounce?: undefined;
+    l?: undefined;
+    c?: undefined;
+    h?: undefined;
+};
+/**
+ * How far Random strays from an active preset. A number lands in a window 35% of its range wide,
+ * centred on the preset's value and slid inward at an end so it keeps its width: far enough to
+ * be a new take, near enough to stay recognisably that preset (Mutate moves 8–12% from the
+ * current values; a free roll covers 100%). Choices and opted-in switches keep the preset's
+ * pick, changing `switch` of the time. Colours keep their family: hue within ±`hue`°,
+ * lightness ±`lightness`, chroma ±`chroma` of what that hue can hold. Seeds roll freely: a new
+ * pattern is what a seed is for.
+ */
+export declare const AROUND: {
+    readonly spread: 0.35;
+    readonly switch: 0.3;
+    readonly hue: 20;
+    readonly lightness: 0.06;
+    readonly chroma: 0.15;
+};
+/**
+ * One field's roll around `base` (an active preset's value): see `AROUND`. Fields with nothing
+ * to vary around (keys, seeds) roll as `pick` does.
+ */
+export declare function around(field: ValueField, base: unknown, random: () => number): unknown;
 export declare function randomValues<S extends Schema>(schema: S, random?: () => number): Values<S>;

package/dist/types/core/remote.d.ts

@@ -26,9 +26,11 @@ export interface SpringBindingDescriptor extends DescriptorMeta {
     };
     readonly default?: SpringValue;
 }
-/** A button row: pressing it calls `onAction(key)`. */
+/** A button row: pressing it calls `onAction(key)`. `shortcut` takes a combination here. */
 export interface ActionDescriptor extends DescriptorMeta {
     readonly kind: "action";
+    readonly global?: boolean;
+    readonly rebind?: boolean;
     readonly default?: undefined;
     readonly bind?: undefined;
 }
@@ -116,6 +118,8 @@ export interface RemoteControlsOptions {
     readonly enabled?: boolean | (() => boolean);
     /** Ships the panel as product UI, live in production: `() => import("knobs/panel")` (see `ControlsOptions.ship`). */
     readonly ship?: () => Promise<PanelModule>;
+    /** The key that shows and hides its panels with the page's others (see `ControlsOptions.toggleKey`). */
+    readonly toggleKey?: string | false;
     /** How long (ms) a key changed here outranks incoming values for it; 600 by default. */
     readonly echo?: number;
     /**

package/dist/types/core/schema.d.ts

@@ -20,7 +20,10 @@ export interface FieldMeta {
     /** One muted line under the section's heading on a page (the first field that gives one wins). */
     readonly sectionDescription?: string;
     readonly shortcut?: string;
-    /** `false` keeps the field out of Random and Mutate, as a lock does, but by declaration. */
+    /**
+     * `false` keeps the field out of Random and Mutate, as a lock does, but by declaration. Switches,
+     * seeds and key combinations start out; `true` brings them in.
+     */
     readonly random?: boolean;
     /**
      * The row dims and takes no edits from the pointer or keys (focus can still reach it, to read
@@ -75,6 +78,11 @@ export interface Knob extends FieldMeta {
     /** Digits after the point in the readout; the step's own by default. */
     readonly decimals?: number;
     readonly spring?: SpringPart;
+    /**
+     * Whether a drag sticks for a moment at the default, the active preset's value and the middle
+     * (and zero); `false` lets it glide straight through.
+     */
+    readonly detents?: boolean;
 }
 export interface Choice<T extends string = string> extends FieldMeta {
     readonly kind: "choice";
@@ -141,6 +149,12 @@ export interface CurveField extends FieldMeta {
 export interface ActionField extends FieldMeta {
     readonly kind: "action";
     readonly run?: () => void;
+    /** The combination that presses it (`"Shift+K"`), shown as a key cap at the row's end. */
+    readonly shortcut?: string;
+    /** Where `shortcut` works, as a toolbar button's (see `ToolbarShortcut`); `"panel"` by default. */
+    readonly scope?: "page" | "panel" | "none";
+    /** The user can rebind it in place: a click or Enter on the key cap listens for a new one. */
+    readonly rebind?: boolean;
 }
 export interface Vec3 {
     readonly x: number;
@@ -350,9 +364,17 @@ export declare function choice<const T extends readonly [string, ...string[]]>(v
     readonly labels?: Readonly<Partial<Record<T[number], string>>>;
     readonly display?: "menu" | "segmented";
 }): Choice<T[number]>;
-/** `action("Replay", { run })`: a button row. Its key also reaches the store's `onAction`. */
-export declare function action(label?: string, meta?: Omit<FieldMeta, "label"> & {
+/**
+ * `action("Replay", { run, shortcut: "Shift+K", global: true, rebind: true })`: a button row. Its
+ * key also reaches the store's `onAction`. `shortcut` presses it as a toolbar button's does (a
+ * combination, or `{ key, scope }`), and `rebind` lets the user change it from its key cap.
+ */
+export declare function action(label?: string, meta?: Omit<FieldMeta, "label" | "shortcut"> & {
     run?: () => void;
+    shortcut?: string | ToolbarShortcut;
+    /** A plain-string shortcut works anywhere on the page (as `scope: "page"`). */
+    global?: boolean;
+    rebind?: boolean;
 }): ActionField;
 type SpringHalf = number | Knob;
 /**
@@ -369,6 +391,10 @@ export declare function flatSpring(parts?: {
     readonly duration: Knob;
     readonly bounce: Knob;
 };
+/**
+ * A switch. Switches usually show or hide things (a view, a scene's parts), so Random and Mutate
+ * leave them alone unless `random: true`.
+ */
 export declare function toggle(value: boolean, meta?: FieldMeta): Toggle;
 /** `spring({ duration: 0.4, bounce: 0.2 })`, like SwiftUI's `.spring(duration:bounce:)`. */
 export declare function spring(value?: Partial<SpringValue>, meta?: FieldMeta): SpringField;
@@ -469,11 +495,14 @@ export declare function curve(points: readonly CurvePoint[] | keyof typeof CURVE
     readonly presets?: Readonly<Record<string, readonly CurvePoint[]>>;
     readonly shapes?: boolean;
 }): CurveField;
-/** A toolbar item's shortcut as `{ key, scope }`, or undefined without one. */
-export declare function toolbarShortcut(item: ToolbarItem): {
+type ResolvedShortcut = {
     readonly key: string;
     readonly scope: "page" | "panel" | "none";
-} | undefined;
+};
+/** A toolbar item's shortcut as `{ key, scope }`, or undefined without one. */
+export declare function toolbarShortcut(item: ToolbarItem): ResolvedShortcut | undefined;
+/** An action row's shortcut as `{ key, scope }`, or undefined without one. */
+export declare function actionShortcut(field: ActionField): ResolvedShortcut | undefined;
 /** A wrapping row of buttons with icons and shortcut chips; holds no value. */
 export declare function toolbar(items: readonly ToolbarItem[], meta?: FieldMeta): ToolbarField;
 type ReadoutOptions = Omit<ReadoutMeta, "shortcut" | "random" | "readOnly">;

package/dist/types/core/store.d.ts

@@ -15,7 +15,8 @@ export interface ChipOptions {
     /**
      * When the chip shows. `"hover"`: while the element is hovered or focused. `"shortcut"`: hidden
      * until `shortcut` turns on knobs mode (remembered for the tab), then on hover. `"always"`:
-     * whenever its panel is closed. `"hover"` in development, `"shortcut"` in production builds.
+     * whenever its panel is closed. `"hover"` in development (and on a page someone unlocked),
+     * `"shortcut"` for a shipped store in production builds.
      */
     readonly reveal?: RevealMode;
     /** The key that toggles knobs mode for `"shortcut"` chips: `"Alt+Shift+D"` (⌥⇧D) by default. */
@@ -36,6 +37,16 @@ export interface ChangeMeta {
     readonly coalesce?: boolean;
     readonly key?: string;
     readonly group?: string;
+    /** A reset that went back to the active preset (see `Controls.activePreset`), not the defaults. */
+    readonly base?: boolean;
+}
+/**
+ * The preset last applied from the strip: a schema preset (by id) or a saved variant. It's the
+ * base Reset returns to and Random explores around.
+ */
+export interface PresetRef {
+    readonly kind: "preset" | "variant";
+    readonly id: string;
 }
 export interface ControlAction<V = State> {
     readonly id?: string;
@@ -86,7 +97,7 @@ export type PanelCommand = "random" | "mutate" | "reset" | "resetAll" | "compare
 export type PanelKeys = {
     readonly [C in PanelCommand]?: string | boolean;
 } & {
-    /** `false` drops the j/k and h/l aliases: only the arrows move and adjust; the letters reach the page. */
+    /** `false` drops the j/k aliases: only the arrows move; the letters reach the page. */
     readonly vim?: boolean;
     /**
      * `false` stops digits, `.`, `-` and Enter from opening a slider's inline number editor (they
@@ -98,6 +109,14 @@ export type PanelKeys = {
     /** `false` stops ↑/↓ at the first and last rows instead of wrapping around. */
     readonly wrap?: boolean;
 };
+/** `glass` (the default): ticks with a faint ring. `mech`: drier, the rings all but gone. */
+export type SoundTheme = "glass" | "mech";
+/** A mount's `sound`, beyond `true`. */
+export interface SoundOptions {
+    /** This panel's level, 0–1 (times `sound.volume`). */
+    readonly volume?: number;
+    readonly theme?: SoundTheme;
+}
 /** A header button (see `MountPanelOptions.header`). */
 export type HeaderButton = "random" | "reset" | "copy" | "undo" | "redo" | "help" | "close";
 export interface HeaderOptions {
@@ -126,6 +145,12 @@ export interface MountPanelOptions extends LabelOptions {
      * don't join the page's. `keys: { hint: false }` turns hint mode off here either way.
      */
     readonly hints?: "page" | "panel";
+    /**
+     * The key that shows and hides every panel and chip on the page that listens for it, outside
+     * text fields and without modifiers; remembered per store. The store's `toggleKey` by default
+     * (a backtick), `false` on a full page (`mountPage`). `false`: this panel always shows.
+     */
+    readonly toggleKey?: string | false;
     /**
      * `false` hides what says a value differs from its default: modified dots and readout marks,
      * group reset icons and the header's Reset. For panels whose values belong to someone else
@@ -141,6 +166,11 @@ export interface MountPanelOptions extends LabelOptions {
      * list, every button but `help` shows (see `HeaderOptions`).
      */
     readonly header?: boolean | HeaderOptions;
+    /**
+     * `false` drops the scope line beside the title (`Shape › Cohesion`, where keys go, and a faint
+     * `esc ↑ Shape` for where Esc goes). The focus lens and the armed frame stay.
+     */
+    readonly crumbs?: boolean;
     /**
      * `false`: no per-tab session, so a rebuilt panel doesn't take focus back to the row it last
      * had or reopen editors and folded groups. On while the store has storage.
@@ -185,6 +215,18 @@ export interface MountPanelOptions extends LabelOptions {
      * Reduced motion turns them off too.
      */
     readonly haptics?: boolean;
+    /**
+     * Magnetic detents on slider drags and pans (the default, the active preset's value, the middle
+     * and zero); on by default, `false` turns them off for the whole panel.
+     */
+    readonly detents?: boolean;
+    /**
+     * Sound effects: quiet, short ticks and clicks synthesized live for the panel's moments (a
+     * slider's detents, a switch, Random, Copy…). Off by default; `true` turns them on, or
+     * `{ volume, theme }`. The page's switch (`sound.enable(false)` from `knobs/panel`) mutes every
+     * panel, and the `?` popover offers it as Sounds, kept in the store's storage.
+     */
+    readonly sound?: boolean | SoundOptions;
     /** Called once the panel is mounted, with a handle to focus it (a host's "Tune" key). */
     readonly onReady?: (panel: PanelHandle) => void;
     /** What Copy (and ⇧C) puts on the clipboard; `controls.code()` by default. */
@@ -255,6 +297,8 @@ export interface PanelHandle {
 export interface PanelModule {
     mountPanel(controls: Controls<any>, container: HTMLElement, options?: MountPanelOptions): PanelHandle;
     attach(controls: Controls<any>, element: HTMLElement, chip?: ChipOptions): () => void;
+    /** A brief status at the bottom of the page ("knobs unlocked"). */
+    status?(text: string): void;
 }
 export interface ControlsOptions<S extends Schema> extends LabelOptions {
     enabled?: boolean | (() => boolean);
@@ -267,6 +311,12 @@ export interface ControlsOptions<S extends Schema> extends LabelOptions {
     ship?: () => Promise<PanelModule>;
     /** The chip `attach` shows: its label, when it shows and the knobs-mode key (see `ChipOptions`). */
     chip?: ChipOptions;
+    /**
+     * The key that shows and hides this store's panels and chips, with every other panel on the
+     * page that listens for it (see `MountPanelOptions.toggleKey`). A backtick by default; `false`
+     * for a shipped store (`ship`), whose panels are product UI. `false`: always shown.
+     */
+    toggleKey?: string | false;
     /**
      * The longest (ms) a key changed here outranks incoming values for it (see `sync`), so an echo
      * of an older value still in flight can't pull it back. The hold ends early once the remote
@@ -345,6 +395,8 @@ export interface Controls<S extends Schema = Schema> {
         readonly reveal: RevealMode;
         readonly shortcut: string;
     };
+    /** The key that shows and hides its panels and chips, or `false` (see `ControlsOptions.toggleKey`). */
+    readonly toggleKey: string | false;
     /** How page cards show group presets (`groupPresetDisplay`, `auto` by default). */
     readonly groupPresetDisplay: GroupPresetDisplay;
     /** A group's display label (`groupLabels`, else its fields' `groupLabel`), if it has one. */
@@ -406,17 +458,28 @@ export interface Controls<S extends Schema = Schema> {
     readonly canRedo: boolean;
     subscribe(cb: () => void): () => void;
     /**
-     * Back to the defaults: every field, or only `keys`. Locks don't apply; disabled and read-only
-     * fields keep their values.
+     * Back to the active preset (see `activePreset`) while anything differs from it, else to the
+     * defaults: every field, or only `keys`. Reaching the defaults with every field also forgets
+     * the active preset. Locks don't apply; disabled and read-only fields keep their values.
      */
     reset(keys?: readonly (keyof S & string)[]): void;
+    /** One key, as `reset` does: to the active preset's value, else (already there) its default. */
     resetKey(key: keyof S & string): void;
+    /**
+     * A group, as `reset` does: to its active group preset (or the panel's active preset) while it
+     * differs from it, else to its defaults, which forgets the group's preset.
+     */
     resetGroup(group: string): void;
+    /** Whether the key (or anything) differs from the active preset; the defaults without one. */
     isModified(key?: keyof S & string): boolean;
+    /** Whether `reset` (of every field, or `keys`) would change anything. */
+    canReset(keys?: readonly (keyof S & string)[]): boolean;
+    /** What differs from the defaults (the values `code()` and Swift export care about). */
     modified(): Partial<Values<S>>;
     /**
      * Random values for every field that can roll (see `canRoll`), or those among `keys`, drawn
-     * from `random`. One undo step.
+     * from `random`. With an active preset, they land near its values (see `AROUND`) instead of
+     * anywhere in range. One undo step.
      */
     randomize(keys?: readonly (keyof S & string)[]): void;
     /** Small changes around the current values instead of a re-roll; skips what can't roll. */
@@ -424,6 +487,17 @@ export interface Controls<S extends Schema = Schema> {
     /** Keeps fields out of Random and Mutate (or lets them back in). Saved with the values. */
     lock(keys: (keyof S & string) | readonly (keyof S & string)[], locked?: boolean): void;
     isLocked(key: keyof S & string): boolean;
+    /**
+     * The combination that presses an action row now, or a toolbar's button (`item`, its id or
+     * label): the user's rebinding, else the declared `shortcut`; `""` when cleared, undefined
+     * when there's none.
+     */
+    shortcut(key: keyof S & string, item?: string): string | undefined;
+    /**
+     * Rebinds an action row's shortcut (or a toolbar button's): a combination, `""` for none, or
+     * undefined to restore the declared one. Not undoable; saved with the values, as locks are.
+     */
+    rebind(key: keyof S & string, combo: string | undefined, item?: string): void;
     /**
      * Whether Random and Mutate may change `key`: it holds a value and isn't locked, `random:
      * false`, refused by `tunable`, disabled or read-only.
@@ -451,13 +525,28 @@ export interface Controls<S extends Schema = Schema> {
      */
     compare(hold: boolean): void;
     readonly comparing: boolean;
-    preset(id: string): void;
+    /**
+     * Applies a preset and makes it the active one (`"default"` clears it); one undo step, or
+     * folded into the last with `coalesce` (a pan across the strip).
+     */
+    preset(id: string, options?: {
+        coalesce?: boolean;
+    }): void;
     matchingPreset(): string;
+    /**
+     * The preset (or saved variant) last applied, which Reset returns to and Random explores
+     * around, or null. Kept with the values; forgotten by a reset to the defaults.
+     */
+    activePreset(): PresetRef | null;
+    /** The group preset last applied to `group` (0-based), or -1. */
+    activeGroupPreset(group: string): number;
+    /** The values Reset returns to first: the active presets over the defaults. */
+    baseValues(): Values<S>;
     /** Each group's numbered presets, complete over the keys they cover. */
     readonly groupPresets: Readonly<Record<string, readonly GroupPreset<Values<S>>[]>>;
     /**
-     * Applies a group's preset (0-based), one undo step; `coalesce` folds it into the previous
-     * one (a pan across a card's presets).
+     * Applies a group's preset (0-based) and makes it the group's active one, one undo step;
+     * `coalesce` folds it into the previous one (a pan across a card's presets).
      */
     groupPreset(group: string, index: number, options?: {
         coalesce?: boolean;

package/dist/types/core/unlock.d.ts

@@ -0,0 +1,77 @@
+import type { PanelModule } from "./store.js";
+/** The Konami code: ↑ ↑ ↓ ↓ ← → ← → B A, as key names for `unlock({ sequence })`. */
+export declare const KONAMI: readonly string[];
+export type Corner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export interface UnlockOptions {
+    /**
+     * The panel code, loaded only once someone unlocks: `() => import("knobs/panel")`. Your bundler
+     * splits it into its own chunk, so visitors who never unlock download none of it.
+     */
+    readonly panel: () => Promise<PanelModule>;
+    /**
+     * Typed anywhere outside a text field: a word (`"knobs"` by default) or a list of key names
+     * (`KONAMI`). Typing it again locks. `false`: none.
+     */
+    readonly sequence?: string | readonly string[] | false;
+    /** `?knobs` in the URL unlocks and `?knobs=off` locks (`"knobs"` by default). `false`: none. */
+    readonly query?: string | false;
+    /**
+     * Three quick taps or clicks in this corner of the window (`"top-right"` by default), for
+     * phones. Three more lock. `false`: none.
+     */
+    readonly corner?: Corner | false;
+    /** Remember being unlocked in localStorage until it's locked again (default true). */
+    readonly persist?: boolean;
+}
+/** A page's secret unlock (see `unlock`). */
+export interface Unlock {
+    readonly unlocked: boolean;
+    unlock(): void;
+    lock(): void;
+    /** Stops listening for the sequence and the corner; the state stays as it is. */
+    dispose(): void;
+}
+/** Whether this page has been unlocked (see `unlock`). */
+export declare const isUnlocked: () => boolean;
+/** The panel module an unlocked page mounts from, if `unlock` named one. */
+export declare const unlockedPanel: () => (() => Promise<PanelModule>) | undefined;
+/** Calls `listener` whenever the page locks or unlocks. */
+export declare function onUnlock(listener: () => void): () => void;
+export declare const UNLOCK_KEY = "knobs:unlocked";
+/** The keys a sequence is typed with: a word's letters, or key names as given. */
+export declare function sequenceKeys(sequence: string | readonly string[]): string[];
+/**
+ * Watches keys go by for `sequence`: true on the key that completes it. Letters match in either
+ * case, a wrong key starts over (keeping what it could begin), and a pause longer than `gap` ms
+ * forgets what was typed.
+ */
+export declare function sequenceMatcher(sequence: string | readonly string[], gap?: number): (key: string, at: number) => boolean;
+/**
+ * What the URL says: `?knobs` (or `=1`, `=on`, `=true`) unlocks, `?knobs=off` (or `=0`, `=false`,
+ * `=lock`) locks, and without it, undefined.
+ */
+export declare function queryUnlock(search: string, name: string): boolean | undefined;
+/**
+ * Whether a page view starts unlocked: the URL decides when it says, else what was remembered
+ * (only when `persist`). `remember` is what to keep afterwards (undefined: leave it).
+ */
+export declare function resolveUnlock(input: {
+    readonly query: boolean | undefined;
+    readonly stored: boolean;
+    readonly persist: boolean;
+}): {
+    readonly unlocked: boolean;
+    readonly remember: boolean | undefined;
+};
+/** Whether a point is in `corner` of a `width` × `height` window, within `size` px. */
+export declare function inCorner(x: number, y: number, width: number, height: number, corner: Corner, size?: number): boolean;
+/** Counts quick taps: true on the `count`th, each within `within` ms of the last. */
+export declare function tapCounter(count?: number, within?: number): (at: number) => boolean;
+/**
+ * Lets this deploy be unlocked: stores stay locked to their shipped values and mount nothing
+ * until someone types the sequence, opens the page with `?knobs`, or taps the corner three
+ * times. Then they come alive (values from this browser's storage) and the panel code loads.
+ * The same again locks, back to the shipped values. In development it changes nothing: stores
+ * are live there anyway.
+ */
+export declare function unlock(options: UnlockOptions): Unlock;

package/dist/types/core/variants.d.ts

@@ -9,9 +9,17 @@ export interface Variants<V> {
     readonly ready: boolean;
     list(): readonly Variant<V>[];
     save(name?: string): Variant<V>;
-    load(id: string): void;
+    /**
+     * Applies a saved variant, making it the active preset (see `Controls.activePreset`); one undo
+     * step, or folded into the last with `coalesce` (a pan across the strip).
+     */
+    load(id: string, options?: {
+        coalesce?: boolean;
+    }): void;
+    /** Renames a saved variant (an empty name clears it); kept in storage with the variants. */
+    rename(id: string, name: string): void;
     remove(id: string): void;
     export(): string;
     import(json: string): void;
 }
-export declare function createVariants<S extends Schema>(schema: () => S, id: string, key: string, storage: () => StoragePort | null, get: () => Values<S>, set: (v: Values<S>) => void, notify: () => void, enabled: () => boolean): Variants<Values<S>>;
+export declare function createVariants<S extends Schema>(schema: () => S, id: string, key: string, storage: () => StoragePort | null, get: () => Values<S>, set: (v: Values<S>, id: string, coalesce: boolean) => void, notify: () => void, enabled: () => boolean): Variants<Values<S>>;

package/dist/types/index.d.ts

@@ -1,12 +1,14 @@
-export { knob, choice, toggle, spring, color, point, easing, action, flatSpring, vec2, vec3, range, angle, seed, keybind, gradient, curve, toolbar, toolbarShortcut, watch, sparkline, graph, meter, table, log, hasValue, isReadout, wrapAngle, SPRING, type FieldMeta, type ActionField, type SpringPart, type ValueField, type Knob, type Choice, type Toggle, type SpringField, type ColorField, type PointField, type EasingField, type VecField, type Vec3, type RangeField, type AngleField, type SeedField, type KeybindField, type GradientField, type CurveField, type ToolbarField, type ToolbarItem, type ToolbarShortcut, type WatchField, type SparklineField, type GraphField, type GraphSeries, type GraphThreshold, type MeterField, type TableField, type LogField, type ReadoutField, type ReadoutKeys, type ReadoutInput, type Point, type Field, type Schema, type Values, type Value, type State, } from "./core/schema.js";
+export { knob, choice, toggle, spring, color, point, easing, action, flatSpring, vec2, vec3, range, angle, seed, keybind, gradient, curve, toolbar, toolbarShortcut, actionShortcut, watch, sparkline, graph, meter, table, log, hasValue, isReadout, wrapAngle, SPRING, type FieldMeta, type ActionField, type SpringPart, type ValueField, type Knob, type Choice, type Toggle, type SpringField, type ColorField, type PointField, type EasingField, type VecField, type Vec3, type RangeField, type AngleField, type SeedField, type KeybindField, type GradientField, type CurveField, type ToolbarField, type ToolbarItem, type ToolbarShortcut, type WatchField, type SparklineField, type GraphField, type GraphSeries, type GraphThreshold, type MeterField, type TableField, type LogField, type ReadoutField, type ReadoutKeys, type ReadoutInput, type Point, type Field, type Schema, type Values, type Value, type State, } from "./core/schema.js";
 export { springCss, springMotion, type SpringValue } from "./core/spring.js";
 export { colorHex, parseColor, type Oklch } from "./core/color.js";
 export { sampleGradient, sampleCurve, gradientCss, CURVE_SHAPES, type GradientStop, type GradientSpace, type CurvePoint, type CurveInterp, type SampleGradientOptions, type SampleCurveOptions, } from "./core/ramp.js";
 export { bezierCss, bezierPoint, EASINGS, type Bezier, type EasingName } from "./core/easing.js";
-export { defineControls, type ChangeMeta, type GestureEvent, type ChangeSource, type ChipOptions, type ControlAction, type Controls, type ControlsOptions, type DensityMode, type GroupPreset, type GroupPresetDisplay, type HeaderButton, type HeaderOptions, type HostHistory, type LabelOptions, type MountPanelOptions, type PanelCommand, type PanelHandle, type PanelModule, type PanelKeys, type PersistMode, type SearchChip, type SearchOptions, type SyncOptions, type RendererMode, type RevealMode, type SectionFolded, type ThemeMode, } from "./core/store.js";
+export { AROUND } from "./core/random.js";
+export { defineControls, type ChangeMeta, type GestureEvent, type ChangeSource, type ChipOptions, type ControlAction, type Controls, type ControlsOptions, type DensityMode, type GroupPreset, type GroupPresetDisplay, type PresetRef, type HeaderButton, type HeaderOptions, type HostHistory, type LabelOptions, type MountPanelOptions, type PanelCommand, type PanelHandle, type PanelModule, type PanelKeys, type PersistMode, type SearchChip, type SearchOptions, type SyncOptions, type RendererMode, type RevealMode, type SectionFolded, type SoundOptions, type SoundTheme, type ThemeMode, } from "./core/store.js";
 export { createRemoteControls, descriptorToField, formatSwift, fromDescriptors, fromSettings, type SettingsGroup, type SettingsItem, type ActionDescriptor, type ChoiceOption, type ControlDescriptor, type SpringBindingDescriptor, type ToolbarDescriptor, type ReadoutDescriptor, type ValueDescriptor, type RemoteControls, type RemoteControlsOptions, } from "./core/remote.js";
 export type { LogEntry, LogLevel, TableRows, WatchValue } from "./core/readout.js";
 export { memoryStorage, urlFlag, type StoragePort } from "./core/storage.js";
+export { KONAMI, unlock, type Corner, type Unlock, type UnlockOptions } from "./core/unlock.js";
 export type { TokenPreset } from "./core/theme.js";
 export { formatCode, type CodeFormat } from "./core/code.js";
 export { comboFromEvent, letterOf, comboLabel, comboParts, matchesCombo, normalizeCombo, } from "./core/keys.js";

package/dist/types/panel/attach.d.ts

@@ -3,3 +3,5 @@ import type { Schema } from "../core/schema.js";
 export declare function attach<S extends Schema>(controls: Controls<S>, element: HTMLElement, options?: ChipOptions): () => void;
 /** Parses `"Alt+Shift+D"` into a test for keydown events. Letters and digits match by key position. */
 export declare function matchShortcut(shortcut: string): (event: KeyboardEvent) => boolean;
+/** A brief status at the bottom of the page, as knobs mode's "knobs on" ("knobs unlocked"). */
+export declare function status(text: string, doc?: Document): void;

package/dist/types/panel/crumbs.d.ts

@@ -0,0 +1,19 @@
+import { type Crumb, type CrumbLevel } from "./scope.js";
+export declare const CRUMB_GLIDE: string;
+export interface CrumbsView {
+    readonly element: HTMLElement;
+    /** The trail for where focus is, and where Esc goes from there (none at the panel). */
+    set(trail: readonly Crumb[], esc?: string): void;
+    /** Shows or quiets the Esc hint. */
+    hint(on: boolean): void;
+    /** Re-place it after the header's layout changed. */
+    layout(): void;
+    dispose(): void;
+}
+export declare function createCrumbs(o: {
+    header: HTMLElement;
+    title: HTMLElement;
+    jump: (level: CrumbLevel | "panel") => void;
+    reduced: () => boolean;
+    wake: () => void;
+}): CrumbsView;

package/dist/types/panel/editors.d.ts

@@ -54,6 +54,17 @@ export interface EditorRow {
     dispose(): void;
     readonly tracks: readonly SubTrack[];
     readonly gpu: readonly GpuRowBinding[];
+    /** Named options the digits pick while the row is focused (a ramp's or easing's presets). */
+    readonly options?: RowOptions;
+}
+/** A row's options as the digits 1–9 pick them (see scope.ts). */
+export interface RowOptions {
+    readonly count: number;
+    choose(i: number): void;
+    /** The options while they show (segments, chips), for a digit on each; empty while hidden. */
+    shown(): readonly HTMLElement[];
+    /** What stands for them while they're hidden (a menu's button, a head's mini curve). */
+    readonly anchor: Element;
 }
 export declare const reducedMotion: (doc: Document) => boolean;
 export declare const rgbCss: (rgb: readonly number[]) => string;
@@ -154,6 +165,15 @@ export declare function panPresets(c: RowContext<unknown>, head: HTMLElement, nu
     at(): number;
     choose(i: number, coalesce: boolean): void;
 }): void;
+/** Named presets as chips in a radiogroup (the easing editor's look); ←/→ cycle them. */
+export declare function presetChips(c: RowContext<unknown>, names: readonly string[], choose: (i: number) => void, cls?: string): {
+    el: HTMLDivElement;
+    buttons: HTMLButtonElement[];
+    cycle: (dir: number) => void;
+    check(i: number): void;
+};
+/** ←/→ on `target` itself cycle the presets (a row's head, the chips). */
+export declare function cycleKeys(targets: readonly HTMLElement[], row: HTMLElement, cycle: (dir: number) => void): void;
 /** A mini curve in the head; an editor with two handles and named chips in the body. */
 export declare function easingRow(c: RowContext<EasingField>): EditorRow;
 export {};