@kitlangton/knobs 0.4.0-next.14 → 0.4.0-next.15

package/README.md

@@ -838,8 +838,13 @@ panel.tab("emitter") // shows a tab; panel.tab() answers the one showing
 - **Keys presets leave alone, in place.** `inPresets: false` on a field, or `inPresets: { Motion:
   false }` on the store for a whole group, keeps presets, scoped presets and saved variants off
   those keys exactly as they stay off pinned ones (and a preset's chip stays lit when they move),
-  but the rows stay where they are. A pinned key is one of these, moved to the top.
-  `controls.inPresets(key)` says whether presets move a key.
+  but the rows stay where they are. A pinned key is one of these, moved to the top. The rule, for
+  `inPresets: false` and `pinned` groups alike: presets and variants from *other* scopes (the
+  panel-wide presets, tab scopes, other groups') leave the group alone, but a scope keyed by the
+  group's own name still moves it. So `inPresets: { Motion: false }` with
+  `scopedPresets: { Motion: { Snappy } }` gives Motion its own strip that state presets never
+  touch; its chips apply, save, match and mark only Motion. A field's own `inPresets: false` stays
+  out of every scope. `controls.inPresets(key)` says whether presets from other scopes move a key.
 - **Presets of a tab's own.** `scopedPresets` gives a tab (or a group) presets that belong to it:
   `{ Sidebars: { snappy, smooth, calm } }`. Its strip shows only on that tab, and a tab without any
   shows none. A scoped preset moves only its tab's (or group's) keys, never pinned ones or another
@@ -854,7 +859,8 @@ panel.tab("emitter") // shows a tab; panel.tab() answers the one showing
   group keeps Shipped, Snappy and Calm beside its knobs. Every strip's default chip reads `defaultLabel`; by scope,
   `defaultLabel: { "": "Empty", Motion: "Shipped" }` names each on its own. In code, `controls.preset(id, { scope })`, `activePreset(scope)` and
   `matchingPreset(scope)` take the tab or group, and `controls.scopeOf(key)` says whose presets
-  move a key (`""` for plain `presets`, undefined when pinned). An active preset saved while the
+  move a key (`""` for plain `presets`, the group's id for a pinned or `inPresets: false`
+  group with a scope of its own, else undefined when pinned). An active preset saved while the
   presets were panel-wide comes back on the scope that now has one by that id, and variants saved
   then start out in each scope they move.
 

package/dist/dev/{chunk-s7d5a8vb.js → chunk-49hkdggk.js}

@@ -16107,7 +16107,7 @@ function buildPanel(controls, host, options) {
           }
           under = name, nodes.push(r.row);
         }
-        let strip = run.group !== void 0 && !run.pinned && !stripped.has(run.group) ? groupStripFor(run.group) : void 0;
+        let strip = run.group !== void 0 && !stripped.has(run.group) ? groupStripFor(run.group) : void 0;
         if (strip)
           stripped.add(run.group);
         if (arrange(block.card, strip ? [strip.element, ...nodes] : nodes), animate && at >= 0) {

package/dist/dev/{chunk-f0e5tkqg.js → chunk-902v1jgd.js}

@@ -82,7 +82,7 @@ function attach(controls, element, options = {}) {
       return;
     loading = !0;
     try {
-      let { createPanel } = await import("./chunk-s7d5a8vb.js");
+      let { createPanel } = await import("./chunk-49hkdggk.js");
       if (disposed || !controls.enabled || panel)
         return;
       if (panel = createPanel(controls, element, close, { restored, chip }), remember)

package/dist/dev/index.js

@@ -625,9 +625,13 @@ function defineControls(id, input, options = {}) {
       named.add(variants);
     let of = /* @__PURE__ */ new Map;
     for (let k of valueKeys(schema)) {
-      if (presetFree().has(k))
+      let f = fields[k];
+      if (presetFree().has(k)) {
+        if (f.inPresets !== !1 && f.group !== void 0 && named.has(f.group))
+          of.set(k, f.group);
         continue;
-      let f = fields[k], tab = tabOf(f);
+      }
+      let tab = tabOf(f);
       of.set(k, tab !== void 0 && named.has(tab) ? tab : f.group !== void 0 && named.has(f.group) ? f.group : "");
     }
     return scopingOf = { schema, of, named: [...named], variants }, scopingOf;
@@ -1522,11 +1526,11 @@ function defineControls(id, input, options = {}) {
     code: (format, values) => formatCode(values ?? get(), format),
     variants,
     attach(element, chip) {
-      let load = options.ship ? () => options.ship().then((m) => m.attach) : () => import("./chunk-f0e5tkqg.js").then((m) => m.attach);
+      let load = options.ship ? () => options.ship().then((m) => m.attach) : () => import("./chunk-902v1jgd.js").then((m) => m.attach);
       return live(load, (attach) => attach(controls, element, chip), (detach) => detach());
     },
     mount(container, mountOptions) {
-      let load = options.ship ? () => options.ship().then((m) => m.mountPanel) : () => import("./chunk-s7d5a8vb.js").then((m) => m.mountPanel);
+      let load = options.ship ? () => options.ship().then((m) => m.mountPanel) : () => import("./chunk-49hkdggk.js").then((m) => m.mountPanel);
       return live(load, (mountPanel) => {
         let panel = mountPanel(controls, container, mountOptions);
         return mountOptions?.onReady?.(panel), panel;

package/dist/index.js

@@ -1688,9 +1688,13 @@ function defineControls(id, input, options = {}) {
       named.add(variants);
     let of = /* @__PURE__ */ new Map;
     for (let k of valueKeys(schema)) {
-      if (presetFree().has(k))
+      let f = fields[k];
+      if (presetFree().has(k)) {
+        if (f.inPresets !== !1 && f.group !== void 0 && named.has(f.group))
+          of.set(k, f.group);
         continue;
-      let f = fields[k], tab = tabOf(f);
+      }
+      let tab = tabOf(f);
       of.set(k, tab !== void 0 && named.has(tab) ? tab : f.group !== void 0 && named.has(f.group) ? f.group : "");
     }
     return scopingOf = { schema, of, named: [...named], variants }, scopingOf;

package/dist/panel.js

@@ -27530,7 +27530,7 @@ function buildPanel(controls, host, options) {
           under = name;
           nodes.push(r.row);
         }
-        const strip = run.group !== undefined && !run.pinned && !stripped.has(run.group) ? groupStripFor(run.group) : undefined;
+        const strip = run.group !== undefined && !stripped.has(run.group) ? groupStripFor(run.group) : undefined;
         if (strip)
           stripped.add(run.group);
         arrange(block.card, strip ? [strip.element, ...nodes] : nodes);

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

@@ -389,13 +389,15 @@ export interface ControlsOptions<S extends Schema> extends LabelOptions {
      * Groups pinned to the top of a panel, under the header and above the tab strip, on every tab
      * (as fields' `pinned: true` pins theirs). Presets and saved variants leave them alone: applying
      * one keeps their values, saving one keeps them out, and they're modified against their defaults.
+     * A scope keyed by the group's own name (`scopedPresets`) still moves it.
      */
     pinned?: readonly string[];
     /**
      * Groups presets leave alone, where they are: `{ Motion: false }`. As with pinned groups,
      * applying a preset or variant keeps their values, saving one leaves them out, and a preset's chip
-     * doesn't drift when they change; but their rows stay in place. A field says it alone with
-     * `inPresets: false`.
+     * doesn't drift when they change; but their rows stay in place. A scope keyed by the group's own
+     * name (`scopedPresets: { Motion: … }`) still moves it: only other scopes' presets leave it
+     * alone. A field says it alone with `inPresets: false`, and then no scope moves it.
      */
     inPresets?: Readonly<Record<string, boolean>>;
     /**
@@ -449,7 +451,7 @@ export interface Controls<S extends Schema = Schema> {
     readonly scopes: Readonly<Record<string, PresetScope<Values<S>>>>;
     /**
      * The scope `key`'s presets come from: a tab or group's id, `""` for `presets`, or undefined
-     * when presets leave it alone (pinned, `inPresets: false`).
+     * when presets leave it alone (pinned, `inPresets: false`, without a scope of its group's own).
      */
     scopeOf(key: string): string | undefined;
     readonly actions: readonly ControlAction<Values<S>>[];
@@ -485,7 +487,10 @@ export interface Controls<S extends Schema = Schema> {
     presetLabel(id: string, scope?: string): string;
     /** Whether `key` is pinned (its group is, see `ControlsOptions.pinned`), outside the presets. */
     isPinned(key: string): boolean;
-    /** Whether presets move `key`: false when it's pinned or says `inPresets: false` (or its group does). */
+    /**
+     * Whether presets move `key`: false when it's pinned or says `inPresets: false` (or its group
+     * does). Its group's own scope may still move it (see `scopeOf`).
+     */
     inPresets(key: string): boolean;
     readonly error: string | null;
     get(): Values<S>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitlangton/knobs",
-  "version": "0.4.0-next.14",
+  "version": "0.4.0-next.15",
   "description": "Per-component tuning controls. Explore in development, ship constants.",
   "type": "module",
   "license": "MIT",