@globalbrain/sefirot 4.59.0 → 4.60.0

package/lib/blocks/lens/FieldData.ts

@@ -61,6 +61,16 @@ export interface FieldDataBase {
   showOnDetail?: boolean
   showOnCreate?: boolean
   showOnUpdate?: boolean
+  /**
+   * The server-declared blank for the field's input, as a wire-format
+   * payload value — the server owns this entirely: types whose blank isn't
+   * null (a multiple select's `[]`) declare it here, and an entity may set
+   * its own (e.g. `'draft'` for a status select). Feeds `inputEmptyValue`:
+   * the create form seeds from it, and an editor opening on a null stored
+   * value falls back to it. Null or absent (backends predating the key)
+   * means a null blank.
+   */
+  emptyValue?: any
 }
 
 export interface AvatarFieldData extends FieldDataBase {

package/lib/blocks/lens/components/LensCatalog.vue

@@ -74,6 +74,11 @@ export interface Props {
   // normally. The value remains accessible via `record[indexField]` in
   // `cell-clicked` events and through the `selected` model regardless.
   //
+  // When omitted, the identifier defaults to `id`, and the `selected`
+  // model is keyed by it on any catalog — editable or not — whenever the
+  // loaded rows carry it (server-default selects typically do). Only rows
+  // without the identifier fall back to positional selection keys.
+  //
   // If the caller's `select` is empty or `null` (i.e. "use server
   // defaults"), the index field is **not** auto-appended — that would
   // narrow the result to just that single column on backends that treat
@@ -584,33 +589,59 @@ const tableSelect = computed(() => {
 const idField = computed(() => props.indexField ?? 'id')
 
 // Whether the currently loaded rows actually carry the effective row identifier.
-// Editing / opening a row needs it (`resolveId`), but rows fetched while
-// `editable` was still false — or before an `indexField` change settled — won't
-// have it until the triggered refetch lands. Editing is gated on this (see the
-// `editable` getter) so a quick save in that window can't post `id: undefined`.
-// An empty result has nothing to edit, so it doesn't block.
+// Editing / opening a row needs it (`resolveId`), and the table's selection key
+// only switches onto it when present (`tableIndexField` below). Rows fetched
+// while `editable` was still false — or before an `indexField` change settled —
+// won't have it until the triggered refetch lands. Editing is gated on this (see
+// the `editable` getter) so a quick save in that window can't post
+// `id: undefined`. An empty result has nothing to edit or select, so it
+// doesn't block.
 const rowsCarryIndexField = computed(() => {
   const rows = result.value?.data
   if (!rows || rows.length === 0) { return true }
   return idField.value in rows[0]
 })
 
-// The row-identifier the table uses as its selection key. An explicit
-// `indexField`, or `id` for editable catalogs (which always carry it). Without
-// this, an editable catalog that relies on the default would leave the table on
-// positional selection keys, so an optimistic create/delete that shifts rows
-// would leave `selected` pointing at the wrong records. Mirrors `edit.indexField`.
+// The row-identifier the table uses as its selection key: the effective
+// `idField`, on any catalog whose loaded rows carry it. Without this, a catalog
+// relying on the default `id` would leave the table on positional selection
+// keys, so anything that shifts rows — an optimistic create/delete, a page
+// change, a re-sort, a refresh-banner apply — would leave `selected` pointing
+// at the wrong records. Editable or not: a read-only catalog with
+// `v-model:selected` (a picker dialog, say) needs identity keys just as much,
+// and a server-default select typically already carries `id`. Mirrors
+// `edit.indexField`.
 //
-// Gated on `rowsCarryIndexField`: when `editable` flips true (or `indexField`
-// changes) the on-screen rows don't carry the new key until the triggered refetch
-// lands. Switching STable onto it during that window keys every row's selection to
-// `undefined` — wiping the current selection and making any row-select emit
-// `[undefined]` (so parent bulk actions act on no/wrong records). Stay on the
-// previous positional key until the loaded rows carry it, matching the
-// `edit.editable` gate so selection and editing flip together.
+// Gated on `rowsCarryIndexField`: while the loaded rows don't carry the key —
+// an explicit `select` that omits it, or an `indexField` change (on an editable
+// catalog the triggered refetch below brings the new key in; a read-only
+// catalog stays positional until a fetch happens to include it) — switching
+// STable onto it would key every row's selection to `undefined`, wiping the
+// current selection and making any row-select emit `[undefined]` (so parent
+// bulk actions act on no/wrong records). Stay on the positional key until the
+// loaded rows carry it.
 const tableIndexField = computed(() => {
-  const field = props.indexField ?? (props.editable ? 'id' : undefined)
-  return field && rowsCarryIndexField.value ? field : undefined
+  return rowsCarryIndexField.value ? idField.value : undefined
+})
+
+// `selected` keys live in `tableIndexField`'s domain — record identity vs row
+// position. If that domain changes while rows are on screen (a view change
+// dropping the identifier column, one re-adding it, a runtime `indexField`
+// swap), the held keys mean nothing under the new domain — but STable's
+// selection pruning keeps any that happen to *collide* with it (a numeric id
+// surviving as a row position, or vice versa), silently re-pointing the
+// selection at wrong rows for the parent's bulk actions. Clear it instead.
+//
+// A flip settling on a fetch that follows an empty table (`hadRows` false —
+// first load, or a filter state with no matches) doesn't count: nothing was
+// selectable under the previous domain, so anything already in `selected` is a
+// parent-provided seed targeting the domain being settled, and must survive it.
+let hadRows = false
+watch([tableIndexField, () => result.value?.data], ([field], [prevField]) => {
+  if (field !== prevField && hadRows && selected.value?.length) {
+    selected.value = []
+  }
+  hadRows = (result.value?.data?.length ?? 0) > 0
 })
 
 // The `indexField` is appended to the request `select` so the server
@@ -622,10 +653,16 @@ const tableIndexField = computed(() => {
 //
 // Editable catalogs must carry a row identifier so updates / deletes can
 // address each row; when no `indexField` is configured the identifier
-// defaults to `id`. When the caller has no concrete select list, nothing
-// is added either — leaving the request empty lets the server use its own
-// defaults (which include `id`, so the read-only sheet still opens). See
-// `indexField` prop docs above.
+// defaults to `id`. Read-only catalogs get no *default* identifier appended
+// (an explicit `indexField` is always included, per its prop doc): the
+// selection key (`tableIndexField` above) is opportunistic — it keys by the
+// identifier when the rows already carry it (server defaults typically
+// include `id`) and stays positional when an explicit `select` omits it,
+// rather than growing every read-only request by an extra column. When the
+// caller has no concrete select list, nothing is added either — leaving the
+// request empty lets the server use its own defaults (which typically
+// include `id`, so the read-only sheet still opens). See `indexField` prop
+// docs above.
 function withIndexField(fields: string[]): string[] {
   if (fields.length === 0) { return [] }
   const field = props.indexField ?? (props.editable ? 'id' : null)

package/lib/blocks/lens/components/LensSheetField.vue

@@ -95,7 +95,7 @@ const formEl = ref<HTMLElement | null>(null)
 
 function start() {
   const raw = props.record[props.fieldKey]
-  model.value = props.field.payloadToInput(raw ?? props.field.inputEmptyValue())
+  model.value = raw != null ? props.field.payloadToInput(raw) : props.field.inputEmptyValue()
   reset()
   editing.value = true
   // Focus the input on open (matching the inline table editor): better UX, and

package/lib/blocks/lens/components/LensTable.vue

@@ -236,9 +236,10 @@ const table = useTable({
   orders,
   columns,
   // A getter (not a snapshot) so the selection key stays reactive: `indexField`
-  // can change after mount — e.g. an editable catalog resolves permissions async
-  // and flips from positional keys to `id`. STable reads this inside a computed,
-  // so the getter establishes the dependency and selection re-keys correctly.
+  // can change after mount — e.g. rows landing without the identifier flip the
+  // catalog from identity keys back to positional, and an `indexField` change
+  // settling re-keys it. STable reads this inside a computed, so the getter
+  // establishes the dependency and selection re-keys correctly.
   get indexField() { return props.indexField },
   borderless: true
 })

package/lib/blocks/lens/components/LensTableAvatarCell.vue

@@ -193,7 +193,8 @@ function startNames() {
     return
   }
   for (const entry of nameEntries.value) {
-    nameModel[entry.key] = entry.field.payloadToInput(props.record[entry.key] ?? entry.field.inputEmptyValue())
+    const raw = props.record[entry.key]
+    nameModel[entry.key] = raw != null ? entry.field.payloadToInput(raw) : entry.field.inputEmptyValue()
   }
   reset()
   inline?.start(myKey.value)

package/lib/blocks/lens/components/LensTableEditableCell.vue

@@ -156,7 +156,8 @@ function start() {
   }
 
   inputComponent.value = props.field.formInputComponent()
-  model.value = props.field.payloadToInput(props.value ?? props.field.inputEmptyValue())
+  const raw = props.value
+  model.value = raw != null ? props.field.payloadToInput(raw) : props.field.inputEmptyValue()
   reset()
   inline?.start(myKey.value)
   nextTick(() => {

package/lib/blocks/lens/fields/AvatarField.ts

@@ -56,10 +56,6 @@ export class AvatarField extends Field<AvatarFieldData> {
     return false
   }
 
-  override inputEmptyValue(): any {
-    return null
-  }
-
   override formInputComponent(): any {
     return this.defineFormInputComponent((props, { emit }) => {
       return () => h(LensInputAvatar, {

package/lib/blocks/lens/fields/Field.ts

@@ -255,10 +255,21 @@ export abstract class Field<T extends FieldData> {
   }
 
   /**
-   * Returns the value should be used when the input is empty.
+   * The value an empty input starts from: the definition's `emptyValue`, a
+   * wire-format payload value run through `payloadToInput`. The server owns
+   * the blank entirely — field types with a non-null blank (a multiple
+   * select's `[]`, say) declare it in their definition, so there are no
+   * per-type overrides here. Only null/undefined fall back to a null blank,
+   * so `false` and `0` are real values.
+   *
+   * Feeds the create-form seeding and the editors' null fallback alike, so
+   * a non-blank `emptyValue` also pre-fills the editor of a record whose
+   * stored value is null.
    */
   inputEmptyValue(): any {
-    return null
+    return this.data.emptyValue != null
+      ? this.payloadToInput(this.data.emptyValue)
+      : null
   }
 
   /**

package/lib/blocks/lens/fields/FileUploadField.ts

@@ -49,10 +49,6 @@ export class FileUploadField extends Field<FileUploadFieldData> {
     })
   }
 
-  override inputEmptyValue(): any {
-    return []
-  }
-
   override formInputComponent(): any {
     return this.defineFormInputComponent((props, { emit }) => {
       return () => h(SInputFileUpload, {

package/lib/blocks/lens/fields/SelectField.ts

@@ -145,17 +145,11 @@ export class SelectField extends Field<SelectFieldData> {
   }
 
   protected renderDataListItemValueForText(value: any): any {
-    if (this.data.multiple) {
-      value = Array.isArray(value) ? value : [value]
-    }
+    value = Array.isArray(value) ? value : [value]
 
     return this.optionsForValues(value).map((o) => this.labelForOption(o)).join(', ')
   }
 
-  override inputEmptyValue(): any {
-    return this.data.multiple ? [] : null
-  }
-
   override formInputComponent(): any {
     switch (this.data.inputAs) {
       case 'dropdown':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@globalbrain/sefirot",
-  "version": "4.59.0",
+  "version": "4.60.0",
   "description": "Vue Components for Global Brain Design System.",
   "keywords": [
     "components",
@@ -59,8 +59,8 @@
     "@iconify-json/ph": "^1.2.2",
     "@iconify-json/ri": "^1.2.10",
     "@popperjs/core": "^2.11.8",
-    "@sentry/browser": "^10.62.0",
-    "@sentry/vue": "^10.62.0",
+    "@sentry/browser": "^10.63.0",
+    "@sentry/vue": "^10.63.0",
     "@tanstack/vue-virtual": "3.0.0-beta.62",
     "@tinyhttp/content-disposition": "^2.2.4",
     "@tinyhttp/cookie": "^2.1.1",
@@ -84,11 +84,11 @@
     "jsdom": "^29.1.1",
     "lodash-es": "^4.18.1",
     "magic-string": "^0.30.21",
-    "markdown-it": "^14.2.0",
+    "markdown-it": "^14.3.0",
     "normalize.css": "^8.0.1",
     "ofetch": "^1.5.1",
     "pinia": "^3.0.4",
-    "postcss": "^8.5.15",
+    "postcss": "^8.5.16",
     "postcss-nested": "^7.0.2",
     "punycode": "^2.3.1",
     "qs": "^6.15.3",
@@ -104,8 +104,8 @@
     "@histoire/plugin-vue": "1.0.0-beta.1",
     "@release-it/conventional-changelog": "^11.0.1",
     "@types/jsdom": "^28.0.3",
-    "@types/node": "^26.0.1",
-    "@typescript-eslint/rule-tester": "^8.62.0",
+    "@types/node": "^26.1.0",
+    "@typescript-eslint/rule-tester": "^8.62.1",
     "@vitest/coverage-v8": "^4.1.9",
     "@vue/test-utils": "^2.4.11",
     "eslint": "^9.39.4",
@@ -115,7 +115,7 @@
     "typescript": "~6.0.3",
     "vitepress": "^2.0.0-alpha.17",
     "vitest": "^4.1.9",
-    "vue-tsc": "^3.3.5"
+    "vue-tsc": "^3.3.6"
   },
   "packageManager": "pnpm@11.9.0"
 }