alinea 2.0.0-preview.13 → 2.0.0-preview.14

package/dist/dashboard/atoms/overview.js

@@ -148,10 +148,16 @@ function resolveOverviewOptions(config, overview, types, sort, options = {}) {
     filters: Object.entries(overview?.filters ?? {}).map(
       ([key, filter]) => filterState(key, filter)
     ),
+    tabs: Object.entries(overview?.tabs ?? {}).map(([key, tab]) => ({
+      key,
+      label: tab.label,
+      filter: tab.filter
+    })),
     sort,
     layout: overview?.layout,
     thumbnail: overview?.thumbnail ? selection(overview.thumbnail, typeNames) : void 0,
     actions: overview?.actions ?? [],
+    header: overview?.header,
     types: listed
   };
 }
@@ -181,17 +187,31 @@ function columnSorts(columns) {
     ] : []
   );
 }
-function filterState(key, filter) {
-  return {
+function filterOptions(options) {
+  return Object.entries(options).map(([key, option]) => ({
     key,
-    label: filter.label,
-    multiple: filter.multiple ?? false,
-    options: Object.entries(filter.options).map(([key2, option]) => ({
-      key: key2,
-      label: option.label,
-      filter: option.filter
-    }))
-  };
+    label: option.label,
+    filter: option.filter
+  }));
+}
+function filterState(key, filter) {
+  const base = { key, label: filter.label, multiple: filter.multiple ?? false };
+  const { options } = filter;
+  if (typeof options === "function")
+    return { ...base, options: [], load: options };
+  return { ...base, options: filterOptions(options) };
+}
+function hasFilterLoaders(overview) {
+  return overview.filters.some((filter) => filter.load);
+}
+async function loadFilterOptions(overview, context) {
+  if (!hasFilterLoaders(overview)) return overview;
+  const filters = await Promise.all(
+    overview.filters.map(
+      async ({ load, ...filter }) => load ? { ...filter, options: filterOptions(await load(context)) } : filter
+    )
+  );
+  return { ...overview, filters };
 }
 function customColumn(key, column, typeNames) {
   const select = column.select === void 0 ? void 0 : selection(column.select, typeNames);
@@ -209,6 +229,7 @@ function customColumn(key, column, typeNames) {
   };
 }
 function isSortable(value) {
+  if (isRecord(value) && "edge" in value) return value.count === true;
   if (!Overview.isPlainExpr(value)) return false;
   if (!hasField(value)) return true;
   const field = value;
@@ -219,7 +240,7 @@ function columnSortBy(column, select) {
   if (column.sortBy) return Overview.sortExpr(column.sortBy);
   if (!select) return void 0;
   if (select.all !== void 0)
-    return isSortable(select.all) ? select.all : void 0;
+    return isSortable(select.all) ? Overview.sortExpr(select.all) : void 0;
   const cases = Object.entries(select.byType ?? {});
   if (!cases.every(([, value]) => isSortable(value))) return void 0;
   return Overview.sortExpr(Object.fromEntries(cases));
@@ -321,8 +342,12 @@ function pickedFilters(overview, selection2) {
   }
   return picked;
 }
-function overviewFilter(overview, selection2) {
+function pickedTab(overview, tab) {
+  return overview.tabs.find((option) => option.key === tab) ?? overview.tabs[0];
+}
+function overviewFilter(overview, selection2, tab) {
   const picked = pickedFilters(overview, selection2);
+  const tabFilter = pickedTab(overview, tab)?.filter;
   const conditions = overview.filters.flatMap((filter) => {
     const options = filter.options.filter(
       (option) => picked[filter.key]?.includes(option.key)
@@ -331,6 +356,7 @@ function overviewFilter(overview, selection2) {
     if (options.length === 1) return [options[0].filter];
     return [{ or: options.map((option) => option.filter) }];
   });
+  if (tabFilter) conditions.unshift(tabFilter);
   if (conditions.length === 0) return void 0;
   if (conditions.length === 1) return conditions[0];
   return { and: conditions };
@@ -467,8 +493,10 @@ export {
   columnField,
   columnLinkIds,
   columnProjection,
+  hasFilterLoaders,
   linkedEntryId,
   loadColumnValues,
+  loadFilterOptions,
   loadOverviewParent,
   openEntryAtom,
   overviewEntry,
@@ -480,6 +508,7 @@ export {
   parentTypes,
   pickedFilters,
   pickedSort,
+  pickedTab,
   resolveOverview,
   resolveOverviewOptions,
   sortedColumn,

package/dist/dashboard/atoms/root.js

@@ -28,7 +28,12 @@ import {
   treeEntryAtoms
 } from "./entry.js";
 import { shaAtom } from "./graph.js";
-import { overviewSortAtom, pageAtom, routeAtom } from "./nav.js";
+import {
+  overviewSortAtom,
+  overviewTabAtom,
+  pageAtom,
+  routeAtom
+} from "./nav.js";
 import { policyAtom } from "./user.js";
 import {
   dashboardEntryDragItem,
@@ -409,6 +414,7 @@ var RootAtoms = class {
       {
         enableNavigation: true,
         sortState: overviewSortAtom(this.workspace, this.key, parentId),
+        tabState: overviewTabAtom(this.workspace, this.key, parentId),
         rootData: this.data,
         // The filters picked in this list, kept when the editor comes back to
         // it, like its sort, but not applied to the lists of other entries

package/dist/dashboard/boot/ActivityEvent.d.ts

@@ -1,4 +1,4 @@
-export type ActivityType = 'mutation' | 'upload';
+export type ActivityType = 'mutation' | 'upload' | 'sync';
 export type ActivityStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'blocked' | 'discarded' | 'cancelled';
 export interface Activity {
     id: string;

package/dist/dashboard/boot/Boot.js

@@ -10,6 +10,7 @@ import { App } from "../App.js";
 import { ActivityEvent } from "./ActivityEvent.js";
 import { DashboardWorker } from "./DashboardWorker.js";
 import { loadWorker } from "./LoadWorker.js";
+import { SyncEvent } from "./SyncEvent.js";
 import { WorkerDB } from "./WorkerDB.js";
 import { jsx } from "react/jsx-runtime";
 async function boot(gen) {
@@ -24,6 +25,9 @@ async function boot(gen) {
     into.id = "root";
     if (element.parentElement === document.head) document.body.append(into);
     else element.parentElement.replaceChild(into, element);
+    const html = document.documentElement;
+    if (!html.hasAttribute("data-alinea-theme"))
+      html.setAttribute("data-alinea-theme", "");
     const root = createRoot(into);
     let lastRevision;
     for await (const batch of gen) {
@@ -75,6 +79,8 @@ function listen(source) {
       events.dispatchEvent(new IndexEvent(data.data));
     } else if (data.type === ActivityEvent.type) {
       events.dispatchEvent(new ActivityEvent(data.activities));
+    } else if (data.type === SyncEvent.type) {
+      events.dispatchEvent(new SyncEvent(data.progress));
     }
   });
   return events;

package/dist/dashboard/boot/DashboardWorker.d.ts

@@ -11,6 +11,12 @@ export declare class DashboardWorker extends EventTarget {
     constructor(source?: Source);
     get db(): EntryStore | Promise<EntryStore>;
     sync(): Promise<string>;
+    /**
+     * Resolve once the dashboard can show content. Stored content shows right
+     * away and catches up with the remote as an activity; an empty store, or
+     * one whose cached content failed, waits for its first sync.
+     */
+    ready(): Promise<void>;
     sha(): Promise<string>;
     queue(id: string, mutations: Array<Mutation>): Promise<string>;
     retryActivity(): Promise<void>;

package/dist/dashboard/boot/DashboardWorker.js

@@ -5,6 +5,7 @@ import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/boot/DashboardWorker.ts
 import { Entry } from "alinea/core/Entry";
+import { createId } from "alinea/core/Id";
 import { getScope } from "alinea/core/Scope";
 import { trigger } from "alinea/core/Trigger";
 import { IndexEvent } from "alinea/core/db/IndexEvent";
@@ -17,9 +18,11 @@ import { EntryStore } from "alinea/database/EntryStore";
 import {
   ActivityEvent
 } from "./ActivityEvent.js";
+import { SyncEvent } from "./SyncEvent.js";
 var remote = pLimit(1);
 var cacheName = "alinea-entry-database";
 var syncInterval = 12e4;
+var progressInterval = 100;
 var activityHistoryLimit = 100;
 var DashboardWorker = class extends EventTarget {
   #source;
@@ -57,6 +60,57 @@ var DashboardWorker = class extends EventTarget {
       throw error;
     }
   }
+  /**
+   * Resolve once the dashboard can show content. Stored content shows right
+   * away and catches up with the remote as an activity; an empty store, or
+   * one whose cached content failed, waits for its first sync.
+   */
+  async ready() {
+    const loaded = await this.#nextLoad;
+    if (!loaded.stored) return void await this.sync();
+    loaded.caughtUp ??= this.#catchUp();
+  }
+  #catchUp() {
+    const activity = {
+      id: createId(),
+      type: "sync",
+      status: "running",
+      operations: [{ op: "sync" }],
+      startedAt: Date.now()
+    };
+    this.#activities.unshift(activity);
+    return this.#syncActivities([activity]);
+  }
+  async #syncActivities(activities) {
+    for (const activity of activities) {
+      activity.status = "running";
+      activity.finishedAt = void 0;
+      activity.error = void 0;
+    }
+    this.#emitActivity();
+    try {
+      await this.sync();
+    } catch (error) {
+      for (const activity of activities)
+        if (activity.status === "running") this.#failActivity(activity, error);
+      this.#startSyncing();
+    }
+  }
+  /** Content that synced is caught up: settle the catch-up activities. */
+  #settleSyncs() {
+    const syncs = this.#activities.filter(
+      (activity) => activity.type === "sync" && (activity.status === "running" || activity.status === "failed")
+    );
+    if (syncs.length === 0) return;
+    const finishedAt = Date.now();
+    for (const activity of syncs) {
+      activity.status = "succeeded";
+      activity.finishedAt = finishedAt;
+      activity.error = void 0;
+    }
+    this.#trimActivities();
+    this.#emitActivity();
+  }
   async #syncLoaded(load) {
     const loaded = await load;
     const { db, client } = loaded;
@@ -127,6 +181,10 @@ Remote updates: ${remote2}`
     });
   }
   async retryActivity() {
+    const syncs = this.#activities.filter(
+      (activity) => activity.type === "sync" && activity.status === "failed"
+    );
+    if (syncs.length > 0) await this.#syncActivities(syncs);
     if (this.#blocked) await this.#retryMutations();
   }
   async #retryMutations() {
@@ -191,13 +249,16 @@ Remote updates: ${remote2}`
           await this.#syncWithClient(db, client);
         this.#completeMutation(item);
       } catch (error) {
-        this.#blocked = true;
-        this.#failActivity(item.activity, error);
+        let revision;
         try {
-          await this.#syncWithClient(db, client);
-          item.sha = void 0;
+          revision = await this.#syncWithClient(db, client);
         } catch {
         }
+        if (revision && revision === item.sha)
+          return this.#completeMutation(item);
+        this.#blocked = true;
+        this.#failActivity(item.activity, error);
+        if (revision) item.sha = void 0;
       }
     });
   }
@@ -228,7 +289,21 @@ Remote updates: ${remote2}`
     this.dispatchEvent(new ActivityEvent(this.activities()));
   }
   async #syncWithClient(db, client) {
-    return db.syncWith(client, { validate: false });
+    let reported = 0;
+    const onProgress = (progress) => {
+      const now = Date.now();
+      const done = progress.loaded >= progress.total;
+      if (!done && now - reported < progressInterval) return;
+      reported = now;
+      this.dispatchEvent(new SyncEvent(progress));
+    };
+    try {
+      const revision = await db.syncWith(client, { validate: false, onProgress });
+      this.#settleSyncs();
+      return revision;
+    } finally {
+      if (reported) this.dispatchEvent(new SyncEvent());
+    }
   }
   #failActivity(activity, error) {
     activity.status = "failed";
@@ -241,7 +316,7 @@ Remote updates: ${remote2}`
     for (let index = this.#activities.length - 1; excess > 0; index--) {
       if (index < 0) break;
       const activity = this.#activities[index];
-      if (activity.status === "pending" || activity.status === "running" || activity.status === "blocked" || activity.type === "mutation" && activity.status === "failed")
+      if (activity.status === "pending" || activity.status === "running" || activity.status === "blocked" || activity.status === "failed")
         continue;
       this.#activities.splice(index, 1);
       excess -= 1;
@@ -291,12 +366,18 @@ Remote updates: ${remote2}`
         db = await this.#open(config, revision, true);
         cacheFailure = await this.#syncLocalIndex(db);
       }
-      if (hadPrevious && (await db.source.getTree()).isEmpty)
+      const empty = (await db.source.getTree()).isEmpty;
+      if (hadPrevious && empty)
         await this.#syncWithClient(db, client).catch(() => {
         });
       this.#localDB = db;
       this.#localClient = client;
-      nextLoad.resolve({ db, client, cacheFailure });
+      nextLoad.resolve({
+        db,
+        client,
+        cacheFailure,
+        stored: !cacheFailure && !empty
+      });
       const unsubscribe = db.onChange((change) => {
         this.dispatchEvent(
           new IndexEvent({

package/dist/dashboard/boot/LoadWorker.js

@@ -7,6 +7,7 @@ import "../../chunks/chunk-CQ52GEHY.js";
 import { IndexEvent } from "alinea/core/db/IndexEvent";
 import { ActivityEvent } from "./ActivityEvent.js";
 import { DashboardWorker } from "./DashboardWorker.js";
+import { SyncEvent } from "./SyncEvent.js";
 async function loadWorker(gen) {
   const worker = new DashboardWorker();
   function forward(target) {
@@ -16,10 +17,12 @@ async function loadWorker(gen) {
       } catch {
         worker.removeEventListener(IndexEvent.type, listen);
         worker.removeEventListener(ActivityEvent.type, listen);
+        worker.removeEventListener(SyncEvent.type, listen);
       }
     };
     worker.addEventListener(IndexEvent.type, listen);
     worker.addEventListener(ActivityEvent.type, listen);
+    worker.addEventListener(SyncEvent.type, listen);
   }
   if ("onconnect" in globalThis) {
     addEventListener("connect", (event) => {

package/dist/dashboard/boot/SyncEvent.d.ts

@@ -0,0 +1,7 @@
+import type { SyncProgress } from 'alinea/core/db/LocalStore';
+/** Progress of a sync from the remote, without progress once it finished. */
+export declare class SyncEvent extends Event {
+    progress?: SyncProgress | undefined;
+    static readonly type = "sync";
+    constructor(progress?: SyncProgress | undefined);
+}

package/dist/dashboard/boot/SyncEvent.js

@@ -0,0 +1,14 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/boot/SyncEvent.ts
+var SyncEvent = class _SyncEvent extends Event {
+  constructor(progress) {
+    super(_SyncEvent.type);
+    this.progress = progress;
+  }
+  progress;
+  static type = "sync";
+};
+export {
+  SyncEvent
+};

package/dist/dashboard/boot/WorkerDB.d.ts

@@ -16,6 +16,7 @@ export declare class WorkerDB extends WriteableGraph {
         sha: string;
     }>;
     resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
+    ready(): Promise<void>;
     sync(): Promise<string>;
     get sha(): Promise<string>;
     referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;

package/dist/dashboard/boot/WorkerDB.js

@@ -25,6 +25,9 @@ var WorkerDB = class extends WriteableGraph {
     const body = scope.stringify(query);
     return this.#worker.resolve(body);
   }
+  ready() {
+    return this.#worker.ready();
+  }
   sync() {
     return this.#worker.sync();
   }

package/dist/dashboard/cms/EntryTable.d.ts

@@ -1,4 +1,4 @@
-import type { EntryFields } from 'alinea/core/EntryFields';
+import type { EntryFilterFields } from 'alinea/core/EntryFields';
 import type { OpenFilter } from 'alinea/core/Filter';
 import type { OrderBy } from 'alinea/core/OrderBy';
 import type { OverviewColumn, OverviewOptions } from 'alinea/core/Overview';
@@ -11,9 +11,10 @@ export interface EntryTableProps {
     type?: Type | Array<Type>;
     /**
      * Only list entries matching this filter, like the `filter` of a query,
-     * eg. `{brand: {has: {_entry: entryId}}}`
+     * eg. `{brand: {has: {_entry: entryId}}}` or
+     * `{_referenced: Query.referencedBy({type: Product})}`
      */
-    filter?: OpenFilter<EntryFields>;
+    filter?: OpenFilter<EntryFilterFields>;
     /** Only list entries of this workspace */
     workspace?: string;
     /** Only list entries of this root */

package/dist/dashboard/cms/EntryTable.js

@@ -66,9 +66,9 @@ import {
 var EntryTable_default = {
   "EntryTable-loading": "alinea-EntryTable-loading",
   "EntryTableLoading": "alinea-EntryTable-loading",
-  "EntryTable": "alinea-EntryTable",
   "EntryTable-table": "alinea-EntryTable-table",
-  "EntryTableTable": "alinea-EntryTable-table"
+  "EntryTableTable": "alinea-EntryTable-table",
+  "EntryTable": "alinea-EntryTable"
 };
 
 // src/dashboard/cms/EntryTable.tsx

package/dist/dashboard/cms/ViewProps.d.ts

@@ -24,8 +24,9 @@ export interface SectionViewProps {
     section: Section;
 }
 /**
- * Props of the component a type points to with `view`. It replaces the
- * default entry editor for entries of that type.
+ * Props of the component a type points to with `view`. It replaces the form
+ * of entries of that type below the entry header, the field hooks edit the
+ * fields of the entry.
  */
 export interface TypeViewProps {
     /** The type of the entry being shown */

package/dist/dashboard/cms/hooks.d.ts

@@ -2,13 +2,15 @@
  * The hooks of custom field and dashboard views, exported from `alinea/cms`.
  * Their types do not expose the internal state of the dashboard.
  */
+import type { DashboardEntry } from 'alinea/core/DashboardEntry';
 import type { WriteableGraph } from 'alinea/core/db/WriteableGraph';
-import type { Entry as EntryRecord } from 'alinea/core/Entry';
+import type { Entry } from 'alinea/core/Entry';
 import type { Field } from 'alinea/core/Field';
 import type { PreviewMetadata } from 'alinea/core/Preview';
 import type { Policy } from 'alinea/core/Role';
 import type { User } from 'alinea/core/User';
 import { type Dispatch, type SetStateAction } from 'react';
+import type { DashboardLocation } from '../Href.js';
 /**
  * Returns the permissions of the signed-in user. Check access with
  * `policy.get({workspace, root, id, ...})`, which returns flags such as
@@ -32,8 +34,24 @@ export declare function usePreviewMetadata(): PreviewMetadata | undefined;
 /**
  * Returns the stored value of a field in the entry, list row or object being
  * edited. Use it in a view that only reads the value.
+ *
+ * The field-based hooks (`useFieldValue`, `useField`, `useFieldSetter`, ...)
+ * also read the fields around a custom field: pass a field of the same row,
+ * of a parent row or of the entry, and it resolves in the nearest scope that
+ * holds it. Import the type from your schema or pass the field through the
+ * options of your field.
+ *
+ * A view shared by types that each define their own field can pass its key
+ * instead, which reads the field of the same row, untyped.
+ *
+ * @example
+ * // In the view of a field inside a list row of `BlogPost`
+ * const title = useFieldValue(BlogPost.title) // a field of the entry
+ * const price = useFieldValue(options.price) // a field passed as option
+ * const path = useFieldValue('path') // the path field of this type
  */
 export declare function useFieldValue<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): StoredValue;
+export declare function useFieldValue(key: string): unknown;
 /**
  * Returns the stored value of a field and a setter, like `useState`. The
  * setter also accepts an updater function that receives the current value.
@@ -66,39 +84,37 @@ export declare function useFieldError<StoredValue, QueryValue, Mutator, Options>
 /**
  * Returns the stored value of another field in the same entry, list row or
  * object, by its key.
+ *
+ * @deprecated Use `useFieldValue`: pass the field, which is typed and also
+ * reads fields of a parent row or the entry (`useFieldValue(BlogPost.title)`),
+ * or its key (`useFieldValue('title')`).
  */
 export declare function useSiblingFieldValue(key: string): unknown;
 /**
- * Returns the selected entry version as a plain Entry object.
+ * Returns the entry being edited, in the selected locale and version.
+ * `entry.data` holds the field values as saved: use `useFieldValue(field)`
+ * for the live value while the editor changes it.
  *
- * Returns null outside an entry scope, or when the current entry cannot be
- * resolved. The returned value follows locale/status selection and does not
- * expose internal atoms.
+ * Returns null outside an entry, eg. in a root view.
  */
-export declare function useEntry(): EntryRecord<Record<string, unknown>> | null;
+export declare function useEntry(): DashboardEntry | null;
+/** @internal */
+export declare function dashboardEntry(entry: Entry): DashboardEntry;
 /**
  * Returns the current locale of the dashboard: the locale of the entry being
  * edited, or the selected locale of the current root. `null` for content
  * without translations or outside the dashboard layout.
  */
 export declare function useLocale(): string | null;
-/** A place in the dashboard to navigate to */
-export interface DashboardLocation {
-    /** Name of the workspace */
-    workspace: string;
-    /** Name of the root */
-    root: string;
-    /** Id of the entry to open, leave out to open the root */
-    entryId?: string;
-    /** Locale to open, for roots with translations */
-    locale?: string | null;
-}
 /**
  * Returns a function that navigates the dashboard to an entry or root. The
  * user is asked to confirm first when the current entry has unsaved changes.
+ * An entry can be opened by its id alone, its workspace and root are looked
+ * up.
  *
  * @example
  * const navigate = useNavigate()
- * navigate({workspace: entry.workspace, root: entry.root, entryId: entry.id})
+ * navigate({entryId: post.id, locale: 'en'})
+ * navigate({workspace: 'main', root: 'pages'})
  */
 export declare function useNavigate(): (location: DashboardLocation) => void;

package/dist/dashboard/cms/hooks.js

@@ -9,7 +9,8 @@ import "../../chunks/chunk-CQ52GEHY.js";
 import { assert } from "alinea/core/util/Assert";
 import {
   useCallback,
-  useContext
+  useContext,
+  useMemo
 } from "react";
 import { graphAtom } from "../atoms/core.js";
 import { routeAtom } from "../atoms/nav.js";
@@ -19,8 +20,7 @@ import {
   dashboardContext,
   entryContext,
   useEditor,
-  useFieldInfo,
-  useFieldNode
+  useFieldInfo
 } from "../contexts.js";
 function usePolicy() {
   return useAtomValueRaw(policyAtom);
@@ -35,8 +35,13 @@ function usePreviewMetadata() {
   return useAtomValueRaw(previewMetadataAtom);
 }
 function useFieldValue(field) {
-  const node = useFieldNode(field);
-  return useAtomValueRaw(node.value);
+  const editor = useEditor();
+  const info = typeof field === "string" ? editor.field(field) : editor.get(field);
+  assert(
+    info,
+    `Field not found: ${typeof field === "string" ? field : "field"}`
+  );
+  return useAtomValueRaw(info.value);
 }
 function useField(field) {
   const info = useFieldInfo(field);
@@ -61,14 +66,26 @@ function useFieldError(field) {
   return useAtomValueRaw(info.error);
 }
 function useSiblingFieldValue(key) {
-  const editor = useEditor();
-  const info = editor.field(key);
-  assert(info, `Field not found: ${key}`);
-  return useAtomValueRaw(info.value);
+  return useFieldValue(key);
 }
 function useEntry() {
-  const scope = useContext(entryContext);
-  return scope?.selectedEntry ?? null;
+  const selected = useContext(entryContext)?.selectedEntry;
+  return useMemo(() => selected ? dashboardEntry(selected) : null, [selected]);
+}
+function dashboardEntry(entry) {
+  return {
+    id: entry.id,
+    type: entry.type,
+    title: entry.title,
+    path: entry.path,
+    url: entry.url,
+    locale: entry.locale,
+    status: entry.status,
+    workspace: entry.workspace,
+    root: entry.root,
+    parentId: entry.parentId,
+    data: entry.data
+  };
 }
 function useLocale() {
   const entry = useContext(entryContext);
@@ -76,20 +93,28 @@ function useLocale() {
   if (entry) return entry.localeData.requestedLocale;
   return dashboard?.page.locale ?? null;
 }
+function dashboardRoute(location) {
+  const locale = location.locale ?? void 0;
+  if (location.entryId && !location.workspace && !location.root)
+    return { page: "edit", entry: location.entryId, locale, view: location.view };
+  return {
+    page: "entry",
+    workspace: location.workspace,
+    root: location.root,
+    entry: location.entryId,
+    locale,
+    view: location.view
+  };
+}
 function useNavigate() {
   const setRoute = useSetAtom(routeAtom);
   return useCallback(
-    (location) => setRoute({
-      page: "entry",
-      workspace: location.workspace,
-      root: location.root,
-      entry: location.entryId,
-      locale: location.locale ?? void 0
-    }),
+    (location) => setRoute(dashboardRoute(location)),
     [setRoute]
   );
 }
 export {
+  dashboardEntry,
   useEntry,
   useField,
   useFieldError,

package/dist/dashboard/contexts.d.ts

@@ -49,10 +49,11 @@ export declare const editorContext: import("react").Context<EditorModel | null>;
  */
 export declare function useEditor(): EditorModel;
 /**
- * Returns the editor metadata for a field in the active editor scope.
+ * Returns the editor metadata for a field in the active editor scope, or in
+ * the scope of a parent row or the entry when the field belongs there.
  */
 export declare function useFieldInfo(field: Field): import("./atoms/editor.js").EditorField;
 /**
- * Returns the reactive node backing a field in the active editor.
+ * Returns the reactive node backing a field in the editor it belongs to.
  */
 export declare function useFieldNode<Value>(field: Field): ReactiveNode<Value>;