@structured-field/widget-editor 1.2.2 → 1.4.0

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@structured-field/widget-editor",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "A lightweight JSON Schema form builder with support for relation fields (ForeignKey, QuerySet) and autocomplete search.",
   "type": "module",
+  "packageManager": "pnpm@10.11.1",
+  "engines": {
+    "node": ">=20"
+  },
   "main": "dist/structured-widget-editor.js",
   "module": "dist/structured-widget-editor.esm.js",
   "repository": {
@@ -27,7 +31,9 @@
   "scripts": {
     "build": "rollup -c && node scripts/bundle-iife.mjs",
     "dev": "rollup -c -w",
-    "test:serve": "vite --open"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "playground": "vite --open"
   },
   "keywords": [
     "json-schema",

package/src/SchemaForm.vue

@@ -13,7 +13,7 @@
 
 <script>
 import SchemaEditor from './editors/SchemaEditor.vue';
-import { deepClone } from './utils';
+import { deepClone, isChoiceOneOf } from './utils';
 import { applyConditionals, hasConditionals } from './conditionals';
 
 export default {
@@ -89,29 +89,36 @@ export default {
         const hasNull = schema.anyOf.some(s => s.type === 'null');
         if (hasNull && nonNull.length === 1) {
           const resolved = this.resolveSchema(nonNull[0]);
-          return {
-            ...resolved,
-            _nullable: true,
-            title: schema.title || resolved.title,
-            default: 'default' in schema ? schema.default : null,
-          };
+          // Carry ALL sibling keys through the nullable collapse: pydantic
+          // emits json_schema_extra (placeholder, minLength/maxLength,
+          // minimum/maximum, format, choice oneOf, ...) as SIBLINGS of
+          // anyOf on Optional fields. Outer keys override the inner branch.
+          const { anyOf, oneOf, ...rest } = schema;
+          const out = { ...resolved, ...rest, _nullable: true };
+          if (!('default' in schema)) out.default = null;
+          if (isChoiceOneOf(oneOf)) out.oneOf = oneOf;
+          return out;
         }
         if (nonNull.length >= 1) return this.resolveSchema(nonNull[0]);
       }
 
       if (schema.oneOf && schema.discriminator) return schema;
 
+      // A oneOf of {const, title} value options is a choice list (select),
+      // not alternative sub-schemas: keep it intact for SelectEditor instead
+      // of collapsing to the first member (which routed to HiddenEditor and
+      // overwrote stored values on mount).
+      if (isChoiceOneOf(schema.oneOf)) return schema;
+
       if (schema.oneOf) {
         const nonNull = schema.oneOf.filter(s => s.type !== 'null');
         const hasNull = schema.oneOf.some(s => s.type === 'null');
         if (hasNull && nonNull.length === 1) {
           const resolved = this.resolveSchema(nonNull[0]);
-          return {
-            ...resolved,
-            _nullable: true,
-            title: schema.title || resolved.title,
-            default: 'default' in schema ? schema.default : null,
-          };
+          const { anyOf, oneOf, ...rest } = schema;
+          const out = { ...resolved, ...rest, _nullable: true };
+          if (!('default' in schema)) out.default = null;
+          return out;
         }
         if (nonNull.length >= 1) return this.resolveSchema(nonNull[0]);
       }

package/src/editors/DateEditor.vue

@@ -0,0 +1,95 @@
+<template>
+  <div class="sf-field" :class="{ errors: fieldErrors.length }">
+    <span class="sf-label" :class="{ required: isRequired }">
+      {{ title }}
+      <span v-if="isNullable && isNullValue" class="sf-null-badge">null</span>
+    </span>
+    <div :class="isNullable ? 'sf-input-row' : null">
+      <input
+        :type="inputType"
+        class="sf-input"
+        :value="displayValue"
+        :placeholder="isNullValue ? 'null' : (schema.placeholder || '')"
+        :min="schema.minimum || schema.formatMinimum || null"
+        :max="schema.maximum || schema.formatMaximum || null"
+        @input="onInput"
+      />
+      <button v-if="isNullable && !isNullValue" type="button" class="sf-null-clear-btn" title="Set to null" @click="$emit('update:modelValue', null)">&#x2715;</button>
+    </div>
+    <ul v-if="fieldErrors.length" class="errorlist">
+      <li v-for="(err, i) in fieldErrors" :key="i">{{ err }}</li>
+    </ul>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'DateEditor',
+  props: {
+    schema: { type: Object, required: true },
+    modelValue: { default: '' },
+    path: { type: Array, default: () => [] },
+    form: { type: Object, default: null },
+  },
+  emits: ['update:modelValue'],
+  computed: {
+    isDateTime() {
+      return this.schema.format === 'date-time';
+    },
+    inputType() {
+      return this.isDateTime ? 'datetime-local' : 'date';
+    },
+    displayValue() {
+      if (this.isNullValue) return '';
+      const v = String(this.modelValue);
+      if (this.isDateTime) {
+        // Accept ISO 8601 strings like "2026-04-09T10:30:00[.sss][Z|+00:00]"
+        // datetime-local expects "YYYY-MM-DDTHH:mm" (or with seconds).
+        const match = v.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})(?::(\d{2}(?:\.\d+)?))?/);
+        if (match) {
+          return match[3] ? `${match[1]}T${match[2]}:${match[3]}` : `${match[1]}T${match[2]}`;
+        }
+        return v;
+      }
+      // date: expect "YYYY-MM-DD"
+      return v.slice(0, 10);
+    },
+    title() {
+      return this.schema.title || this.humanize(this.path[this.path.length - 1]) || '';
+    },
+    isRequired() {
+      if (this.path.length < 2 || !this.form) return false;
+      const parentPath = this.path.slice(0, -1);
+      const fieldName = this.path[this.path.length - 1];
+      const parentSchema = this.form.getSchemaAtPath(parentPath);
+      return parentSchema && Array.isArray(parentSchema.required) && parentSchema.required.includes(fieldName);
+    },
+    isNullable() {
+      return !!this.schema._nullable;
+    },
+    isNullValue() {
+      return this.modelValue === null || this.modelValue === undefined;
+    },
+    fieldErrors() {
+      if (!this.form || !this.form.getErrorsForPath) return [];
+      return this.form.getErrorsForPath(this.path);
+    },
+  },
+  methods: {
+    onInput(e) {
+      const val = e.target.value;
+      if (val === '') {
+        this.$emit('update:modelValue', this.isNullable ? null : '');
+        return;
+      }
+      // Emit ISO-compatible string. Pydantic accepts both "YYYY-MM-DD"
+      // and "YYYY-MM-DDTHH:mm[:ss]" for date / datetime fields.
+      this.$emit('update:modelValue', val);
+    },
+    humanize(str) {
+      if (!str) return '';
+      return str.replace(/_/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2').replace(/^./, s => s.toUpperCase());
+    },
+  },
+};
+</script>

package/src/editors/ObjectEditor.vue

@@ -1,15 +1,18 @@
 <template>
   <div v-if="isRoot" class="sf-object sf-object-root">
     <div class="sf-object-fields">
-      <SchemaEditor
-        v-for="(propSchema, key) in (effectiveSchema.properties || {})"
-        :key="key"
-        :schema="form.resolveSchema(propSchema)"
-        :model-value="(modelValue || {})[key]"
-        :path="[...path, key]"
-        :form="form"
-        @update:model-value="onChildChange(key, $event)"
-      />
+      <template v-for="cell in cells" :key="cell.key">
+        <div v-if="cell.breakBefore" class="sf-flow-break" aria-hidden="true"></div>
+        <div :class="cell.classes">
+          <SchemaEditor
+            :schema="cell.schema"
+            :model-value="(modelValue || {})[cell.key]"
+            :path="[...path, cell.key]"
+            :form="form"
+            @update:model-value="onChildChange(cell.key, $event)"
+          />
+        </div>
+      </template>
     </div>
   </div>
   <fieldset v-else class="sf-object" :class="{ 'sf-object-collapsed': collapsed }">
@@ -21,15 +24,18 @@
       <span v-if="collapsed && summary" class="sf-object-summary">{{ summary }}</span>
     </legend>
     <div v-show="!collapsed" class="sf-object-fields">
-      <SchemaEditor
-        v-for="(propSchema, key) in (effectiveSchema.properties || {})"
-        :key="key"
-        :schema="form.resolveSchema(propSchema)"
-        :model-value="(modelValue || {})[key]"
-        :path="[...path, key]"
-        :form="form"
-        @update:model-value="onChildChange(key, $event)"
-      />
+      <template v-for="cell in cells" :key="cell.key">
+        <div v-if="cell.breakBefore" class="sf-flow-break" aria-hidden="true"></div>
+        <div :class="cell.classes">
+          <SchemaEditor
+            :schema="cell.schema"
+            :model-value="(modelValue || {})[cell.key]"
+            :path="[...path, cell.key]"
+            :form="form"
+            @update:model-value="onChildChange(cell.key, $event)"
+          />
+        </div>
+      </template>
     </div>
   </fieldset>
 </template>
@@ -38,6 +44,7 @@
 import SchemaEditor from './SchemaEditor.vue';
 import SfIcon from './SfIcon.vue';
 import { applyConditionals, hasConditionals } from '../conditionals';
+import { layoutCells } from '../layout';
 
 export default {
   name: 'ObjectEditor',
@@ -46,6 +53,9 @@ export default {
     this.$options.components.SchemaEditor = SchemaEditor;
     this.$options.components.SfIcon = SfIcon;
   },
+  inject: {
+    customEditors: { default: () => () => [] },
+  },
   props: {
     schema: { type: Object, required: true },
     modelValue: { default: () => ({}) },
@@ -56,6 +66,9 @@ export default {
   data() {
     return {
       collapsed: false,
+      // Values pruned when a conditional rule deactivated their field,
+      // kept so toggling the controller back restores what the user typed.
+      prunedStash: {},
     };
   },
   computed: {
@@ -69,6 +82,13 @@ export default {
       if (!hasConditionals(this.schema)) return this.schema;
       return applyConditionals(this.schema, this.modelValue || {}, this.form?.resolveSchema);
     },
+    cells() {
+      return layoutCells(this.effectiveSchema.properties, {
+        resolveSchema: this.form?.resolveSchema,
+        customEditors: this.customEditors(),
+        basePath: this.path,
+      });
+    },
     summary() {
       const val = this.modelValue || {};
       const parts = [];
@@ -103,10 +123,21 @@ export default {
       const allowed = new Set(Object.keys(effective.properties || {}));
       let changed = false;
       const out = {};
+      // restore stashed values for fields a rule just re-activated
+      for (const k of allowed) {
+        if (!(k in value) && k in this.prunedStash) {
+          out[k] = this.prunedStash[k];
+          delete this.prunedStash[k];
+          changed = true;
+        }
+      }
       for (const k of Object.keys(value)) {
         if (allowed.has(k)) {
           out[k] = value[k];
         } else {
+          // pruned from the emitted value (documented behavior), but kept
+          // locally so a controller toggle round-trip is not destructive
+          this.prunedStash[k] = value[k];
           changed = true;
         }
       }

package/src/editors/RelationEditor.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="sf-field sf-relation" :class="{ errors: fieldErrors.length }" ref="root">
+  <div class="sf-field sf-relation" :class="{ errors: fieldErrors.length, 'sf-relation-multiple': isMultiple, 'sf-relation-open': dropdownVisible }" ref="root">
     <span class="sf-label" :class="{ required: isRequired }">{{ title }}</span>
     <div class="sf-relation-wrapper">
       <!-- Selected items -->

package/src/editors/SchemaEditor.vue

@@ -25,6 +25,7 @@
 import StringEditor from './StringEditor.vue';
 import NumberEditor from './NumberEditor.vue';
 import BooleanEditor from './BooleanEditor.vue';
+import DateEditor from './DateEditor.vue';
 import SelectEditor from './SelectEditor.vue';
 import HiddenEditor from './HiddenEditor.vue';
 import ObjectEditor from './ObjectEditor.vue';
@@ -34,8 +35,8 @@ import UnionEditor from './UnionEditor.vue';
 import RelationEditor from './RelationEditor.vue';
 import JsonEditor from './JsonEditor.vue';
 import WebComponentWrapper from './WebComponentWrapper.vue';
-
-const MAX_DEPTH = 12;
+import { isChoiceOneOf } from '../utils';
+import { MAX_DEPTH } from '../layout';
 
 export default {
   name: 'SchemaEditor',
@@ -43,6 +44,7 @@ export default {
     StringEditor,
     NumberEditor,
     BooleanEditor,
+    DateEditor,
     SelectEditor,
     HiddenEditor,
     ObjectEditor,
@@ -92,6 +94,9 @@ export default {
 
       if (schema.type === 'relation') return 'RelationEditor';
       if (schema.oneOf && schema.discriminator) return 'UnionEditor';
+      // Choice-list oneOf ({const, title} options) renders as a select —
+      // must be checked before the 'const' HiddenEditor routing.
+      if (isChoiceOneOf(schema.oneOf)) return 'SelectEditor';
       if ('const' in schema) return 'HiddenEditor';
       if (schema.enum && schema.enum.length === 1 && schema.type === 'string') return 'HiddenEditor';
       if (schema._nullable && (schema.type === 'object' || schema.type === 'array')) return 'NullableEditor';
@@ -101,6 +106,7 @@ export default {
       if (schema.enum) return 'SelectEditor';
       if (schema.type === 'boolean') return 'BooleanEditor';
       if (schema.type === 'number' || schema.type === 'integer') return 'NumberEditor';
+      if (schema.type === 'string' && (schema.format === 'date' || schema.format === 'date-time')) return 'DateEditor';
 
       return 'StringEditor';
     },

package/src/editors/SelectEditor.vue

@@ -7,12 +7,12 @@
     <div :class="isNullable ? 'sf-input-row' : null">
       <select
         class="sf-input sf-select"
-        :value="isNullValue ? '' : (modelValue != null ? String(modelValue) : '')"
-        @change="$emit('update:modelValue', $event.target.value)"
+        :value="selectedIndex === -1 ? '' : String(selectedIndex)"
+        @change="onChange($event.target.value)"
       >
-        <option v-if="isNullable && isNullValue" value="" disabled selected>null</option>
-        <option v-for="opt in (schema.enum || [])" :key="opt" :value="String(opt)">
-          {{ opt }}
+        <option v-if="selectedIndex === -1" value="" disabled selected>{{ isNullValue ? 'null' : '' }}</option>
+        <option v-for="(opt, i) in options" :key="i" :value="String(i)">
+          {{ opt.label }}
         </option>
       </select>
       <button v-if="isNullable && !isNullValue" type="button" class="sf-null-clear-btn" title="Set to null" @click="$emit('update:modelValue', null)">&#x2715;</button>
@@ -24,6 +24,8 @@
 </template>
 
 <script>
+import { isChoiceOneOf } from '../utils';
+
 export default {
   name: 'SelectEditor',
   props: {
@@ -34,6 +36,20 @@ export default {
   },
   emits: ['update:modelValue'],
   computed: {
+    options() {
+      // Two source shapes: a choice-list oneOf ({const, title} pairs, e.g.
+      // metaobjects' select kind — labels preserved) or a plain enum.
+      if (isChoiceOneOf(this.schema.oneOf)) {
+        return this.schema.oneOf.map((o) => ({
+          value: o.const,
+          label: o.title != null ? o.title : String(o.const),
+        }));
+      }
+      return (this.schema.enum || []).map((v) => ({ value: v, label: String(v) }));
+    },
+    selectedIndex() {
+      return this.options.findIndex((o) => o.value === this.modelValue);
+    },
     title() {
       return this.schema.title || this.humanize(this.path[this.path.length - 1]) || '';
     },
@@ -56,6 +72,13 @@ export default {
     },
   },
   methods: {
+    onChange(indexStr) {
+      const opt = this.options[Number(indexStr)];
+      // Emit the ORIGINAL option value (options are addressed by index in
+      // the DOM), so integer/boolean enums keep their native type instead
+      // of being stringified by the <select> element.
+      if (opt !== undefined) this.$emit('update:modelValue', opt.value);
+    },
     humanize(str) {
       if (!str) return '';
       return str.replace(/_/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2').replace(/^./, s => s.toUpperCase());

package/src/index.js

@@ -5,6 +5,7 @@ export { default as SchemaEditor } from './editors/SchemaEditor.vue';
 export { default as StringEditor } from './editors/StringEditor.vue';
 export { default as NumberEditor } from './editors/NumberEditor.vue';
 export { default as BooleanEditor } from './editors/BooleanEditor.vue';
+export { default as DateEditor } from './editors/DateEditor.vue';
 export { default as SelectEditor } from './editors/SelectEditor.vue';
 export { default as HiddenEditor } from './editors/HiddenEditor.vue';
 export { default as ObjectEditor } from './editors/ObjectEditor.vue';
@@ -15,6 +16,7 @@ export { default as RelationEditor } from './editors/RelationEditor.vue';
 export { default as WebComponentWrapper } from './editors/WebComponentWrapper.vue';
 export { BaseEditorElement } from './BaseEditorElement.js';
 export { applyConditionals, matchesSchema, hasConditionals } from './conditionals.js';
+export { fieldSize, layoutCells, normalizeLayoutHint } from './layout.js';
 
 import { defineCustomElement } from 'vue';
 import SchemaFormComponent from './SchemaForm.vue';

package/src/layout.js

@@ -0,0 +1,116 @@
+import { isChoiceOneOf } from './utils';
+
+// Field-size classification for the multicolumn flow layout.
+// Sizes are flex-basis tokens (see scss/components/layout.scss), not column
+// counts: columns emerge from how many cells fit the container's width.
+// Invariant: visual order === DOM order === tab order. Never reorder cells.
+
+const SIZES = ['xs', 'sm', 'md', 'lg', 'full'];
+const BREAKS = ['before', 'after', 'both'];
+
+// Schema-author hint: `layout: 'sm'` or `layout: { size: 'sm', break: 'before' }`.
+// Invalid hints are silently ignored so a typo degrades to the heuristic.
+export function normalizeLayoutHint(layout) {
+  if (typeof layout === 'string') {
+    return { size: SIZES.includes(layout) ? layout : null, break: null };
+  }
+  if (layout && typeof layout === 'object' && !Array.isArray(layout)) {
+    return {
+      size: SIZES.includes(layout.size) ? layout.size : null,
+      break: BREAKS.includes(layout.break) ? layout.break : null,
+    };
+  }
+  return { size: null, break: null };
+}
+
+// Nullable scalars carry the inline null-clear button (~30px of chrome), and
+// datetime-local needs its full width — one tier of slack keeps them usable.
+const NULLABLE_BUMP = { xs: 'sm', sm: 'md' };
+
+function bumpNullable(size, schema) {
+  return schema._nullable ? (NULLABLE_BUMP[size] || size) : size;
+}
+
+function choiceSize(labels, schema) {
+  const compact = labels.length <= 8 && labels.every((l) => String(l ?? '').length <= 12);
+  return bumpNullable(compact ? 'sm' : 'md', schema);
+}
+
+// Shared with SchemaEditor: past this depth everything renders StringEditor.
+export const MAX_DEPTH = 12;
+
+// Intrinsic size of a RESOLVED schema node.
+// Returns 'xs' | 'sm' | 'md' | 'lg' | 'full' | 'hidden'.
+// Hidden routing (const / single-string-enum) is authoritative: a size hint
+// on a field that renders HiddenEditor would only produce an empty cell.
+export function fieldSize(schema) {
+  if (!schema || typeof schema !== 'object') return 'full';
+  const intrinsic = intrinsicSize(schema);
+  if (intrinsic === 'hidden') return 'hidden';
+  return normalizeLayoutHint(schema.layout).size || intrinsic;
+}
+
+// The branch order mirrors SchemaEditor.editorComponent — keep them in sync.
+function intrinsicSize(schema) {
+  if (schema.type === 'relation') return schema.multiple ? 'lg' : 'md';
+  if (schema.oneOf && schema.discriminator) return 'full';
+  if (isChoiceOneOf(schema.oneOf)) {
+    return choiceSize(schema.oneOf.map((o) => o.title ?? o.const), schema);
+  }
+  if ('const' in schema) return 'hidden';
+  if (schema.enum && schema.enum.length === 1 && schema.type === 'string') return 'hidden';
+  // Covers ObjectEditor, JsonEditor, ArrayEditor and NullableEditor containers.
+  if (schema.type === 'object' || schema.type === 'array') return 'full';
+  if (schema.enum) return choiceSize(schema.enum, schema);
+  if (schema.type === 'boolean') return bumpNullable('xs', schema);
+  if (schema.type === 'number' || schema.type === 'integer') return bumpNullable('xs', schema);
+  if (schema.type === 'string') {
+    if (schema.format === 'date') return bumpNullable('sm', schema);
+    if (schema.format === 'date-time') return bumpNullable('md', schema);
+    // Mirrors StringEditor.isLong (textarea rendering).
+    if (schema.format === 'textarea' || schema.maxLength > 255) return 'full';
+    if (schema.maxLength > 0 && schema.maxLength <= 40) return bumpNullable('sm', schema);
+    return 'md';
+  }
+  return 'full';
+}
+
+// Builds the cell list for an object's properties: resolved schema, wrapper
+// classes and row-break flags. `break: 'after'` marks the NEXT visible field;
+// hidden fields neither consume nor emit a pending break.
+// Custom-editor matches default to 'full' (we can't predict their rendering)
+// unless the schema hint or the override's own `layout` says otherwise.
+export function layoutCells(properties, { resolveSchema, customEditors = [], basePath = [] } = {}) {
+  const cells = [];
+  let pendingBreak = false;
+  // Mirrors SchemaEditor: the depth guard runs before custom-editor overrides,
+  // and past it every field (const included) renders a visible StringEditor.
+  const pastMaxDepth = basePath.length + 1 > MAX_DEPTH;
+  for (const [key, raw] of Object.entries(properties || {})) {
+    const schema = resolveSchema ? resolveSchema(raw) : raw;
+    const hint = normalizeLayoutHint(schema.layout);
+    const override = !pastMaxDepth
+      && customEditors.find((o) => o.match && o.match(schema, [...basePath, key]));
+    let size;
+    if (pastMaxDepth) {
+      size = 'md';
+    } else if (override) {
+      size = hint.size || normalizeLayoutHint(override.layout).size || 'full';
+    } else {
+      size = fieldSize(schema);
+    }
+    const classes = ['sf-cell', `sf-cell-${size}`];
+    // Only the plain-boolean shape reaches the label-less BooleanEditor;
+    // boolean enums / choice oneOfs render SelectEditor (which has a label).
+    const isCheckbox = schema.type === 'boolean' && !override && !pastMaxDepth
+      && !schema.enum && !schema.oneOf && !('const' in schema);
+    let breakBefore = false;
+    if (size !== 'hidden') {
+      if (isCheckbox) classes.push('sf-cell-bool');
+      breakBefore = pendingBreak || hint.break === 'before' || hint.break === 'both';
+      pendingBreak = hint.break === 'after' || hint.break === 'both';
+    }
+    cells.push({ key, schema, classes: classes.join(' '), breakBefore });
+  }
+  return cells;
+}

package/src/scss/components/layout.scss

@@ -0,0 +1,76 @@
+// Multicolumn flow layout for object fields.
+//
+// Model: each .sf-object-fields is a wrapping flex row; cells carry a
+// flex-basis token per field kind (set in src/layout.js) and grow to share
+// the line. Columns emerge from the available width at every nesting level —
+// no media/container queries, no containment (container-type would create
+// stacking contexts under the relation dropdown and collapse the widget's
+// intrinsic width inside Django tabular-inline table cells).
+//
+// Invariant: visual order === DOM order === tab order. No `order`, ever.
+//
+// Gate: @supports (inset: 0) matches the flex-`gap` era (Chrome 87+,
+// FF 66+, Safari 14.5+). Do not test `gap` itself — it false-positives on
+// browsers that only support grid gap. Ungated browsers keep the original
+// single-column flex layout from editors.scss.
+.structured-field-editor {
+
+  .sf-cell {
+    // Required guard: without it a long relation tag or wide intrinsic
+    // content makes the flex item refuse to shrink and blows up the row.
+    min-width: 0;
+  }
+
+  .sf-cell-hidden {
+    display: none;
+  }
+
+  @supports (inset: 0) {
+    .sf-object-fields {
+      flex-flow: row wrap;
+      column-gap: 16px;
+      align-items: flex-start;
+    }
+
+    // Vertical rhythm stays on the editors' own margin-bottom (as in the
+    // single-column layout), so the zero-height row break adds no space.
+    .sf-flow-break {
+      flex-basis: 100%;
+      height: 0;
+    }
+
+    .sf-cell-xs   { flex: 1 1 var(--sf-basis-xs, 8rem); }
+    .sf-cell-sm   { flex: 1 1 var(--sf-basis-sm, 12rem); }
+    .sf-cell-md   { flex: 1 1 var(--sf-basis-md, 18rem); }
+    .sf-cell-lg   { flex: 1 1 var(--sf-basis-lg, 26rem); }
+    .sf-cell-full { flex: 1 1 100%; }
+
+    // Checkbox fields have no label above: equalize the bottom margin and
+    // anchor them to the line's bottom so the checkbox row sits on the same
+    // visual line as its neighbors' inputs.
+    .sf-cell > .sf-field-boolean {
+      margin-bottom: 12px;
+    }
+
+    .sf-cell-bool {
+      align-self: flex-end;
+
+      .sf-boolean-row {
+        min-height: var(--sf-control-height, 30px);
+      }
+    }
+
+    // While validation errors are shown, flex-end would sink checkboxes to
+    // the bottom of the grown line; anchor them to the top instead with a
+    // synthesized label row (one .sf-label line + its 4px margin).
+    @supports selector(:has(*)) {
+      .sf-object-fields:has(.errorlist) > .sf-cell-bool {
+        align-self: flex-start;
+
+        > .sf-field-boolean {
+          padding-top: calc(0.8125rem * 1.4 + 4px);
+        }
+      }
+    }
+  }
+}

package/src/scss/main.scss

@@ -1,3 +1,4 @@
 @use './components/form';
 @use './components/editors';
 @use './components/relation';
+@use './components/layout';

package/src/utils.js

@@ -16,6 +16,24 @@ export function deepClone(obj) {
   return clone;
 }
 
+export function isChoiceOneOf(list) {
+  // A "choice list" oneOf: every member is a {const, title?} value option
+  // (the shape emitted for enumerated choices, e.g. metaobjects' select
+  // kind), as opposed to a oneOf of alternative sub-schemas.
+  return (
+    Array.isArray(list) &&
+    list.length > 0 &&
+    list.every(
+      (m) =>
+        m &&
+        typeof m === 'object' &&
+        'const' in m &&
+        !('properties' in m) &&
+        m.type !== 'null'
+    )
+  );
+}
+
 export function getDefaultForSchema(schema) {
   if ('default' in schema) return deepClone(schema.default);
   if (schema.type === 'object') {