@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/src/app/acceptance/control-acceptance-coverage.ts

@@ -1,7 +1,7 @@
 import {
   getToolcraftControlKeyframeCapability,
   type ResolvedToolcraftAppSchema,
-  type ToolcraftControlSchema,
+  type ResolvedToolcraftControlSchema,
   type ToolcraftTimelineMode,
 } from "@repo/toolcraft-runtime";
 
@@ -21,7 +21,6 @@ import {
 import type {
   ToolcraftBackgroundOutputCoverage,
   ToolcraftComponentAcceptance,
-  ToolcraftConditionalVisibilityCoverage,
   ToolcraftOrientationGizmoCoverage,
   ToolcraftProductReadiness,
 } from "./types";
@@ -53,7 +52,7 @@ function getControlAcceptanceEntryErrors({
   entry,
   label,
 }: {
-  control: ToolcraftControlSchema;
+  control: ResolvedToolcraftControlSchema;
   entry: ToolcraftComponentAcceptance;
   label: string;
 }): string[] {
@@ -98,7 +97,7 @@ function getControlLifecycleAndCustomErrors({
   schema,
 }: {
   acceptance: readonly ToolcraftComponentAcceptance[];
-  control: ToolcraftControlSchema;
+  control: ResolvedToolcraftControlSchema;
   entry: ToolcraftComponentAcceptance;
   label: string;
   layersEnabled: boolean;
@@ -155,7 +154,7 @@ function getControlEvidenceErrors({
   schema,
   sectionTitle,
 }: {
-  control: ToolcraftControlSchema;
+  control: ResolvedToolcraftControlSchema;
   controlId: string;
   entry: ToolcraftComponentAcceptance;
   label: string;
@@ -177,19 +176,6 @@ function getControlEvidenceErrors({
     );
   }
 
-  if (
-    control.visibleWhen &&
-    !hasTypedCoverage<ToolcraftConditionalVisibilityCoverage>(
-      entry.visibilityCoverage,
-      "all-conditional-visibility",
-      ["hidden", "visible"],
-    )
-  ) {
-    errors.push(
-      `${label} uses visibleWhen and must declare visibilityCoverage for both "hidden" and "visible" states reached through ${control.visibleWhen.target}.`,
-    );
-  }
-
   if (
     schemaHasPngExportPanelAction(schema) &&
     isOutputBackgroundToggleControl({ control, controlId, sectionTitle })
@@ -228,7 +214,7 @@ function getControlPartAndRuntimeCoverageErrors({
   layersEnabled,
   timelineMode,
 }: {
-  control: ToolcraftControlSchema;
+  control: ResolvedToolcraftControlSchema;
   entry: ToolcraftComponentAcceptance;
   label: string;
   layersEnabled: boolean;
@@ -236,7 +222,6 @@ function getControlPartAndRuntimeCoverageErrors({
 }): string[] {
   const errors: string[] = [];
   const keyframeCapability = getToolcraftControlKeyframeCapability(control);
-  const isSelectedLayerTarget = control.target.startsWith("selectedLayer.");
   const requiredControlParts = getRequiredToolcraftControlPartCoverage(control);
 
   if (
@@ -255,16 +240,6 @@ function getControlPartAndRuntimeCoverageErrors({
     }
   }
 
-  if (
-    isSelectedLayerTarget &&
-    layersEnabled &&
-    entry.layerCoverage !== "selected-layer-controls"
-  ) {
-    errors.push(
-      `${label} targets selectedLayer.* and must have acceptance layerCoverage "selected-layer-controls" proving the control edits the currently selected layer output.`,
-    );
-  }
-
   return errors;
 }
 
@@ -281,7 +256,7 @@ export function getControlAcceptanceCoverageErrors({
   timelineMode,
 }: {
   acceptance: readonly ToolcraftComponentAcceptance[];
-  control: ToolcraftControlSchema;
+  control: ResolvedToolcraftControlSchema;
   controlId: string;
   entry: ToolcraftComponentAcceptance;
   label: string;

package/templates/starter/src/app/acceptance/control-acceptance-kind-rules.ts

@@ -1,5 +1,8 @@
 import { getToolcraftSegmentedStaticFitError } from "@repo/toolcraft-runtime";
-import type { ToolcraftControlSchema } from "@repo/toolcraft-runtime";
+import type {
+  ToolcraftCollectionItemControlSchema,
+  ToolcraftControlSchema,
+} from "@repo/toolcraft-runtime";
 
 import { getActionValue, isResetPanelAction } from "./actions";
 import {
@@ -103,13 +106,29 @@ function getOptionControlAcceptanceErrors({
     }
   }
 
-  if (control.type === "collectionActions" && control.itemControl) {
-    const segmentedLayoutError = getToolcraftSegmentedStaticFitError(
-      control.itemControl,
+  const nestedItemControls: Array<
+    [string, ToolcraftCollectionItemControlSchema]
+  > = [];
+
+  if (control.itemControl) {
+    nestedItemControls.push(["itemControl", control.itemControl]);
+  }
+
+  if (control.itemControls) {
+    nestedItemControls.push(
+      ...Object.entries(control.itemControls).map(
+        ([itemId, itemControl]): [string, ToolcraftCollectionItemControlSchema] =>
+          [`itemControls.${itemId}`, itemControl],
+      ),
     );
+  }
+
+  for (const [itemId, itemControl] of nestedItemControls) {
+    const segmentedLayoutError =
+      getToolcraftSegmentedStaticFitError(itemControl);
 
     if (segmentedLayoutError) {
-      errors.push(`${label} itemControl ${segmentedLayoutError}`);
+      errors.push(`${label} ${itemId} ${segmentedLayoutError}`);
     }
   }
 

package/templates/starter/src/app/acceptance/control-acceptance-policy.ts

@@ -18,13 +18,12 @@ function getControlComponentPolicyErrors({
   control,
   controlId,
   label,
-  sectionTitle,
 }: Pick<
   ToolcraftControlRuleContext,
-  "control" | "controlId" | "label" | "sectionTitle"
+  "control" | "controlId" | "label"
 >): string[] {
   const errors: string[] = [];
-  const toggleLabelError = getToggleControlLabelError(control, sectionTitle);
+  const toggleLabelError = getToggleControlLabelError(control);
   const singleActionsLabelError = getSingleActionsControlLabelError(control);
   const codeTextareaError = getCodeTextareaControlError({
     control,
@@ -140,17 +139,6 @@ function getControlStatePolicyErrors({
 >): string[] {
   const errors: string[] = [];
 
-  if (control.visibleWhen) {
-    errors.push(
-      ...getConditionValidationErrors({
-        condition: control.visibleWhen,
-        conditionName: "visibleWhen",
-        controlTargets,
-        label,
-      }),
-    );
-  }
-
   if (control.disabledWhen) {
     errors.push(
       ...getConditionValidationErrors({
@@ -164,13 +152,13 @@ function getControlStatePolicyErrors({
 
   if (control.disabled === true) {
     errors.push(
-      `${label} sets disabled: true. Generated product panels should show only controls usable in the current state; hide unavailable product controls with visibleWhen instead of rendering disabled controls.`,
+      `${label} sets disabled: true. Generated product panels should show only controls usable in the current state; declare conditional applicability instead of rendering disabled controls.`,
     );
   }
 
   if (control.disabledWhen) {
     errors.push(
-      `${label} uses disabledWhen. Generated product panels should show only controls usable in the current state; hide unavailable product controls with visibleWhen instead of rendering disabled controls.`,
+      `${label} uses disabledWhen. Generated product panels should show only controls usable in the current state; declare conditional applicability instead of rendering disabled controls.`,
     );
   }
 

package/templates/starter/src/app/acceptance/control-applicability-cases.test.ts

@@ -0,0 +1,321 @@
+import { defineToolcraft } from "@repo/toolcraft-runtime";
+import { describe, expect, it } from "vitest";
+
+import {
+  getToolcraftApplicabilityRequirementId,
+  getToolcraftControlApplicabilityCases,
+} from "./control-applicability-cases";
+import type { ToolcraftControlSectionInventoryEntry } from "./types";
+
+const sectionInventory: readonly ToolcraftControlSectionInventoryEntry[] = [
+  {
+    entity: "Shape",
+    entityId: "shape",
+    groupingReason: "Source and shape selectors gate shape parameters.",
+    id: "shape",
+    targets: ["source.mode", "shape.kind", "shape.sides"],
+    title: "Shape",
+  },
+];
+
+function shapeSchema({
+  applicability = {
+    all: [
+      { equals: "create", target: "source.mode" },
+      { oneOf: ["polygon", "star"], target: "shape.kind" },
+    ],
+    mode: "conditional" as const,
+  },
+}: {
+  applicability?: {
+    all: readonly {
+      equals?: unknown;
+      oneOf?: readonly unknown[];
+      target: string;
+    }[];
+    mode: "conditional";
+  } | { mode: "always" };
+} = {}) {
+  return defineToolcraft({
+    canvas: { enabled: true },
+    panels: {
+      controls: {
+        sections: [
+          {
+            controls: {
+              sourceMode: {
+                applicability: { mode: "always" },
+                defaultValue: "create",
+                options: [
+                  { label: "Upload", value: "upload" },
+                  { label: "Create", value: "create" },
+                ],
+                target: "source.mode",
+                type: "segmented",
+              },
+              shapeKind: {
+                applicability: { mode: "always" },
+                defaultValue: "polygon",
+                options: [
+                  { label: "Circle", value: "circle" },
+                  { label: "Polygon", value: "polygon" },
+                  { label: "Star", value: "star" },
+                ],
+                target: "shape.kind",
+                type: "segmented",
+              },
+              sides: {
+                applicability,
+                defaultValue: 6,
+                target: "shape.sides",
+                type: "slider",
+              },
+            },
+            id: "shape",
+            title: "Shape",
+          },
+        ],
+        title: "Controls",
+      },
+    },
+  });
+}
+
+describe("Toolcraft control applicability cases", () => {
+  it("derives deterministic pairwise cases from semantic inventory", () => {
+    const cases = getToolcraftControlApplicabilityCases({
+      schema: shapeSchema(),
+      sectionInventory,
+      target: "shape.sides",
+    });
+
+    expect(cases.map(({ expectation, selectorTarget, selectorValue, target }) => ({
+      expectation,
+      selectorTarget,
+      selectorValue,
+      target,
+    }))).toEqual([
+      {
+        expectation: "hidden",
+        selectorTarget: "source.mode",
+        selectorValue: "upload",
+        target: "shape.sides",
+      },
+      {
+        expectation: "visible",
+        selectorTarget: "source.mode",
+        selectorValue: "create",
+        target: "shape.sides",
+      },
+      {
+        expectation: "hidden",
+        selectorTarget: "shape.kind",
+        selectorValue: "circle",
+        target: "shape.sides",
+      },
+      {
+        expectation: "visible",
+        selectorTarget: "shape.kind",
+        selectorValue: "polygon",
+        target: "shape.sides",
+      },
+      {
+        expectation: "visible",
+        selectorTarget: "shape.kind",
+        selectorValue: "star",
+        target: "shape.sides",
+      },
+    ]);
+    expect(cases[0]).toEqual(
+      expect.objectContaining({
+        selectorControlType: "segmented",
+        selectorLabel: "sourceMode",
+        selectorOptionLabel: "Upload",
+      }),
+    );
+  });
+
+  it("treats omitted finite siblings as visible claims", () => {
+    const cases = getToolcraftControlApplicabilityCases({
+      schema: shapeSchema({
+        applicability: {
+          all: [{ oneOf: ["polygon", "star"], target: "shape.kind" }],
+          mode: "conditional",
+        },
+      }),
+      sectionInventory,
+      target: "shape.sides",
+    });
+
+    expect(cases.slice(0, 2)).toEqual([
+      expect.objectContaining({
+        expectation: "visible",
+        selectorTarget: "source.mode",
+        selectorValue: "upload",
+        target: "shape.sides",
+      }),
+      expect.objectContaining({
+        expectation: "visible",
+        selectorTarget: "source.mode",
+        selectorValue: "create",
+        target: "shape.sides",
+      }),
+    ]);
+  });
+
+  it("uses one path for always controls and stable encoded requirement ids", () => {
+    const cases = getToolcraftControlApplicabilityCases({
+      schema: shapeSchema({ applicability: { mode: "always" } }),
+      sectionInventory,
+      target: "shape.sides",
+    });
+
+    expect(cases.every((entry) => entry.expectation === "visible")).toBe(true);
+    expect(getToolcraftApplicabilityRequirementId("shape-sides", cases[0]!)).toBe(
+      "shape-sides#applicability:source.mode=%22upload%22:visible",
+    );
+  });
+
+  it("derives bounded numeric boundary cases without enumerating a range", () => {
+    const schema = defineToolcraft({
+      canvas: { enabled: true },
+      panels: {
+        controls: {
+          sections: [
+            {
+              controls: {
+                count: {
+                  applicability: { mode: "always" },
+                  defaultValue: 2,
+                  max: 3,
+                  min: 1,
+                  step: 1,
+                  target: "shade.count",
+                  type: "slider",
+                  variant: "discrete",
+                },
+                thirdShade: {
+                  applicability: {
+                    all: [
+                      {
+                        greaterThanOrEqual: 3,
+                        target: "shade.count",
+                      },
+                    ],
+                    mode: "conditional",
+                  },
+                  target: "shade.third",
+                  type: "color",
+                },
+              },
+              id: "shades",
+              title: "Shades",
+            },
+          ],
+          title: "Controls",
+        },
+      },
+    });
+
+    expect(
+      getToolcraftControlApplicabilityCases({
+        schema,
+        sectionInventory: [
+          {
+            entity: "Shades",
+            entityId: "shades",
+            groupingReason: "Count controls the available shade colors.",
+            id: "shades",
+            targets: ["shade.count", "shade.third"],
+            title: "Shades",
+          },
+        ],
+        target: "shade.third",
+      }).map(({ expectation, selectorTarget, selectorValue, target }) => ({
+        expectation,
+        selectorTarget,
+        selectorValue,
+        target,
+      })),
+    ).toEqual([
+      {
+        expectation: "hidden",
+        selectorTarget: "shade.count",
+        selectorValue: 1,
+        target: "shade.third",
+      },
+      {
+        expectation: "hidden",
+        selectorTarget: "shade.count",
+        selectorValue: 2,
+        target: "shade.third",
+      },
+      {
+        expectation: "visible",
+        selectorTarget: "shade.count",
+        selectorValue: 3,
+        target: "shade.third",
+      },
+    ]);
+  });
+
+  it("uses the resolved Setup product subset only as the inventory fallback", () => {
+    const schema = defineToolcraft({
+      canvas: {
+        enabled: true,
+        sizing: { mode: "editable-output" },
+      },
+      panels: {
+        controls: {
+          sections: [
+            {
+              controls: {
+                background: {
+                  applicability: { mode: "always" },
+                  defaultValue: "#101010",
+                  target: "appearance.background",
+                  type: "color",
+                },
+                includeBackground: {
+                  applicability: { mode: "always" },
+                  defaultValue: true,
+                  target: "export.includeBackground",
+                  type: "switch",
+                },
+              },
+              id: "background",
+              title: "Background",
+            },
+          ],
+          title: "Controls",
+        },
+      },
+    });
+
+    expect(
+      getToolcraftControlApplicabilityCases({
+        schema,
+        sectionInventory: [],
+        target: "appearance.background",
+      }).map(({ expectation, selectorTarget, selectorValue, target }) => ({
+        expectation,
+        selectorTarget,
+        selectorValue,
+        target,
+      })),
+    ).toEqual([
+      {
+        expectation: "visible",
+        selectorTarget: "export.includeBackground",
+        selectorValue: false,
+        target: "appearance.background",
+      },
+      {
+        expectation: "visible",
+        selectorTarget: "export.includeBackground",
+        selectorValue: true,
+        target: "appearance.background",
+      },
+    ]);
+  });
+});