@object-ui/core 17.7.0 → 18.0.0

package/dist/utils/normalize-list-view.js

@@ -83,6 +83,11 @@ const isRecord = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
  * firing control. ⛔ Do not read the three as legacy-only spellings awaiting
  * retirement — the protocol declares them, so removing them here would leave
  * objectui narrower than the protocol.
+ *
+ * ⛔ `inlineEdit` → `editInline` is NOT a row here, although it lands in the same
+ * block (objectui#5144). Every row of this table is deleted after it folds;
+ * `inlineEdit` must survive its fold, because it is also the MODE `ListView`
+ * opens the grid in. See {@link foldsInlineEditIntoEditInline}.
  */
 const SHOW_FLAG_TO_USER_ACTION = {
     showSearch: 'search',
@@ -93,6 +98,43 @@ const SHOW_FLAG_TO_USER_ACTION = {
     showHideFields: 'hideFields',
     showColor: 'rowColor',
 };
+/**
+ * Whether a view's `inlineEdit` folds into `userActions.editInline`
+ * (objectui#5144, the maintainer's B-fold).
+ *
+ * The spec declares `userActions.editInline` with `.default(true)` since the
+ * maintainer's v18 ruling (objectstack#22605): a list is editable in place by
+ * default, and `editInline: false` is the opt-out. It declares the view's
+ * `inlineEdit` as the same kind of permission ("allow inline editing"). Stored
+ * views carry `inlineEdit`, not `editInline`: authored views declare it, and
+ * the console's list toolbar used to write it. Folding it here puts both keys
+ * on one vocabulary, so `ListView` can read `editInline` with the spec default
+ * and a view's own `inlineEdit` still decides it when `editInline` is absent.
+ *
+ * The console's toolbar no longer writes `inlineEdit` (objectui#5144, ruling
+ * E). It persisted a user's edit mode into this permission key, so switching
+ * the toggle off stored `inlineEdit: false` and the fold then read the view as
+ * not offering inline editing. The toggle is session state now.
+ *
+ * Two rules, each the same as a fold above:
+ *  - The value carries over: `inlineEdit: true` folds to `editInline: true`,
+ *    and `inlineEdit: false` to `editInline: false`.
+ *  - An explicit `userActions.editInline` wins. It is the spec key, so a
+ *    stored `inlineEdit` only fills the gap.
+ *
+ * One departure, the `data` → `objectName` one: `inlineEdit` is KEPT. The other
+ * folds delete because the legacy key has one meaning and one home.
+ * `inlineEdit` has a second use. It is the spec's own `ListView.inlineEdit`,
+ * and `ListView` seeds the grid's edit MODE from it on each load. The toolbar
+ * toggle then flips that mode for the session. `editInline` decides whether
+ * the toggle is offered at all. Deleting `inlineEdit` would open every such
+ * view out of edit mode.
+ */
+function foldsInlineEditIntoEditInline(s) {
+    if (typeof s.inlineEdit !== 'boolean')
+        return false;
+    return !(isRecord(s.userActions) && typeof s.userActions.editInline === 'boolean');
+}
 /**
  * Legacy `sharing.visibility` → the spec's `ViewSharing.type`. The spec models
  * two ownership kinds; objectui's four-value audience enum collapses onto them:
@@ -240,32 +282,6 @@ function readListViewKind(value) {
     warnUndrawableViewKind(value);
     return undefined;
 }
-/**
- * Per-view-type config aliases → the spec key each one aliases (#2890, the
- * phase-3 carry-over).
- *
- * Phase 3 derived `kanban` / `gallery` / `timeline` from the spec configs but
- * kept the pre-#2231 objectui spellings declared alongside the spec keys so
- * stored view metadata would keep validating
- * (`packages/types/src/zod/objectql.zod.ts`, each marked `@deprecated legacy
- * alias for the spec's X`). Folding them here is what lets a read-site stop
- * carrying its own `canonical || legacy` pair — the same move A1–A5 made for
- * the top-level vocabulary.
- *
- * `calendar` is deliberately absent: its one local key, `defaultView`, is not
- * an alias of anything. It has no spec counterpart at all, so it wants
- * PROMOTION upstream, not a rename — folding it would delete an authored value
- * with nowhere to put it.
- *
- * Note `kanban.columns` is the spec's "fields shown on each card", NOT the
- * table columns that the same word names at the ListView top level. The fold
- * is scoped to the nested config, so the two never meet.
- */
-const PER_VIEW_CONFIG_ALIASES = {
-    kanban: { groupField: 'groupByField', cardFields: 'columns' },
-    gallery: { imageField: 'coverField' },
-    timeline: { dateField: 'startDateField' },
-};
 /**
  * ObjectUI's `list-view` node historically used a different vocabulary from
  * `@objectstack/spec` for the same concepts (`fields` where the spec says
@@ -307,6 +323,12 @@ const PER_VIEW_CONFIG_ALIASES = {
  *    stays absent, because the defaults are per-toggle (search/sort/filter/
  *    rowHeight/group default ON, hideFields/rowColor default OFF) and belong to
  *    the renderer, not to the vocabulary bridge.
+ *  - the view's `inlineEdit` → `userActions.editInline` (objectui#5144), with
+ *    the value carried over and an explicit `editInline` winning. `inlineEdit`
+ *    stays on the result, because `ListView` seeds the grid's edit mode from
+ *    it. See {@link foldsInlineEditIntoEditInline}. An absent pair stays
+ *    absent here as well; `ListView` reads that as on, the spec's default
+ *    (objectstack#22605).
  *  - `aria: { label, describedBy }` → the spec's `AriaProps`
  *    (`{ ariaLabel, ariaDescribedBy }`), and `sharing: { visibility, enabled }`
  *    → the spec's `ViewSharing` (`{ type }`) — #2890 scope A step 5. `aria.live`
@@ -329,8 +351,8 @@ const PER_VIEW_CONFIG_ALIASES = {
  *      · an already-present `objectName` WINS — this fold only fills a gap, it
  *        never re-points a binding that already resolves;
  *      · `data` is NOT deleted. Every other fold deletes because the legacy key
- *        has one meaning and one home; `data` has four providers, `api`/`value`
- *        are read live in `ListView`, and the whole block is FORWARDED to child
+ *        has one meaning and one home; `data` has more providers than
+ *        `object`, `value` is read live in `ListView`, and the whole block is FORWARDED to child
  *        views (the gantt branch), whose own `getDataConfig` reads `data` before
  *        `objectName`. Deleting it for one provider would rewrite what a child
  *        resolves. Nothing in `ListView` reads `data.provider === 'object'`, so
@@ -353,16 +375,14 @@ const PER_VIEW_CONFIG_ALIASES = {
  *    breaking change with no inventory. Runs AFTER the `fields` → `columns` fold
  *    above, so a view that spells its column list the legacy way still gets its
  *    entries canonicalized.
- *  - the four PER-VIEW-TYPE config aliases phase 3 carried over
- *    ({@link PER_VIEW_CONFIG_ALIASES}): `kanban.groupField` → `groupByField`,
- *    `kanban.cardFields` → `columns`, `gallery.imageField` → `coverField`,
- *    `timeline.dateField` → `startDateField`. One read-site changes behaviour
- *    as a result, and it is a CORRECTION of the same inverted precedence A2
- *    fixed for `densityMode`: `ListView`'s kanban adapter resolves
- *    `cardFields || columns`, i.e. legacy over canonical, so a config carrying
- *    BOTH used to render the legacy value. After the fold the canonical
- *    `columns` reaches it. Every other reader of these four was already
- *    canonical-first and is unaffected.
+ *
+ * No longer folded: the four PER-VIEW-TYPE config aliases phase 3 carried over
+ * (`kanban.groupField` → `groupByField`, `kanban.cardFields` → `columns`,
+ * `gallery.imageField` → `coverField`, `timeline.dateField` →
+ * `startDateField`). objectui#6152 round 14 retired that fold with every
+ * renderer-side reader of the four: each list-view door refuses them by name
+ * (rounds 11 and 12), and a stored block that still carries one passes through
+ * here untouched and binds nothing downstream.
  */
 export function normalizeListViewSchema(schema) {
     if (!schema || typeof schema !== 'object')
@@ -380,6 +400,7 @@ export function normalizeListViewSchema(schema) {
     const legacyFilters = s.filters;
     const foldFilter = Array.isArray(legacyFilters);
     const legacyFlags = Object.keys(SHOW_FLAG_TO_USER_ACTION).filter((k) => typeof s[k] === 'boolean');
+    const foldInlineEdit = foldsInlineEditIntoEditInline(s);
     const foldDescription = typeof s.showDescription === 'boolean';
     const aria = isRecord(s.aria) ? s.aria : undefined;
     const foldAria = !!aria && Object.keys(ARIA_KEY_ALIASES).some((k) => aria[k] !== undefined);
@@ -409,22 +430,9 @@ export function normalizeListViewSchema(schema) {
             : undefined;
     const foldedColumns = normalizeColumnIdentities(columnsSource);
     const foldColumnIdentity = foldedColumns !== columnsSource;
-    // Per-view-type config aliases (#2890 phase-3 carry-over). Collected before
-    // the early return so an otherwise-canonical view carrying only a nested
-    // legacy key still folds — and so a view carrying none still returns by
-    // reference.
-    const perViewFolds = Object.entries(PER_VIEW_CONFIG_ALIASES)
-        .map(([viewKey, aliases]) => {
-        const cfg = isRecord(s[viewKey]) ? s[viewKey] : undefined;
-        if (!cfg)
-            return undefined;
-        const legacyKeys = Object.keys(aliases).filter((legacy) => cfg[legacy] !== undefined);
-        return legacyKeys.length ? { viewKey, aliases, cfg, legacyKeys } : undefined;
-    })
-        .filter((entry) => entry !== undefined);
-    if (!foldColumns && !foldRowHeight && !foldFilter && !legacyFlags.length &&
+    if (!foldColumns && !foldRowHeight && !foldFilter && !legacyFlags.length && !foldInlineEdit &&
         !foldDescription && !foldAria && !foldSharing && !defaultViewKind &&
-        !foldColumnIdentity && !perViewFolds.length && !foldObjectName) {
+        !foldColumnIdentity && !foldObjectName) {
         return schema;
     }
     const next = { ...s };
@@ -448,7 +456,7 @@ export function normalizeListViewSchema(schema) {
             next.filter = legacyFilters;
         delete next.filters;
     }
-    if (legacyFlags.length) {
+    if (legacyFlags.length || foldInlineEdit) {
         const ua = { ...(isRecord(next.userActions) ? next.userActions : {}) };
         for (const flag of legacyFlags) {
             const key = SHOW_FLAG_TO_USER_ACTION[flag];
@@ -456,6 +464,10 @@ export function normalizeListViewSchema(schema) {
                 ua[key] = s[flag];
             delete next[flag];
         }
+        // objectui#5144. Gap-fill only, and `inlineEdit` is not deleted: see
+        // `foldsInlineEditIntoEditInline`.
+        if (foldInlineEdit)
+            ua.editInline = s.inlineEdit;
         next.userActions = ua;
     }
     if (foldDescription) {
@@ -498,19 +510,6 @@ export function normalizeListViewSchema(schema) {
         delete nextSharing.enabled;
         next.sharing = nextSharing;
     }
-    for (const { viewKey, aliases, cfg, legacyKeys } of perViewFolds) {
-        const nextCfg = { ...cfg };
-        for (const legacy of legacyKeys) {
-            const canonical = aliases[legacy];
-            // Same one-directional shape as every fold above: the canonical key wins
-            // when both are present, and the legacy key is REMOVED so a missed
-            // read-site fails loudly instead of quietly taking the legacy path.
-            if (nextCfg[canonical] === undefined)
-                nextCfg[canonical] = cfg[legacy];
-            delete nextCfg[legacy];
-        }
-        next[viewKey] = nextCfg;
-    }
     if (foldObjectName)
         next.objectName = dataObjectName;
     if (defaultViewKind)

package/dist/utils/predicate-fields.js

@@ -105,7 +105,7 @@ const TARGET_ROW_TOKEN = /\{([a-z_][a-z0-9_]*)\}/gi;
 /**
  * The row key a `defaultFromRow` param seeds its value from — `field` wins,
  * because row data is keyed by object field; `name` is the fallback. The same
- * precedence `resolveActionParam` (`@object-ui/app-shell`) reads, which is the
+ * precedence `resolveActionParam` (`@object-ui/fields`) reads, which is the
  * point: the projection must carry the key the runtime looks up, not the
  * param's payload name. `remove_team_member` seeds `teamId` from `team_id`.
  */
@@ -125,7 +125,11 @@ function defaultFromRowKey(param) {
  * Each source is the one a writer actually merges into the written set:
  *
  *  - `patch`: the static field values of `operation: 'update'`, merged under the
- *    collected params (`ActionRunner`'s `executeUpdateOperation`);
+ *    collected params (`ActionRunner`'s `executeUpdateOperation`). Every def
+ *    this harvest reads is a definition its writer applies whole (a view's
+ *    resolved row def, a `bulkActionDefs` entry, an object's action), never a
+ *    page action row, so this is the declared `patch` the write applies: the
+ *    one the runner's Undo snapshot reads too (objectui#13022);
  *  - each param's COLLECTED key, `name ?? field`: the key the param dialog
  *    stores its answer under (`paramName` in `app-shell`'s
  *    `resolveActionParams`). This is the opposite precedence to

package/dist/utils/record-source.d.ts

@@ -45,7 +45,7 @@ import type { ViewData } from '@object-ui/types';
  * The ladder's second rung wraps inline rows as `{ provider: 'value', items }`,
  * which names no object at all. So for the object-NAME question the three-rung
  * ladder reduces to two rungs — the resolved config's object when it names one,
- * else the schema's own `objectName`, which is what a `value`/`api`-backed block
+ * else the schema's own `objectName`, which is what a `value`-backed block
  * still needs for metadata reads, i18n field labels and permission verdicts.
  * Callers pass the ALREADY-RESOLVED config (their
  * {@link resolveRecordSourceConfig} output, direct or through a local wrapper),

package/dist/utils/record-source.js

@@ -44,7 +44,7 @@
  * The ladder's second rung wraps inline rows as `{ provider: 'value', items }`,
  * which names no object at all. So for the object-NAME question the three-rung
  * ladder reduces to two rungs — the resolved config's object when it names one,
- * else the schema's own `objectName`, which is what a `value`/`api`-backed block
+ * else the schema's own `objectName`, which is what a `value`-backed block
  * still needs for metadata reads, i18n field labels and permission verdicts.
  * Callers pass the ALREADY-RESOLVED config (their
  * {@link resolveRecordSourceConfig} output, direct or through a local wrapper),

package/dist/utils/reference-keys.js

@@ -280,7 +280,7 @@ const warnedUnfoldableSpelling = new Set();
  * ⚠️ Not NO reader, and the line never says so (objectui#7650). Some reads of a
  * retired spelling were KEPT on purpose and still see a value this arm leaves
  * alone. For the two `no-declared-twin` keys: `resolveActionParam` in
- * `@object-ui/app-shell` reads `id_field` and `title_format` (objectui#7435
+ * `@object-ui/fields` reads `id_field` and `title_format` (objectui#7435
  * kept them; its pin `resolveActionParams.declaredLookupLegs-7435.test.ts`
  * calls them the snake spellings that must keep working), and
  * `resolveGroupByLabels` in `@object-ui/plugin-charts` reads

package/dist/validation/schema-validator.js

@@ -5,6 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+import { nodeSlotValues, nodeSlotsFor } from '@object-ui/types';
 import { hasDeclaredPredicate } from '../evaluator/declaredPredicate.js';
 import { isUnevaluablePredicate } from '../evaluator/unevaluablePredicate.js';
 /**
@@ -360,15 +361,21 @@ function validateFormSchema(schema, path = 'schema') {
     }
     return errors;
 }
+/** `schema.items[0].content[1]`: the child's path, spelled the way `children[0]` already is. */
+function spellSlotPath(path, segments) {
+    return segments.reduce((spelled, segment) => (typeof segment === 'number' ? `${spelled}[${segment}]` : `${spelled}.${segment}`), path);
+}
 /**
- * Validate child schemas recursively
+ * Validate child schemas recursively: what `children` holds on every node,
+ * and what the node slots declared for this node's type hold.
  */
 function validateChildren(schema, path = 'schema') {
     const errors = [];
-    // One spelling. This walker resolved `children || body` for ANY node type,
-    // so it outlived every per-registration read of the dialect — objectui#6771
-    // retired it, and a recursive validator that still descended `body` would
-    // keep validating a child list no renderer puts on the page.
+    // One child-list spelling. This walker resolved `children || body` for ANY
+    // node type, so it outlived every per-registration read of the dialect —
+    // objectui#6771 retired it, and a recursive validator that still descended
+    // `body` on every node would keep validating a child list no renderer puts
+    // on the page.
     const children = schema.children;
     if (children) {
         if (Array.isArray(children)) {
@@ -384,6 +391,23 @@ function validateChildren(schema, path = 'schema') {
             errors.push(...childResult.errors, ...childResult.warnings);
         }
     }
+    // The node slots THIS type's renderer reads — a dialog's `trigger`, a tab
+    // item's `content`, a page's `regions[].components` — from the one
+    // declaration in `@object-ui/types` (`nodeSlotsFor`, objectui#11170), which
+    // the `objectui check` gate and the SDUI parser read too. Per type, never a
+    // second generic spelling: `page:card`'s retired `body` is walked because
+    // that renderer is measured still painting it; `body` on any other type is
+    // not, which is the objectui#6771 line above, kept.
+    if (typeof schema.type === 'string') {
+        for (const slot of nodeSlotsFor(schema.type)) {
+            for (const { segments, value } of nodeSlotValues(schema, slot.path)) {
+                if (!isSchemaNodeShape(value))
+                    continue;
+                const childResult = validateSchema(value, spellSlotPath(path, segments));
+                errors.push(...childResult.errors, ...childResult.warnings);
+            }
+        }
+    }
     return errors;
 }
 /**

package/dist/validation/server-owned-value.d.ts

@@ -21,7 +21,11 @@
  *   2. the create-mode static `required` rule (#4069) —
  *      `isRequiredInForm` in `@object-ui/plugin-form`;
  *   3. the create-mode `requiredWhen` rule (#4085) —
- *      {@link isServerOwnedValue}, read by `resolveFieldRuleState`.
+ *      {@link isServerOwnedValue}, read by `resolveFieldRuleState`;
+ *   4. the "Set automatically when saved." hint (objectui#12108) — the form
+ *      renderer reads the same {@link isServerOwnedValue} answer it hands to
+ *      `resolveFieldRuleState`, so the hint and the lowered `required` are
+ *      one verdict.
  */
 export declare function isRuntimeDefault(v: unknown): boolean;
 /**

package/dist/validation/server-owned-value.js

@@ -67,7 +67,11 @@ function isExpressionEnvelope(v) {
  *   2. the create-mode static `required` rule (#4069) —
  *      `isRequiredInForm` in `@object-ui/plugin-form`;
  *   3. the create-mode `requiredWhen` rule (#4085) —
- *      {@link isServerOwnedValue}, read by `resolveFieldRuleState`.
+ *      {@link isServerOwnedValue}, read by `resolveFieldRuleState`;
+ *   4. the "Set automatically when saved." hint (objectui#12108) — the form
+ *      renderer reads the same {@link isServerOwnedValue} answer it hands to
+ *      `resolveFieldRuleState`, so the hint and the lowered `required` are
+ *      one verdict.
  */
 export function isRuntimeDefault(v) {
     return isRuntimeDefaultToken(v) || isExpressionEnvelope(v);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/core",
-  "version": "17.7.0",
+  "version": "18.0.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -25,9 +25,9 @@
     }
   },
   "dependencies": {
-    "@objectstack/formula": "^17.5.0",
-    "@objectstack/spec": "^17.6.0",
-    "@object-ui/types": "17.7.0"
+    "@objectstack/formula": "^18.0.0",
+    "@objectstack/spec": "^18.0.0",
+    "@object-ui/types": "18.0.0"
   },
   "devDependencies": {
     "typescript": "^6.0.3",