@kitlangton/knobs 0.4.0-next.12 → 0.4.0-next.13

package/dist/dev/index.js

@@ -481,7 +481,7 @@ function unlock(options) {
 }
 
 // src/core/variants.ts
-function createVariants(schema, id, key, storage, get, set, notify, enabled) {
+function createVariants(schema, id, key, storage, get, set, notify, enabled, seed) {
   let ready = !1, list = Object.freeze([]);
   function parse(json) {
     let data = JSON.parse(json);
@@ -510,7 +510,7 @@ function createVariants(schema, id, key, storage, get, set, notify, enabled) {
     if (ready || !enabled())
       return;
     let json = storage()?.getItem(key);
-    list = json ? parse(json) : Object.freeze([]), ready = !0;
+    list = json ? parse(json) : Object.freeze([...seed?.() ?? []]), ready = !0;
   }
   function persist(next) {
     if (!enabled())
@@ -597,26 +597,46 @@ function defineControls(id, input, options = {}) {
   let schema = Object.freeze({ ...input }), locked = normalize(schema, {}), actions = Object.freeze([...options.actions ?? []]), { theme, appearance } = options, density = options.density ?? "default", renderer = options.renderer ?? "auto", enabled = () => typeof options.enabled === "function" ? options.enabled() : options.enabled ?? (Boolean(options.ship) || isUnlocked() || typeof location < "u" && ["localhost", "127.0.0.1", "[::1]"].includes(location.hostname)), storage = () => options.storage === void 0 ? browserStorage() : options.storage, persistMode = options.persist ?? "all", valueStorage = () => persistMode === "all" ? storage() : null, variantStorage = () => persistMode === "none" ? null : storage(), draw = options.random ?? Math.random, hostHistory = options.history, unsubscribeHistory, unsubscribeUnlock, listeners = /* @__PURE__ */ new Set, refreshes = 0, notify = () => {
     for (let cb of [...listeners])
       cb();
-  }, mixed = /* @__PURE__ */ new Set, current = locked, read = !1, error = null, locks = /* @__PURE__ */ new Set, bindings = /* @__PURE__ */ new Map, comparing = null, landing = !1, echo = Math.max(0, options.echo ?? 0), grabbed = /* @__PURE__ */ new Set, changedAt = /* @__PURE__ */ new Map, sent = /* @__PURE__ */ new Map, pending = /* @__PURE__ */ new Map, echoTimer, now = () => typeof performance < "u" ? performance.now() : Date.now(), isHeld = (key) => grabbed.has(key) || echo > 0 && now() - (changedAt.get(key) ?? -1 / 0) < echo, NO_BASE = Object.freeze({ preset: null, groups: Object.freeze({}) }), base = NO_BASE, past = [], future = [], HISTORY = 100, stateKey = storageKey(id, "state"), pinnedOf, pinned = () => {
+  }, mixed = /* @__PURE__ */ new Set, current = locked, read = !1, error = null, locks = /* @__PURE__ */ new Set, bindings = /* @__PURE__ */ new Map, comparing = null, landing = !1, echo = Math.max(0, options.echo ?? 0), grabbed = /* @__PURE__ */ new Set, changedAt = /* @__PURE__ */ new Map, sent = /* @__PURE__ */ new Map, pending = /* @__PURE__ */ new Map, echoTimer, now = () => typeof performance < "u" ? performance.now() : Date.now(), isHeld = (key) => grabbed.has(key) || echo > 0 && now() - (changedAt.get(key) ?? -1 / 0) < echo, NO_BASE = Object.freeze({
+    preset: null,
+    groups: Object.freeze({}),
+    scopes: Object.freeze({})
+  }), base = NO_BASE, past = [], future = [], HISTORY = 100, stateKey = storageKey(id, "state"), pinnedOf, pinned = () => {
     if (pinnedOf?.schema !== schema)
       pinnedOf = { schema, keys: pinnedKeys(schema, options.pinned) };
     return pinnedOf.keys;
-  }, variantsChoice = () => variantsOf(schema, (key) => pinned().has(key)), unpinned = (values) => {
-    let keys = pinned();
-    if (keys.size === 0)
-      return values;
-    let out = { ...values };
-    for (let k of keys)
-      if (Object.hasOwn(locked, k))
-        out[k] = locked[k];
-    return Object.freeze(out);
-  }, presetPatch = (values) => {
-    let keys = pinned();
-    if (keys.size === 0)
-      return values;
-    return Object.fromEntries(Object.entries(values).filter(([k]) => !keys.has(k)));
-  }, buildPresets = () => {
-    let own = options.presets ?? {}, v = variantsChoice();
+  }, variantsChoice = () => variantsOf(schema, (key) => pinned().has(key)), scopingOf, scoping = () => {
+    if (scopingOf?.schema === schema)
+      return scopingOf;
+    let fields = schema, groupTab = /* @__PURE__ */ new Map;
+    for (let f of Object.values(fields))
+      if (f.group !== void 0 && f.tab !== void 0 && !groupTab.has(f.group))
+        groupTab.set(f.group, f.tab);
+    let tabOf = (f) => f.tab ?? (f.group !== void 0 ? groupTab.get(f.group) : void 0), named = new Set(Object.keys(options.scopedPresets ?? {}));
+    if (named.has(""))
+      throw Error("A scope needs a nonempty tab or group id.");
+    let v = variantsChoice(), group = v?.field.group, variants = v ? tabOf(v.field) ?? (group !== void 0 && named.has(group) ? group : "") : void 0;
+    if (variants)
+      named.add(variants);
+    let of = /* @__PURE__ */ new Map;
+    for (let k of valueKeys(schema)) {
+      if (pinned().has(k))
+        continue;
+      let f = fields[k], 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;
+  }, within = (values, scope) => {
+    let of = scoping().of, out;
+    for (let k of Object.keys(locked))
+      if (of.get(k) !== scope && !same(values[k], locked[k]))
+        out ??= { ...values }, out[k] = locked[k];
+    return out ? Object.freeze(out) : values;
+  }, unpinned = (values) => within(values, ""), patchIn = (values, scope) => {
+    let of = scoping().of;
+    return Object.fromEntries(Object.entries(values).filter(([k]) => of.get(k) === scope));
+  }, buildPresets = (scope) => {
+    let own = (scope === "" ? options.presets : options.scopedPresets?.[scope]) ?? {}, v = scoping().variants === scope ? variantsChoice() : void 0;
     if (v && Object.hasOwn(own, v.field.value))
       throw Error(`The default variant (${v.field.value}) is the schema's defaults; set its values there.`);
     let ids = [
@@ -629,10 +649,17 @@ function defineControls(id, input, options = {}) {
         if (id === "default" || id === "custom")
           throw Error(`Reserved preset id: ${id}`);
         let variant = v?.field.options.includes(id) ? { [v.key]: id } : {};
-        return [id, unpinned(normalize(schema, { ...locked, ...variant, ...own[id] }))];
+        return [id, within(normalize(schema, { ...locked, ...variant, ...own[id] }), scope)];
       })
     ]));
-  }, presets = buildPresets(), buildGroupPresets = () => Object.freeze(Object.fromEntries(Object.entries(options.groupPresets ?? {}).map(([group, list]) => {
+  }, buildScopePresets = () => new Map(scoping().named.map((scope) => [scope, buildPresets(scope)])), presets = buildPresets(""), scopePresets = buildScopePresets(), presetsIn = (scope) => {
+    if (scope === "")
+      return presets;
+    let found = scopePresets.get(scope);
+    if (!found)
+      throw Error(`Unknown preset scope: ${scope}`);
+    return found;
+  }, buildGroupPresets = () => Object.freeze(Object.fromEntries(Object.entries(options.groupPresets ?? {}).map(([group, list]) => {
     let named = list.flatMap((p) => Object.keys(p.values).filter((k) => Object.hasOwn(schema, k))), covered = new Set((named.length ? named : Object.keys(schema).filter((k) => schema[k].group === group)).filter((k) => hasValue2(schema[k])));
     return [
       group,
@@ -697,22 +724,54 @@ function defineControls(id, input, options = {}) {
   function commit(next) {
     current = next, persist(), notify();
   }
-  let makeBase = (preset, groups) => preset === null && Object.keys(groups).length === 0 ? NO_BASE : Object.freeze({ preset, groups: Object.freeze({ ...groups }) }), sameBase = (a, b) => a === b || a.preset?.kind === b.preset?.kind && a.preset?.id === b.preset?.id && Object.keys(a.groups).length === Object.keys(b.groups).length && Object.entries(a.groups).every(([g, i]) => b.groups[g] === i);
+  let makeBase = (preset, groups, scopes = {}) => preset === null && Object.keys(groups).length === 0 && Object.keys(scopes).length === 0 ? NO_BASE : Object.freeze({
+    preset,
+    groups: Object.freeze({ ...groups }),
+    scopes: Object.freeze({ ...scopes })
+  }), withScope = (scopes, scope, ref) => {
+    let { [scope]: _, ...others } = scopes;
+    return ref ? { ...others, [scope]: ref } : others;
+  }, sameRef = (a, b) => a?.kind === b?.kind && a?.id === b?.id, sameBase = (a, b) => a === b || sameRef(a.preset, b.preset) && Object.keys(a.groups).length === Object.keys(b.groups).length && Object.entries(a.groups).every(([g, i]) => b.groups[g] === i) && Object.keys(a.scopes).length === Object.keys(b.scopes).length && Object.entries(a.scopes).every(([s, ref]) => sameRef(ref, b.scopes[s])), seedsScopes = () => scopePresets.size > 0 && Object.keys(options.presets ?? {}).length === 0, groupsOutside = (groups, scope) => {
+    let of = scoping().of;
+    return Object.fromEntries(Object.entries(groups).filter(([g]) => !(groupPresets[g] ?? []).some((p) => Object.keys(p.values).some((k) => of.get(k) === scope))));
+  }, known = (ref, scope) => ref.kind === "variant" || ref.id !== "default" && Object.hasOwn(scopePresets.get(scope) ?? {}, ref.id);
   function validBase(b) {
-    let preset = b.preset?.kind === "preset" && !(b.preset.id !== "default" && Object.hasOwn(presets, b.preset.id)) ? null : b.preset, groups = Object.fromEntries(Object.entries(b.groups).filter(([g, i]) => groupPresets[g]?.[i] !== void 0)), next = makeBase(preset, groups);
+    let preset = b.preset?.kind === "preset" && !(b.preset.id !== "default" && Object.hasOwn(presets, b.preset.id)) ? null : b.preset, groups = Object.fromEntries(Object.entries(b.groups).filter(([g, i]) => groupPresets[g]?.[i] !== void 0)), scopes = Object.fromEntries(Object.entries(b.scopes).filter(([s, ref]) => scopePresets.has(s) && known(ref, s))), next = makeBase(preset, groups, scopes);
     return sameBase(next, b) ? b : next;
   }
+  let readRef = (raw) => raw && typeof raw === "object" && (raw.kind === "preset" || raw.kind === "variant") && typeof raw.id === "string" ? Object.freeze({ kind: raw.kind, id: raw.id }) : null;
   function readBase(raw) {
     if (!raw || typeof raw !== "object")
       return NO_BASE;
-    let { preset, groups } = raw, ref = preset && typeof preset === "object" && (preset.kind === "preset" || preset.kind === "variant") && typeof preset.id === "string" ? Object.freeze({ kind: preset.kind, id: preset.id }) : null, byGroup = groups && typeof groups === "object" ? Object.fromEntries(Object.entries(groups).filter((e) => Number.isInteger(e[1]))) : {};
-    return validBase(makeBase(ref, byGroup));
+    let { preset, groups, scopes } = raw, ref = readRef(preset), byGroup = groups && typeof groups === "object" ? Object.fromEntries(Object.entries(groups).filter((e) => Number.isInteger(e[1]))) : {}, byScope = {};
+    if (scopes && typeof scopes === "object")
+      for (let [s, r] of Object.entries(scopes)) {
+        let found = readRef(r);
+        if (found)
+          byScope[s] = found;
+      }
+    if (ref?.kind === "preset" && !Object.hasOwn(presets, ref.id)) {
+      for (let [s, list] of scopePresets)
+        if (!byScope[s] && ref.id !== "default" && Object.hasOwn(list, ref.id))
+          byScope[s] = ref;
+      ref = null;
+    } else if (ref?.kind === "variant" && seedsScopes()) {
+      let id = ref.id;
+      for (let s of scopePresets.keys())
+        if (!byScope[s] && scopeVariants(s).list().some((v) => v.id === id))
+          byScope[s] = ref;
+      ref = null;
+    }
+    return validBase(makeBase(ref, byGroup, byScope));
   }
   function activeBase() {
     load();
-    let ref = base.preset;
-    if (ref?.kind === "variant" && !variants.list().some((v) => v.id === ref.id))
-      base = makeBase(null, base.groups);
+    let gone = (ref, list) => ref?.kind === "variant" && !list().some((v) => v.id === ref.id), preset = gone(base.preset, () => variants.list()) ? null : base.preset, scopes = base.scopes;
+    for (let [s, ref] of Object.entries(base.scopes))
+      if (gone(ref, () => scopeVariants(s).list()))
+        scopes = withScope(scopes, s, void 0);
+    if (preset !== base.preset || scopes !== base.scopes)
+      base = makeBase(preset, base.groups, scopes);
     return base;
   }
   let hasBase = () => activeBase() !== NO_BASE, baseCache;
@@ -722,17 +781,23 @@ function defineControls(id, input, options = {}) {
     let b = activeBase();
     if (b === NO_BASE)
       return locked;
-    let list = b.preset?.kind === "variant" ? variants.list() : null, c = baseCache;
-    if (c && c.base === b && c.schema === schema && c.presets === presets && c.groupPresets === groupPresets && c.variants === list)
+    let lists = [
+      b.preset?.kind === "variant" ? variants.list() : null,
+      ...Object.entries(b.scopes).map(([s, ref]) => ref.kind === "variant" ? scopeVariants(s).list() : null)
+    ], c = baseCache;
+    if (c && c.base === b && c.schema === schema && c.presets === presets && c.scopePresets === scopePresets && c.groupPresets === groupPresets && c.variants.length === lists.length && c.variants.every((l, i) => l === lists[i]))
       return c.values;
-    let out = locked, ref = b.preset;
-    if (ref?.kind === "preset" && Object.hasOwn(presets, ref.id))
-      out = presets[ref.id];
-    else if (ref?.kind === "variant") {
+    let valuesOf = (ref, scope, list) => {
+      if (ref.kind === "preset")
+        return presetsIn(scope)[ref.id];
       let found = list?.find((v) => v.id === ref.id);
-      if (found)
-        out = unpinned(normalize(schema, found.values));
-    }
+      return found ? within(normalize(schema, found.values), scope) : void 0;
+    }, out = locked;
+    if (b.preset)
+      out = valuesOf(b.preset, "", lists[0]) ?? locked;
+    let scoped = Object.entries(b.scopes);
+    if (scoped.length)
+      out = { ...out }, scoped.forEach(([s, ref], i) => Object.assign(out, patchIn(valuesOf(ref, s, lists[i + 1]) ?? locked, s)));
     let groups = Object.entries(b.groups);
     if (groups.length) {
       out = { ...out };
@@ -740,13 +805,16 @@ function defineControls(id, input, options = {}) {
         Object.assign(out, groupPresets[g]?.[i]?.values);
     }
     let values = Object.freeze(out);
-    return baseCache = { base: b, schema, presets, groupPresets, variants: list, values }, values;
+    return baseCache = { base: b, schema, presets, scopePresets, groupPresets, variants: lists, values }, values;
   }
   let covered = (key) => {
     let b = activeBase(), group = schema[key]?.group;
     if (group !== void 0 && Object.hasOwn(b.groups, group))
       return !0;
-    return b.preset !== null && !pinned().has(key);
+    let scope = scoping().of.get(key);
+    if (scope === void 0)
+      return !1;
+    return scope === "" ? b.preset !== null : Object.hasOwn(b.scopes, scope);
   };
   function declaredShortcut(id) {
     let slash = id.indexOf("/"), key = slash < 0 ? id : id.slice(0, slash), field = Object.hasOwn(schema, key) ? schema[key] : void 0;
@@ -981,7 +1049,7 @@ function defineControls(id, input, options = {}) {
       schema = Object.freeze({ ...next });
     if (changed) {
       let previous = load();
-      schema = Object.freeze({ ...next }), locked = normalize(schema, {}), presets = buildPresets(), groupPresets = buildGroupPresets(), base = validBase(base);
+      schema = Object.freeze({ ...next }), locked = normalize(schema, {}), presets = buildPresets(""), scopePresets = buildScopePresets(), groupPresets = buildGroupPresets(), base = validBase(base);
       for (let k of [...locks])
         if (!valueField(k))
           locks.delete(k);
@@ -1016,7 +1084,33 @@ function defineControls(id, input, options = {}) {
     listen(cb) {
       return readoutListeners.add(cb), () => readoutListeners.delete(cb);
     }
-  }, variants = createVariants(() => schema, id, storageKey(id, "variants"), variantStorage, () => unpinned(get()), (v, variant, coalesce) => write(presetPatch(v), { source: "variant", coalesce }, makeBase(Object.freeze({ kind: "variant", id: variant }), {})), notify, enabled), resettable = (keys) => (keys ?? fieldKeys()).filter((k) => valueField(k) && !blocked(k));
+  }, variants = createVariants(() => schema, id, storageKey(id, "variants"), variantStorage, () => unpinned(get()), (v, variant, coalesce) => write(patchIn(v, ""), { source: "variant", coalesce }, makeBase(Object.freeze({ kind: "variant", id: variant }), {}, activeBase().scopes)), notify, enabled), scopeVariantsMade = /* @__PURE__ */ new Map;
+  function scopeVariants(scope) {
+    let made = scopeVariantsMade.get(scope);
+    if (made)
+      return made;
+    return made = createVariants(() => schema, id, storageKey(id, `variants:${scope}`), variantStorage, () => within(get(), scope), (v, variant, coalesce) => {
+      let b = activeBase();
+      write(patchIn(v, scope), { source: "variant", coalesce }, makeBase(b.preset, groupsOutside(b.groups, scope), withScope(b.scopes, scope, Object.freeze({ kind: "variant", id: variant }))));
+    }, notify, enabled, () => !seedsScopes() ? [] : variants.list().flatMap((v) => {
+      let values = within(normalize(schema, v.values), scope);
+      return equal(values, locked) ? [] : [{ ...v, values }];
+    })), scopeVariantsMade.set(scope, made), made;
+  }
+  let scopesOf, scopes = () => {
+    if (scopesOf?.presets === scopePresets)
+      return scopesOf.value;
+    let of = scoping().of, value = Object.freeze(Object.fromEntries([...scopePresets].map(([scope, list]) => [
+      scope,
+      Object.freeze({
+        id: scope,
+        keys: Object.freeze([...of].flatMap(([k, s]) => s === scope ? [k] : [])),
+        presets: list,
+        variants: scopeVariants(scope)
+      })
+    ])));
+    return scopesOf = { presets: scopePresets, value }, value;
+  }, resettable = (keys) => (keys ?? fieldKeys()).filter((k) => valueField(k) && !blocked(k));
   function offBase(keys) {
     if (!hasBase())
       return !1;
@@ -1080,6 +1174,10 @@ function defineControls(id, input, options = {}) {
     get presets() {
       return presets;
     },
+    get scopes() {
+      return scopes();
+    },
+    scopeOf: (key) => scoping().of.get(key),
     actions,
     theme,
     appearance,
@@ -1100,8 +1198,8 @@ function defineControls(id, input, options = {}) {
     sectionDescription: (section) => options.sectionDescriptions?.[section] ?? fieldLabels().sectionText.get(section),
     groupFolded: options.groupFolded,
     sectionFolded: options.sectionFolded,
-    presetLabel: (presetId) => {
-      let v = variantsChoice(), option = presetId === "default" ? v?.field.value : presetId;
+    presetLabel: (presetId, scope = "") => {
+      let v = scoping().variants === scope ? variantsChoice() : void 0, option = presetId === "default" ? v?.field.value : presetId;
       return options.presetLabels?.[presetId] ?? (presetId === "default" ? options.defaultLabel : void 0) ?? (v && option !== void 0 && v.field.options.includes(option) ? v.field.labels?.[option] ?? option : presetId);
     },
     isPinned: (key) => pinned().has(key),
@@ -1232,7 +1330,7 @@ function defineControls(id, input, options = {}) {
           options.onPreset?.({ group, index, name: preset.name });
         return;
       }
-      let { [group]: _, ...others } = b.groups, forget = index === void 0 ? void 0 : makeBase(b.preset, others);
+      let { [group]: _, ...others } = b.groups, forget = index === void 0 ? void 0 : makeBase(b.preset, others, b.scopes);
       if (open.length < keys.length)
         return toDefaults(open, forget);
       let patch = {};
@@ -1377,13 +1475,15 @@ function defineControls(id, input, options = {}) {
       comparing = before, options.onChange?.(changes(now, before), before, { source: "compare" }), notify();
     },
     preset(id, presetOptions) {
-      if (!Object.hasOwn(presets, id))
+      let scope = presetOptions?.scope ?? "", list = presetsIn(scope);
+      if (!Object.hasOwn(list, id))
         throw Error(`Unknown preset: ${id}`);
-      write(presetPatch(presets[id]), { source: "preset", coalesce: presetOptions?.coalesce }, id === "default" ? NO_BASE : makeBase(Object.freeze({ kind: "preset", id }), {}));
+      let b = activeBase(), ref = id === "default" ? void 0 : Object.freeze({ kind: "preset", id });
+      write(patchIn(list[id], scope), { source: "preset", coalesce: presetOptions?.coalesce }, scope === "" ? makeBase(ref ?? null, {}, b.scopes) : makeBase(b.preset, groupsOutside(b.groups, scope), withScope(b.scopes, scope, ref)));
     },
-    matchingPreset: () => {
-      let cur = unpinned(get());
-      return Object.keys(presets).find((id) => equal(cur, presets[id])) ?? "custom";
+    matchingPreset: (scope = "") => {
+      let list = presetsIn(scope), cur = within(get(), scope);
+      return Object.keys(list).find((id) => equal(cur, list[id])) ?? "custom";
     },
     get groupPresets() {
       return groupPresets;
@@ -1395,12 +1495,13 @@ function defineControls(id, input, options = {}) {
       if (!enabled())
         return;
       let b = activeBase();
-      write(preset.values, { source: "preset", group, coalesce: presetOptions?.coalesce }, makeBase(b.preset, { ...b.groups, [group]: index })), options.onPreset?.({ group, index, name: preset.name });
+      write(preset.values, { source: "preset", group, coalesce: presetOptions?.coalesce }, makeBase(b.preset, { ...b.groups, [group]: index }, b.scopes)), options.onPreset?.({ group, index, name: preset.name });
     },
-    activePreset() {
+    activePreset(scope) {
       if (!enabled())
         return null;
-      return activeBase().preset;
+      let b = activeBase();
+      return scope ? b.scopes[scope] ?? null : b.preset;
     },
     activeGroupPreset(group) {
       if (!enabled())
@@ -1415,11 +1516,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-ab7vfghg.js").then((m) => m.attach);
+      let load = options.ship ? () => options.ship().then((m) => m.attach) : () => import("./chunk-44r02asc.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-9qtvxa6k.js").then((m) => m.mountPanel);
+      let load = options.ship ? () => options.ship().then((m) => m.mountPanel) : () => import("./chunk-mbhy4jg5.js").then((m) => m.mountPanel);
       return live(load, (mountPanel) => {
         let panel = mountPanel(controls, container, mountOptions);
         return mountOptions?.onReady?.(panel), panel;
@@ -1718,6 +1819,7 @@ function createRemoteControls(id, descriptors, options = {}) {
     tunable: options.tunable,
     history: options.history,
     presets: options.presets,
+    scopedPresets: options.scopedPresets,
     pinned: options.pinned,
     groupPresets: options.groupPresets,
     onPreset: options.onPreset,