@multiplatform.one/frappe-ui 7.10.0 → 7.15.0

package/src/FrappeTable.tsx

@@ -12,6 +12,7 @@ import {
   type DataTableProps,
   type DataTableState,
   type FilterValue,
+  type FilterableField,
   type PageLoadQuery,
 } from "@multiplatform.one/table";
 import { AsyncBoundary } from "@multiplatform.one/components";
@@ -70,7 +71,17 @@ export interface FrappeTableProps<TDoc extends { name: string; doctype: string }
   doctype: string;
   /** Column definitions for the table */
   columns: DataTableColumn<Partial<TDoc>>[];
-  /** Fields to fetch from the server */
+  /**
+   * Fields to fetch. Omitted, a read from the bench (`serverSide`, or client
+   * mode under a provider without `fixtures`) requests `name` plus every
+   * column's `accessorKey`, and client mode under a provider carrying
+   * `fixtures` reads whole documents from the corpus. A column keyed on
+   * something that is not a doctype field (a rowAccumulator's derived key,
+   * say) makes the bench refuse that read, so name the list to leave such a
+   * key out. Name it, too, to share one collection with another reader of
+   * the same doctype (see useFrappeRows) or to fetch fields no column shows,
+   * such as a title field or a filter-only field.
+   */
   fields?: readonly (keyof TDoc & string)[];
   /** Initial filter criteria */
   filters?: Partial<TDoc> | Array<[keyof TDoc & string, string, any]>;
@@ -116,45 +127,20 @@ export interface FrappeTableProps<TDoc extends { name: string; doctype: string }
    * FrappeTable has to name it or callers (backoffice list) fail the build.
    */
   compact?: boolean;
+  /**
+   * Filters the toolbar offers. Omitted, the list is derived from the
+   * doctype's meta: under a provider carrying `fixtures` that is the
+   * corpus's "DocType" entry and never the network, whatever `baseURL` the
+   * host also carries (a corpus without the entry yields no menu);
+   * otherwise it is a `frappe.desk.form.load.getdoctype` call. The
+   * meta-derived menu offers the doctype's fields, including ones the
+   * server refuses to filter on, so a live app should pass the honoured
+   * set by hand. Passing it skips the meta read entirely, which also drops
+   * title-field row labels back to the document name.
+   */
+  filterableFields?: FilterableField[];
 }
 
-/**
- * A data table component connected to Frappe Live data.
- *
- * Displays documents from a Frappe DocType in a sortable, filterable table
- * with real-time updates via WebSocket. Integrates with the FrappeProvider
- * for configuration.
- *
- * @typeParam TDoc - The document type with at least name and doctype fields
- *
- * @example
- * ```tsx
- * interface ToDo {
- *   name: string;
- *   doctype: string;
- *   description: string;
- *   status: 'Open' | 'Closed';
- * }
- *
- * function ToDoTable() {
- *   return (
- *     <FrappeProvider baseURL="https://mysite.frappe.cloud">
- *       <FrappeTable<ToDo>
- *         doctype="ToDo"
- *         columns={[
- *           { accessorKey: 'description', header: 'Description' },
- *           { accessorKey: 'status', header: 'Status' }
- *         ]}
- *         fields={['name', 'description', 'status']}
- *         onRowClick={(row) => console.log('Clicked:', row)}
- *       />
- *     </FrappeProvider>
- *   );
- * }
- * ```
- *
- * @category Components
- */
 /**
  * Map one table FilterValue to a Frappe filter tuple. Returns null when the
  * filter carries no usable value (e.g. "contains" with an empty string) so
@@ -274,6 +260,52 @@ function stateToFrappeParams(state: DataTableState) {
   return { limitStart, limit, filters: frappeFilters, orderBy };
 }
 
+/**
+ * A data table component connected to Frappe Live data.
+ *
+ * Displays documents from a Frappe DocType in a sortable, filterable table
+ * with real-time updates via WebSocket. Integrates with the FrappeProvider
+ * for configuration.
+ *
+ * Two props read as optional and carry defaults that matter (MPO-230).
+ * Without `fields`, a read from the bench (`serverSide`, or client mode with
+ * no `fixtures`) requests `name` plus every column's `accessorKey`, and
+ * client mode under a fixture corpus reads whole documents. Without
+ * `filterableFields`, the filter menu comes from the doctype's meta: the
+ * corpus's "DocType" entry under a provider carrying `fixtures`, never the
+ * network whatever `baseURL` the host also carries, and a `getdoctype` call
+ * otherwise. Each prop's own entry has the detail.
+ *
+ * @typeParam TDoc - The document type with at least name and doctype fields
+ *
+ * @example
+ * ```tsx
+ * interface ToDo {
+ *   name: string;
+ *   doctype: string;
+ *   description: string;
+ *   status: 'Open' | 'Closed';
+ * }
+ *
+ * function ToDoTable() {
+ *   return (
+ *     <FrappeProvider baseURL="https://mysite.frappe.cloud">
+ *       <FrappeTable<ToDo>
+ *         doctype="ToDo"
+ *         columns={[
+ *           { accessorKey: 'description', header: 'Description' },
+ *           { accessorKey: 'status', header: 'Status' }
+ *         ]}
+ *         fields={['name', 'description', 'status']}
+ *         onRowClick={(row) => console.log('Clicked:', row)}
+ *       />
+ *     </FrappeProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @category Components
+ */
 export function FrappeTable<TDoc extends { name: string; doctype: string }>({
   baseURL,
   auth,
@@ -363,11 +395,42 @@ export function FrappeTable<TDoc extends { name: string; doctype: string }>({
     return new FrappeApp(finalBaseURL, (finalAuth ?? {}) as Record<string, unknown>);
   }, [serverSide, finalBaseURL, finalAuth]);
 
+  // Keyed on content, not on the columns array, so an inline `columns`
+  // literal cannot re-key the fetch every render and refetch in a loop.
+  const columnFieldsKey = fields
+    ? undefined
+    : JSON.stringify(
+        columns
+          .map((column): unknown => column.accessorKey)
+          .filter((key): key is string => typeof key === "string"),
+      );
+  const serverFields = useMemo<string[]>(
+    () =>
+      fields
+        ? (fields as string[])
+        : Array.from(new Set<string>(["name", ...JSON.parse(columnFieldsKey ?? "[]")])),
+    [fields, columnFieldsKey],
+  );
+  // Client mode over a fixture corpus keeps whole documents: narrowing it
+  // would drop the non-column fields (a title field, a filter-only field)
+  // fixture hosts read today.
+  const clientFields = (fields ??
+    (connectionConfig.fixtures ? undefined : serverFields)) as typeof fields;
+
   // Full doctype field list → table filterableFields: hidden / non-column
   // fields become filterable through the toolbar Filter surface. An explicit
   // filterableFields prop overrides the metadata-derived list (fixtures,
-  // stories, custom subsets).
-  const { meta } = useDocTypeMeta(filterableFieldsProp ? undefined : connectionConfig, doctype);
+  // stories, custom subsets). A fixture corpus is the whole world for meta
+  // too: the read goes to its "DocType" collection with the baseURL a
+  // fixture host may still carry withheld, so a corpus without the entry
+  // yields no menu instead of dialling getdoctype (MPO-230).
+  const skipMeta = !!filterableFieldsProp;
+  const metaConnection = useMemo(() => {
+    if (skipMeta) return undefined;
+    if (!connectionConfig.fixtures) return connectionConfig;
+    return { ...connectionConfig, baseURL: undefined };
+  }, [skipMeta, connectionConfig]);
+  const { meta } = useDocTypeMeta(metaConnection, doctype);
   const metaFilterFields = useMemo(
     () => (meta?.fields ? docFieldsToFilterFields(meta.fields) : undefined),
     [meta],
@@ -465,7 +528,7 @@ export function FrappeTable<TDoc extends { name: string; doctype: string }>({
       try {
         const [data, count] = await Promise.all([
           frappeApp.db().getDocList<TDoc>(doctype, {
-            fields: (fields as string[]) ?? ["name"],
+            fields: serverFields,
             filters: params.filters.length ? params.filters : undefined,
             limitStart: params.limitStart,
             limit: params.limit,
@@ -507,7 +570,7 @@ export function FrappeTable<TDoc extends { name: string; doctype: string }>({
         }
       }
     },
-    [frappeApp, serverSide, doctype, fields],
+    [frappeApp, serverSide, doctype, serverFields],
   );
 
   // Live invalidation for serverSide mode: any realtime event for this
@@ -565,7 +628,7 @@ export function FrappeTable<TDoc extends { name: string; doctype: string }>({
       } as DataTableState);
       const [rows, count] = await Promise.all([
         frappeApp.db().getDocList<TDoc>(doctype, {
-          fields: (fields as string[]) ?? ["name"],
+          fields: serverFields,
           filters: params.filters.length ? params.filters : undefined,
           limitStart: params.limitStart,
           limit: params.limit,
@@ -577,7 +640,7 @@ export function FrappeTable<TDoc extends { name: string; doctype: string }>({
       ]);
       return { rows, totalCount: count ?? undefined };
     },
-    [frappeApp, doctype, fields],
+    [frappeApp, doctype, serverFields],
   );
 
   const resolvedLoadPage = loadPageProp ?? (infiniteServerMode ? frappeLoadPage : undefined);
@@ -632,7 +695,7 @@ export function FrappeTable<TDoc extends { name: string; doctype: string }>({
     isQueryLoading: isRowsLoading,
     error: liveError,
   } = useFrappeRows<TDoc>(serverSide ? undefined : connectionConfig, doctype, {
-    fields,
+    fields: clientFields,
     filters: activeFilters,
     limit: null,
     enabled: !serverSide,

package/src/childTableDependsOn.spec.tsx

@@ -0,0 +1,85 @@
+import { fireEvent, screen, waitFor, within } from "@testing-library/react";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { describe, expect, it, vi } from "vitest";
+import {
+  childCellHidden,
+  childFieldsToDetailColumns,
+  type ChildTableFieldDef,
+  type FieldSchema,
+} from "./fieldRegistry";
+import { SchemaForm, type FormSchema } from "./schemaForm";
+
+const childFields: ChildTableFieldDef[] = [
+  { fieldname: "item_code", fieldtype: "Data", label: "Item Code", in_list_view: 1 },
+  { fieldname: "has_serial", fieldtype: "Check", label: "Has Serial", in_list_view: 1 },
+  {
+    fieldname: "serial_no",
+    fieldtype: "Data",
+    label: "Serial No",
+    in_list_view: 1,
+    depends_on: "eval:doc.has_serial == 1",
+  },
+  {
+    fieldname: "warranty",
+    fieldtype: "Data",
+    label: "Warranty",
+    depends_on: 'eval:parent.status == "Draft"',
+  },
+  { fieldname: "sec", fieldtype: "Section Break" },
+];
+
+function renderOrder(status: string) {
+  const fields: FieldSchema[] = [
+    { type: "Data", name: "status", label: "Status" },
+    { type: "Table", name: "items", label: "Items", options: "Order Item", fields: childFields },
+  ];
+  const schema: FormSchema = { fields, sections: [{ columns: [{ fields }] }] };
+  return renderWithProviders(
+    <SchemaForm
+      schema={schema}
+      doc={{
+        status,
+        items: [
+          { name: "r1", item_code: "SKU-1", has_serial: 1, serial_no: "SN-1", warranty: "1y" },
+          { name: "r2", item_code: "SKU-2", has_serial: 0, serial_no: "SN-2", warranty: "2y" },
+        ],
+      }}
+      setValue={vi.fn()}
+    />,
+  );
+}
+
+describe("child-table per-row depends_on (MPO-22)", () => {
+  it("compiles child depends_on against the row, with the parent doc in scope", () => {
+    const hidden = childCellHidden(childFields, { status: "Draft" })!;
+    expect(hidden({ has_serial: 1 }, "serial_no", 0)).toBe(false);
+    expect(hidden({ has_serial: 0 }, "serial_no", 1)).toBe(true);
+    expect(hidden({ has_serial: 0 }, "item_code", 1)).toBe(false);
+    expect(hidden({}, "warranty", 0)).toBe(false);
+    expect(childCellHidden(childFields, { status: "Submitted" })!({}, "warranty", 0)).toBe(true);
+    expect(childCellHidden([{ fieldname: "a", fieldtype: "Data" }])).toBeUndefined();
+  });
+
+  it("hides the cell on the row whose depends_on is false and keeps it on the other", () => {
+    renderOrder("Draft");
+    const serials = screen.getAllByLabelText("Serial No") as HTMLInputElement[];
+    expect(serials.map((input) => input.value)).toEqual(["SN-1"]);
+    expect(screen.getAllByLabelText("Item Code")).toHaveLength(2);
+  });
+
+  it("the row detail editor shows every child field and applies the same rule", async () => {
+    expect(childFieldsToDetailColumns(childFields).map((c) => c.id)).toEqual([
+      "item_code",
+      "has_serial",
+      "serial_no",
+      "warranty",
+    ]);
+
+    renderOrder("Submitted");
+    fireEvent.click(screen.getByRole("button", { name: "Edit row 2" }));
+    const dialog = await waitFor(() => screen.getByRole("dialog", { name: "Row 2" }));
+    expect((within(dialog).getByLabelText("Item Code") as HTMLInputElement).value).toBe("SKU-2");
+    expect(within(dialog).queryByLabelText("Serial No")).toBeNull();
+    expect(within(dialog).queryByLabelText("Warranty")).toBeNull();
+  });
+});

package/src/desk/DeskFormSidebar.spec.tsx

@@ -87,4 +87,24 @@ describe("DeskFormSidebar (MPO-111)", () => {
     renderSidebar();
     expect(await screen.findByTestId("desk-form-sidebar")).toBeTruthy();
   });
+
+  it("hands FormSidebar the Assigned To and Shared With sections even when both are empty", async () => {
+    const doc = {
+      name: "TODO-002",
+      doctype: "Todo",
+      description: "File",
+      owner: "sam@example.com",
+    };
+    let call = 0;
+    mockUseLiveQuery.mockImplementation(() => {
+      const slot = call++ % 3;
+      return { data: slot === 0 ? [doc] : [] };
+    });
+    renderSidebar("TODO-002");
+    const sidebar = await screen.findByTestId("desk-form-sidebar");
+    // buildSidebarSections always emits assignments; shares only when the
+    // DocShare subscription exists (it does here). An empty list keeps its
+    // section and renders emptyText — the pane never loses a row.
+    expect(sidebar.getAttribute("data-section-keys")).toBe("assignments,shares");
+  });
 });

package/src/desk/DeskFormSidebar.stories.tsx

@@ -126,6 +126,31 @@ function makeFixtures() {
   });
 }
 
+/**
+ * Same doc, nothing hanging off it: no `_assign` mirror, no DocShare row, no
+ * image. Every section still renders — with its emptyText — so the pane
+ * geometry is identical to the populated board.
+ */
+const bareTodoDocs = [
+  {
+    name: "TODO-002",
+    doctype: "Todo",
+    description: "File the expense report",
+    status: "Open",
+    owner: "sam@example.com",
+    modified_by: "sam@example.com",
+    creation: "2026-02-03",
+  },
+];
+
+function makeBareFixtures() {
+  return new InMemoryFixtureProvider({
+    Todo: bareTodoDocs,
+    DocShare: [],
+    ToDo: [],
+  });
+}
+
 export const Default = () => (
   <FrappeProvider baseURL={MOCK_HOST} fixtures={makeFixtures()}>
     <YStack width={320} height={520}>
@@ -135,6 +160,23 @@ export const Default = () => (
 );
 Default.storyName = "Main";
 
+export const EmptySections = () => (
+  <FrappeProvider baseURL={MOCK_HOST} fixtures={makeBareFixtures()}>
+    <YStack width={320} height={520}>
+      <DeskFormSidebar doctype="Todo" name="TODO-002" />
+    </YStack>
+  </FrappeProvider>
+);
+EmptySections.storyName = "Empty Sections";
+EmptySections.parameters = {
+  docs: {
+    description: {
+      story:
+        "Doc with no assignees, no shares and no image: Assigned To reads its emptyText (No one assigned), Shared With reads Not shared, and the metadata rows still come from the doc.",
+    },
+  },
+};
+
 export const Loading = () => (
   <FrappeProvider baseURL={MOCK_HOST} fixtures={makeFixtures()}>
     <YStack width={320} height={200}>

package/src/fieldRegistry.spec.tsx

@@ -9,13 +9,19 @@
  * are plain functions without hooks, so calling them directly is safe).
  */
 import { Button, Combobox, ImageField } from "@multiplatform.one/forms";
-import type { FrappeFieldType } from "@multiplatform.one/frappe";
+import {
+  customFieldTypes,
+  frappeFieldTypes,
+  type FrappeFieldType,
+} from "@multiplatform.one/frappe";
 import type React from "react";
-import { describe, expect, it } from "vitest";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { registeredFieldtypesFromSource } from "../tests/registrySource";
 import {
   childFieldsToColumns,
   fieldtypeToTableField,
   getFieldComponent,
+  registerField,
   type ChildTableFieldDef,
   type FieldRenderProps,
 } from "./fieldRegistry";
@@ -274,69 +280,26 @@ describe("form adapters (registry context)", () => {
     expect(element.props.value).toBe("mail");
   });
 
-  it("union-minus-registry holds no real fieldtype (layout breaks only)", () => {
-    // Every FrappeFieldType member from public/frappe/src/doctype.ts. A real
-    // fieldtype missing from the registry renders the unsupported-type string
-    // (the MPO-51 Icon hole, reopened once already by 035867446's registry
-    // rewrite), so this list is asserted against the registry wholesale.
-    const frappeFieldTypes: readonly FrappeFieldType[] = [
-      "Autocomplete",
-      "Attach",
-      "Attach Image",
-      "Barcode",
-      "Button",
-      "Check",
-      "Code",
-      "Color",
-      "Column Break",
-      "Currency",
-      "Data",
-      "Date",
-      "Datetime",
-      "Duration",
-      "Dynamic Link",
-      "Float",
-      "Geolocation",
-      "HTML",
-      "HTML Editor",
-      "Heading",
-      "Icon",
-      "Image",
-      "Int",
-      "JSON",
-      "Link",
-      "Long Text",
-      "Markdown Editor",
-      "Password",
-      "Percent",
-      "Phone",
-      "Rating",
-      "Read Only",
-      "Section Break",
-      "Select",
-      "Signature",
-      "Small Text",
-      "Tab Break",
-      "Table",
-      "Table MultiSelect",
-      "Text",
-      "Text Editor",
-      "Time",
-    ];
-    const unregistered = frappeFieldTypes.filter((fieldtype) => !getFieldComponent(fieldtype));
-    // The three layout breaks never get adapters — FormSection / FormGrid /
+  it("union-minus-registry holds no real fieldtype (structural types only)", () => {
+    // A real fieldtype missing from the registry renders the unsupported-type
+    // string (the MPO-51 Icon hole, reopened once already by 035867446's
+    // registry rewrite), so the whole union is asserted against the registry.
+    // The three breaks and Fold never get adapters: FormSection / FormGrid /
     // Tabs serve them structurally.
-    const layoutBreaks = ["Column Break", "Section Break", "Tab Break"];
-    for (const layoutBreak of layoutBreaks) {
-      expect(unregistered).toContain(layoutBreak);
-    }
-    expect(unregistered).not.toContain("Icon");
-    // "Button" is transiently tolerated here: its adapter (a8f8f52bd) was
-    // reverted by the same 035867446 rewrite and is being restored on
-    // lane/MPO-51-button-fieldtype. Drop it from this allowlist when that
-    // lands — the Button spec below pins the adapter itself.
-    for (const fieldtype of unregistered) {
-      expect([...layoutBreaks, "Button"]).toContain(fieldtype);
+    const unregistered = frappeFieldTypes.filter((fieldtype) => !getFieldComponent(fieldtype));
+    expect([...unregistered].sort()).toEqual(
+      ["Column Break", "Fold", "Section Break", "Tab Break"].sort(),
+    );
+  });
+
+  it("registers nothing outside the FrappeFieldType union (MPO-15)", () => {
+    expectTypeOf(registerField).parameter(0).toEqualTypeOf<FrappeFieldType>();
+    const union = new Set<string>(frappeFieldTypes);
+    const registered = [...registeredFieldtypesFromSource()];
+    expect(registered.length).toBeGreaterThan(40);
+    expect(registered.filter((fieldtype) => !union.has(fieldtype))).toEqual([]);
+    for (const custom of customFieldTypes) {
+      expect(getFieldComponent(custom), custom).toBeDefined();
     }
   });
 

package/src/fieldRegistry.ts

@@ -8,10 +8,11 @@
 
 import React, { useMemo } from "react";
 import type { ComponentType } from "react";
-import { useDocTypeMeta } from "@multiplatform.one/frappe";
+import { useDocTypeMeta, type FrappeFieldType } from "@multiplatform.one/frappe";
 import { Button, CheckboxGroup, Combobox, ImageField, Skeleton } from "@multiplatform.one/forms";
 
 import { Barcode } from "./fields/Barcode";
+import { compileDependsOn, type DependsDoc, type DependsEvaluator } from "./dependsOn";
 import { useFrappeConfig } from "./FrappeProvider";
 import { Check, type CheckProps } from "./fields/Check";
 import { CodeEditorField, frappeCodeLanguage } from "./fields/CodeEditor";
@@ -47,6 +48,7 @@ import { SwitchField } from "./fields/Switch";
 import { TableMultiSelect } from "./fields/TableMultiSelect";
 import {
   ChildTable,
+  type ChildCellHidden,
   type DataTableCellRenderContext,
   type DataTableField,
 } from "@multiplatform.one/table";
@@ -112,6 +114,8 @@ export interface FieldRenderProps {
   doctype?: string;
   /** For Select fields: newline-separated options string or other config */
   options?: string;
+  /** For Table fields: the form doc child `depends_on` reads as `parent`. */
+  parentDoc?: Record<string, unknown>;
   /** Allow pass-through props */
   [key: string]: any;
 }
@@ -129,9 +133,13 @@ const registry = new Map<string, ComponentType<FieldRenderProps>>();
  * override channel: writing it per provider instance clobbers every other
  * provider on the page (last render wins, silently). Per-subtree overrides
  * belong on `FieldOverridesProvider` (fieldOverrides.tsx), which SchemaForm
- * consults before this table.
+ * consults before this table. Only a `FrappeFieldType` registers: the union
+ * is the authority on what a fieldtype may be (MPO-15).
  */
-export function registerField(fieldtype: string, component: ComponentType<FieldRenderProps>): void {
+export function registerField(
+  fieldtype: FrappeFieldType,
+  component: ComponentType<FieldRenderProps>,
+): void {
   registry.set(fieldtype, component);
 }
 
@@ -955,6 +963,8 @@ export interface ChildTableFieldDef {
   hidden?: boolean | number;
   precision?: number;
   default?: string;
+  /** Per-row visibility, evaluated against the row with the parent doc in scope. */
+  depends_on?: string;
 }
 
 type TableColumnDef = {
@@ -1189,22 +1199,49 @@ function isVisibleChildField(f: ChildTableFieldDef): boolean {
   return !f.hidden && !TABLE_LAYOUT_TYPES.has(f.fieldtype) && !f.fieldtype.startsWith("Table");
 }
 
+function fieldToColumn(f: ChildTableFieldDef): TableColumnDef {
+  const mapped = fieldtypeToTableField(f.fieldtype, f.options);
+  return {
+    id: f.fieldname,
+    header: f.label || f.fieldname,
+    accessorKey: f.fieldname,
+    field: mapped.field,
+    fieldProps: mapped.fieldProps,
+    readOnly: !!f.read_only,
+  };
+}
+
 /** Build editable ChildTable columns from child DocType field defs. */
 export function childFieldsToColumns(fields: ChildTableFieldDef[]): TableColumnDef[] {
   const visible = fields.filter(isVisibleChildField);
   const flagged = visible.filter((f) => !!f.in_list_view);
   const source = flagged.length > 0 ? flagged : visible.slice(0, 8);
-  return source.map((f) => {
-    const mapped = fieldtypeToTableField(f.fieldtype, f.options);
-    return {
-      id: f.fieldname,
-      header: f.label || f.fieldname,
-      accessorKey: f.fieldname,
-      field: mapped.field,
-      fieldProps: mapped.fieldProps,
-      readOnly: !!f.read_only,
-    };
-  });
+  return source.map(fieldToColumn);
+}
+
+/** Every editable child field, for the row detail editor (desk's row form). */
+export function childFieldsToDetailColumns(fields: ChildTableFieldDef[]): TableColumnDef[] {
+  return fields.filter(isVisibleChildField).map(fieldToColumn);
+}
+
+/**
+ * Per-row cell visibility from child `depends_on`: the row is `doc`, the
+ * parent form doc is `parent`. Undefined when no child field declares one.
+ */
+export function childCellHidden(
+  fields: ChildTableFieldDef[],
+  parent?: DependsDoc,
+): ChildCellHidden | undefined {
+  const evaluators = new Map<string, DependsEvaluator>();
+  for (const f of fields) {
+    const evaluator = compileDependsOn(f.depends_on, true);
+    if (evaluator) evaluators.set(f.fieldname, evaluator);
+  }
+  if (evaluators.size === 0) return undefined;
+  return (row, columnId) => {
+    const evaluator = evaluators.get(columnId);
+    return evaluator ? !evaluator(row, parent) : false;
+  };
 }
 
 function defaultRowFromFields(fields: ChildTableFieldDef[]): Record<string, unknown> {
@@ -1305,11 +1342,31 @@ function TableAdapter(props: FieldRenderProps) {
     return undefined;
   }, [resolvedFields]);
 
+  const detailColumns = useMemo(
+    () =>
+      resolvedFields?.length
+        ? childFieldsToDetailColumns(resolvedFields as ChildTableFieldDef[])
+        : undefined,
+    [resolvedFields],
+  );
+
+  const parentDoc = props.parentDoc;
+  const isCellHidden = useMemo(
+    () =>
+      resolvedFields?.length
+        ? childCellHidden(resolvedFields as ChildTableFieldDef[], parentDoc)
+        : undefined,
+    [resolvedFields, parentDoc],
+  );
+
   return React.createElement(ChildTable, {
     label: props.label,
     value: Array.isArray(props.value) ? props.value : [],
     onChange: props.onChange,
     columns,
+    detailColumns: detailColumns?.length ? detailColumns : undefined,
+    rowDetail: true,
+    isCellHidden,
     defaultRow,
     disabled: props.disabled,
     error: props.error,

package/src/fields/Date/index.native.tsx

@@ -14,7 +14,7 @@ import {
   useFormField,
   useResolvedValidators,
 } from "@multiplatform.one/forms";
-import { useState } from "react";
+import { useContext, useState } from "react";
 import {
   Modal,
   Pressable,
@@ -23,6 +23,7 @@ import {
   useWindowDimensions,
   View as RNView,
 } from "react-native";
+import { SafeAreaInsetsContext, initialWindowMetrics } from "react-native-safe-area-context";
 import { platform } from "@multiplatform.one/platform";
 import DateTimePicker, { type DateTimePickerEvent } from "@react-native-community/datetimepicker";
 import { Text, View, XStack, YStack, useProps, useTheme, useThemeName } from "tamagui";
@@ -143,7 +144,8 @@ function DateField<
   // MPO-64 leftover: the sheet must end ABOVE the keyboard, not run under it.
   const keyboardInset = useKeyboardInset();
   const { height: windowHeight } = useWindowDimensions();
-  const maxHeight = dateSheetMaxHeight(windowHeight, keyboardInset);
+  const topInset = useContext(SafeAreaInsetsContext)?.top ?? initialWindowMetrics?.insets.top ?? 0;
+  const maxHeight = dateSheetMaxHeight(windowHeight, keyboardInset, topInset);
 
   const [showPicker, setShowPicker] = useState(false);
   const [showTimePicker, setShowTimePicker] = useState(false);