partforge 0.47.0 → 0.47.1

package/src/framework/panel/widgets/checkbox.js

@@ -0,0 +1,37 @@
+// A bare on/off checkbox, writing `on` when ticked and 0 when cleared.
+//
+// `preserveOn` is the one behavioral difference between the two legacy shapes it
+// replaces. A `features` checkbox only wrote `on` when the value wasn't already
+// positive (controls.js:352), so re-ticking a feature restored the magnitude the
+// user had dialled in. A `toggles` checkbox always wrote it (controls.js:286),
+// because its `on` is a flag, not a magnitude.
+import { attachInfo } from "../info.js";
+
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+
+export function makeCheckbox(node, params, { onChange, info }) {
+  const row = el("label", "feat");
+  const box = document.createElement("input");
+  box.type = "checkbox";
+  box.checked = params[node.key] > 0;
+  const lbl = el("span", "", node.label);
+  attachInfo(lbl, node.description, info);
+  row.append(box, lbl);
+
+  box.addEventListener("change", () => {
+    if (box.checked) {
+      if (!node.preserveOn || !(params[node.key] > 0)) params[node.key] = node.on ?? 1;
+    } else {
+      params[node.key] = 0;
+    }
+    onChange?.();
+  });
+
+  const sync = () => { box.checked = params[node.key] > 0; };
+  return { el: row, sync };
+}

package/src/framework/panel/widgets/index.js

@@ -0,0 +1,13 @@
+// The DOM half of the widget registry. Its keys must match widget-specs.js
+// exactly — test/framework/panel/registry.test.js proves they do.
+import { makeNumeric } from "./numeric.js";
+import { makeText } from "./text.js";
+import { makeCheckbox } from "./checkbox.js";
+
+export const WIDGET_FACTORIES = {
+  slider: makeNumeric,
+  number: makeNumeric,
+  text: makeText,
+  textarea: makeText,
+  checkbox: makeCheckbox,
+};

package/src/framework/panel/widgets/numeric.js

@@ -0,0 +1,77 @@
+// slider + number: a range input (omitted for `number`) beside an editable value
+// box. The box accepts exact values finer than `step`; typed values clamp to
+// [min, max] on commit (blur/Enter).
+import { attachInfo } from "../info.js";
+
+// Short numeric string without float noise (4 dp max) for the value box.
+const numStr = (v) => String(Math.round(v * 1e4) / 1e4);
+
+export function clampToRange(raw, min, max) {
+  const v = parseFloat(raw);
+  if (!Number.isFinite(v)) return null;
+  return Math.min(max, Math.max(min, v));
+}
+
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+
+export function makeNumeric(node, params, { onChange, info }) {
+  const numeric = node.type === "number";
+  const wrap = el("div", "slider");
+  const row = el("div", "row");
+  const label = el("label", "", node.label);
+  attachInfo(label, node.description, info);
+  row.append(label);
+
+  const val = el("div", "val");
+  const box = document.createElement("input");
+  box.type = "number";
+  box.className = "num";
+  box.min = node.min; box.max = node.max; box.step = node.step;
+  box.value = numStr(params[node.key]);
+  val.append(box);
+  if (node.unit) val.append(el("span", "unit", node.unit));
+  row.append(val);
+  wrap.append(row);
+
+  let slider = null;
+  if (!numeric) {
+    slider = document.createElement("input");
+    slider.type = "range";
+    slider.min = node.min; slider.max = node.max; slider.step = node.step;
+    slider.value = params[node.key];
+    slider.addEventListener("input", () => {
+      params[node.key] = +slider.value;
+      box.value = numStr(+slider.value);
+      onChange?.();
+    });
+    wrap.append(slider);
+  }
+
+  // live preview while typing (unclamped); clamp + reformat on commit
+  box.addEventListener("input", () => {
+    const v = parseFloat(box.value);
+    if (!Number.isFinite(v)) return;
+    params[node.key] = v;
+    if (slider) slider.value = v;
+    onChange?.();
+  });
+  box.addEventListener("change", () => {
+    const v = clampToRange(box.value, node.min, node.max);
+    if (v == null) { box.value = numStr(params[node.key]); return; } // revert invalid input
+    params[node.key] = v;
+    box.value = numStr(v);
+    if (slider) slider.value = v;
+    onChange?.();
+  });
+
+  const sync = () => {
+    box.value = numStr(params[node.key]);
+    if (slider) slider.value = params[node.key];
+  };
+  return { el: wrap, sync };
+}

package/src/framework/panel/widgets/text.js

@@ -0,0 +1,33 @@
+// text / textarea: a live-updating string field. Every edit writes params
+// immediately so the existing rebuild loop previews the new string.
+import { attachInfo } from "../info.js";
+
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+
+export function makeText(node, params, { onChange, info }) {
+  const multiline = node.type === "textarea";
+  const wrap = el("div", "slider");
+  const row = el("div", "row");
+  const label = el("label", "", node.label);
+  attachInfo(label, node.description, info);
+  row.append(label);
+  wrap.append(row);
+
+  const field = document.createElement(multiline ? "textarea" : "input");
+  if (!multiline) field.type = "text";
+  field.className = "text-input";
+  field.value = String(params[node.key] ?? "");
+  field.addEventListener("input", () => {
+    params[node.key] = field.value;
+    onChange?.();
+  });
+  wrap.append(field);
+
+  const sync = () => { field.value = String(params[node.key] ?? ""); };
+  return { el: wrap, sync };
+}

package/types/part.d.ts

@@ -57,10 +57,25 @@ export interface PartMeta {
 /** Which input a control renders as. Omit for a slider + number box. */
 export type ControlKind = "slider" | "number" | "text" | "textarea";
 
+/** Every control type the panel can render. */
+export type ControlType = "slider" | "number" | "text" | "textarea" | "checkbox";
+
+/** A declarative visibility condition, evaluated against raw parameters. */
+export type WhenCondition =
+  | { allOf: WhenCondition[] }
+  | { anyOf: WhenCondition[] }
+  | { not: WhenCondition }
+  | Record<string, ParamValue | {
+      gt?: number; gte?: number; lt?: number; lte?: number;
+      ne?: ParamValue; in?: ParamValue[];
+    }>;
+
 /**
  * One parameter control. The recognised field list mirrors
  * `CONTROL_FIELDS` in src/framework/lint/rules-schema.js — anything else is
  * ignored by the panel and warned about by `partforge lint`.
+ *
+ * @deprecated Prefer a `controls` array of control nodes. Still fully supported.
  */
 export interface ControlDef {
   /** Must exist in `defaults`, or the control is silently dead. */
@@ -82,6 +97,8 @@ export interface ControlDef {
  * A feature: a checkbox that sets `key` to `on` (or `0`) and reveals its own
  * controls. `sliders` is REQUIRED — the panel reads `feat.sliders.filter(...)`
  * unguarded. A bare on/off control belongs in `toggles` instead.
+ *
+ * @deprecated Prefer a `controls` array of control nodes. Still fully supported.
  */
 export interface FeatureDef {
   key: string;
@@ -96,6 +113,8 @@ export interface FeatureDef {
 /**
  * A standalone on/off checkbox shown below the preset picker, outside the
  * Advanced fold. Checked writes `on` (default `1`); unchecked writes `0`.
+ *
+ * @deprecated Prefer a `controls` array of control nodes. Still fully supported.
  */
 export interface ToggleDef {
   key: string;