alinea 2.0.0-preview.0 → 2.0.0-preview.10

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

@@ -0,0 +1,21 @@
+import type { FieldSharedProps, StyleProps } from 'alinea/components/types';
+import type { Field } from 'alinea/core/Field';
+import type { ReactNode } from 'react';
+export interface FieldChromeProps extends FieldSharedProps, StyleProps {
+    /** The field whose label, help text, validation error and state to show */
+    field: Field;
+    /** Id of the control the label describes */
+    htmlFor?: string;
+    children?: ReactNode;
+}
+/**
+ * Renders the label, help text, shared badge and validation error of a field
+ * around a custom control, like the built-in fields. The values come from the
+ * field's options and validation state; pass a prop to override one.
+ *
+ * @example
+ * <FieldChrome field={field} htmlFor={id}>
+ *   <input id={id} type="range" />
+ * </FieldChrome>
+ */
+export declare function FieldChrome({ field, children, ...props }: FieldChromeProps): import("react").JSX.Element;

package/dist/dashboard/cms/FieldChrome.js

@@ -0,0 +1,26 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/cms/FieldChrome.tsx
+import { Field as FieldFrame } from "alinea/components/Field";
+import { useFieldError, useFieldOptions } from "../hooks.js";
+import { jsx } from "react/jsx-runtime";
+function FieldChrome({ field, children, ...props }) {
+  const options = useFieldOptions(field);
+  const error = useFieldError(field);
+  return /* @__PURE__ */ jsx(
+    FieldFrame,
+    {
+      label: options.label,
+      description: options.help,
+      error,
+      required: options.required,
+      readOnly: options.readOnly,
+      shared: options.shared,
+      ...props,
+      children
+    }
+  );
+}
+export {
+  FieldChrome
+};

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

@@ -0,0 +1,41 @@
+import type { Field } from 'alinea/core/Field';
+import type { RootData } from 'alinea/core/Root';
+import type { Section } from 'alinea/core/Section';
+import type { Type } from 'alinea/core/Type';
+/**
+ * Props of the component a field points to with `view`, for example in
+ * `Field.create({label, options, view: '@/fields/Range.view'})`.
+ *
+ * @example
+ * export default function RangeView({field}: FieldViewProps<RangeField>) {
+ *   const [value, setValue] = useField(field)
+ * }
+ */
+export interface FieldViewProps<F extends Field = Field> {
+    /** The field being rendered, pass it to the field hooks */
+    field: F;
+}
+/**
+ * Props of the component passed to `Field.view(...)`, rendered between the
+ * fields of a type.
+ */
+export interface SectionViewProps {
+    /** The section that holds the view */
+    section: Section;
+}
+/**
+ * Props of the component a type points to with `view`. It replaces the
+ * default entry editor for entries of that type.
+ */
+export interface TypeViewProps {
+    /** The type of the entry being shown */
+    type: Type;
+}
+/**
+ * Props of the component a root points to with `view`. It replaces the
+ * default root overview.
+ */
+export interface RootViewProps {
+    /** The configuration of the root, including its `label` */
+    root: RootData;
+}

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

@@ -0,0 +1,104 @@
+/**
+ * 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 { WriteableGraph } from 'alinea/core/db/WriteableGraph';
+import type { Entry as EntryRecord } 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';
+/**
+ * Returns the permissions of the signed-in user. Check access with
+ * `policy.get({workspace, root, id, ...})`, which returns flags such as
+ * `read`, `update` and `publish`.
+ */
+export declare function usePolicy(): Policy;
+/**
+ * Returns the authenticated dashboard user, or null when no user is active.
+ */
+export declare function useUser(): User | null;
+/**
+ * Returns the dashboard's content graph. Query it with the same API as the
+ * `cms` instance, for example `graph.find({type: Article})`. Changes made
+ * through it are committed with the permissions of the signed-in user.
+ */
+export declare function useGraph(): WriteableGraph;
+/**
+ * Returns metadata reported by the active browser preview, when available.
+ */
+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.
+ */
+export declare function useFieldValue<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): StoredValue;
+/**
+ * Returns the stored value of a field and a setter, like `useState`. The
+ * setter also accepts an updater function that receives the current value.
+ *
+ * @example
+ * const [value, setValue] = useField(field)
+ */
+export declare function useField<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): [StoredValue, Dispatch<SetStateAction<StoredValue>>];
+/**
+ * Returns only the setter of a field's stored value, so the component does
+ * not re-render when the value changes.
+ */
+export declare function useFieldSetter<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): Dispatch<SetStateAction<StoredValue>>;
+/**
+ * Returns the key a field is stored under in the entry, list row or object
+ * being edited, for example `'title'`.
+ */
+export declare function useFieldKey<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): string;
+/**
+ * Returns the options of a field with the dashboard state applied: `readOnly`
+ * is also `true` when the user may not edit the field or the entry, and
+ * `hidden` reflects the user's permissions. Includes the field's `label`.
+ */
+export declare function useFieldOptions<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): Options;
+/**
+ * Returns the validation message of a field (from `required` or `validate`),
+ * or `undefined` while the value is valid.
+ */
+export declare function useFieldError<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): string | undefined;
+/**
+ * Returns the stored value of another field in the same entry, list row or
+ * object, by its key.
+ */
+export declare function useSiblingFieldValue(key: string): unknown;
+/**
+ * Returns the selected entry version as a plain Entry object.
+ *
+ * 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.
+ */
+export declare function useEntry(): EntryRecord<Record<string, unknown>> | null;
+/**
+ * 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.
+ *
+ * @example
+ * const navigate = useNavigate()
+ * navigate({workspace: entry.workspace, root: entry.root, entryId: entry.id})
+ */
+export declare function useNavigate(): (location: DashboardLocation) => void;

package/dist/dashboard/cms/hooks.js

@@ -0,0 +1,107 @@
+import {
+  useAtomValueRaw,
+  useSetAtom
+} from "../../chunks/chunk-D6UJHBJJ.js";
+import "../../chunks/chunk-CFNRVI3Y.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/cms/hooks.ts
+import { assert } from "alinea/core/util/Assert";
+import {
+  useCallback,
+  useContext
+} from "react";
+import { graphAtom } from "../atoms/core.js";
+import { routeAtom } from "../atoms/nav.js";
+import { previewMetadataAtom } from "../atoms/preview.js";
+import { policyAtom, userAtom } from "../atoms/user.js";
+import {
+  dashboardContext,
+  entryContext,
+  useEditor,
+  useFieldInfo,
+  useFieldNode
+} from "../contexts.js";
+function usePolicy() {
+  return useAtomValueRaw(policyAtom);
+}
+function useUser() {
+  return useAtomValueRaw(userAtom);
+}
+function useGraph() {
+  return useAtomValueRaw(graphAtom);
+}
+function usePreviewMetadata() {
+  return useAtomValueRaw(previewMetadataAtom);
+}
+function useFieldValue(field) {
+  const node = useFieldNode(field);
+  return useAtomValueRaw(node.value);
+}
+function useField(field) {
+  const info = useFieldInfo(field);
+  const value = useAtomValueRaw(info.value);
+  const setValue = useSetAtom(info.value);
+  return [value, setValue];
+}
+function useFieldSetter(field) {
+  const info = useFieldInfo(field);
+  return useSetAtom(info.value);
+}
+function useFieldKey(field) {
+  const info = useFieldInfo(field);
+  return info.key;
+}
+function useFieldOptions(field) {
+  const info = useFieldInfo(field);
+  return useAtomValueRaw(info.options);
+}
+function useFieldError(field) {
+  const info = useFieldInfo(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);
+}
+function useEntry() {
+  const scope = useContext(entryContext);
+  return scope?.selectedEntry ?? null;
+}
+function useLocale() {
+  const entry = useContext(entryContext);
+  const dashboard = useContext(dashboardContext);
+  if (entry) return entry.localeData.requestedLocale;
+  return dashboard?.page.locale ?? null;
+}
+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
+    }),
+    [setRoute]
+  );
+}
+export {
+  useEntry,
+  useField,
+  useFieldError,
+  useFieldKey,
+  useFieldOptions,
+  useFieldSetter,
+  useFieldValue,
+  useGraph,
+  useLocale,
+  useNavigate,
+  usePolicy,
+  usePreviewMetadata,
+  useSiblingFieldValue,
+  useUser
+};

package/dist/dashboard/contexts.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The contexts the dashboard hooks read, see `hooks.tsx`
+ *
+ * @internal
+ */
+import type { Config } from 'alinea/core/Config';
+import type { LocalConnection } from 'alinea/core/Connection';
+import type { WriteableGraph } from 'alinea/core/db/WriteableGraph';
+import type { Entry as EntryRecord } from 'alinea/core/Entry';
+import type { Field } from 'alinea/core/Field';
+import type { WorkspaceInternal } from 'alinea/core/Workspace';
+import { type ComponentType } from 'react';
+import type { EditorModel, ResolvedEditorImage } from './atoms/editor.js';
+import type { EntryAtoms, EntryLocaleAtoms } from './atoms/entry.js';
+import type { Page } from './atoms/nav.js';
+import type { ReactiveNode } from './atoms/ReactiveNode.js';
+import type { RootAtoms } from './atoms/root.js';
+export interface EntryContextValue {
+    entry: EntryAtoms;
+    localeData: EntryLocaleAtoms;
+    richTextImages: ReadonlyMap<string, ResolvedEditorImage>;
+    selectedEntry: EntryRecord<Record<string, unknown>>;
+}
+export interface DashboardOptions {
+    alineaDev?: boolean;
+    local?: boolean;
+}
+export interface Dashboard {
+    graph: WriteableGraph;
+    config: Config;
+    events: EventTarget;
+    client: LocalConnection;
+    views?: Record<string, ComponentType>;
+    options?: DashboardOptions;
+}
+export interface DashboardContextValue {
+    page: Page;
+    workspace: WorkspaceInternal & {
+        name: string;
+    };
+    root: RootAtoms;
+}
+export declare const entryContext: import("react").Context<EntryContextValue | null>;
+export declare const dashboardContext: import("react").Context<DashboardContextValue | null>;
+export declare const dashboardModelContext: import("react").Context<Dashboard | null>;
+export declare const editorContext: import("react").Context<EditorModel | null>;
+/**
+ * Returns the active dashboard editor from the nearest editor scope.
+ */
+export declare function useEditor(): EditorModel;
+/**
+ * Returns the editor metadata for a field in the active editor scope.
+ */
+export declare function useFieldInfo(field: Field): import("./atoms/editor.js").EditorField;
+/**
+ * Returns the reactive node backing a field in the active editor.
+ */
+export declare function useFieldNode<Value>(field: Field): ReactiveNode<Value>;

package/dist/dashboard/contexts.js

@@ -0,0 +1,42 @@
+import {
+  useAtomValueRaw
+} from "../chunks/chunk-D6UJHBJJ.js";
+import "../chunks/chunk-CFNRVI3Y.js";
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/contexts.ts
+import { assert } from "alinea/core/util/Assert";
+import { createContext, useContext } from "react";
+var entryContext = createContext(null);
+var dashboardContext = createContext(
+  null
+);
+var dashboardModelContext = createContext(null);
+var editorContext = createContext(null);
+function useEditor() {
+  const editor = useContext(editorContext);
+  assert(editor, "EntryEditor not found in context");
+  return editor;
+}
+function useFieldInfo(field) {
+  const editor = useEditor();
+  const info = editor.get(field);
+  assert(info, "Field info not found in editor");
+  return info;
+}
+function useFieldNode(field) {
+  const { key } = useFieldInfo(field);
+  const editor = useEditor();
+  const nodes = useAtomValueRaw(editor.node.nodes);
+  assert(nodes[key], `Node not found for field key: ${key}`);
+  return nodes[key];
+}
+export {
+  dashboardContext,
+  dashboardModelContext,
+  editorContext,
+  entryContext,
+  useEditor,
+  useFieldInfo,
+  useFieldNode
+};

package/dist/dashboard/editor/UseField.d.ts

@@ -1,4 +1,9 @@
 import { Field, type FieldOptions } from 'alinea/core/Field';
+/**
+ * The result of the deprecated object-returning `useField`.
+ *
+ * @deprecated Use the tuple `useField` from 'alinea/cms'.
+ */
 export interface UseFieldResult<StoredValue, Mutator, Options> {
     fieldKey: string;
     label: string;
@@ -8,26 +13,44 @@ export interface UseFieldResult<StoredValue, Mutator, Options> {
     error: string | undefined;
 }
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ * Also accepts the field's key instead of the field.
+ *
+ * @deprecated Use the tuple `useField` from 'alinea/cms' (`const [value, setValue] = useField(field)`) with `useFieldOptions` and `useFieldError`.
  */
 export declare function useField<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options> | string): UseFieldResult<StoredValue, Mutator, Options>;
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ * Also accepts the field's key instead of the field.
+ *
+ * @deprecated Use `useFieldKey` from 'alinea/cms'.
  */
 export declare function useFieldKey<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options> | string): string;
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ * Also accepts the field's key instead of the field.
+ *
+ * @deprecated Use `useFieldOptions` from 'alinea/cms'.
  */
 export declare function useFieldOptions<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options> | string): Options & FieldOptions<StoredValue>;
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ * Also accepts the field's key instead of the field.
+ *
+ * @deprecated Use `useFieldError` from 'alinea/cms'.
  */
 export declare function useFieldError<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options> | string): string | undefined;
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ * Also accepts the field's key instead of the field.
+ *
+ * @deprecated Use `useFieldValue` from 'alinea/cms'.
  */
 export declare function useFieldValue<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options> | string): StoredValue;
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ * Also accepts the field's key instead of the field.
+ *
+ * @deprecated Use `useFieldSetter` from 'alinea/cms'.
  */
 export declare function useFieldMutator<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options> | string): Mutator;

package/dist/dashboard/editor/UseField.js

@@ -1,8 +1,8 @@
 import {
-  useAtomValue,
+  useAtomValueRaw,
   useSetAtom
-} from "../../chunks/chunk-U4VOHNR2.js";
-import "../../chunks/chunk-Y7XOMJOC.js";
+} from "../../chunks/chunk-D6UJHBJJ.js";
+import "../../chunks/chunk-CFNRVI3Y.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/editor/UseField.ts
@@ -36,15 +36,15 @@ function useFieldKey(field) {
 }
 function useFieldOptions(field) {
   const info = useFieldInfo(field);
-  return useAtomValue(info.options);
+  return useAtomValueRaw(info.options);
 }
 function useFieldError(field) {
   const info = useFieldInfo(field);
-  return useAtomValue(info.error);
+  return useAtomValueRaw(info.error);
 }
 function useFieldValue(field) {
   const info = useFieldInfo(field);
-  return useAtomValue(info.value);
+  return useAtomValueRaw(info.value);
 }
 function useFieldMutator(field) {
   const info = useFieldInfo(field);

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

@@ -73,12 +73,12 @@ export declare const cms: import("../../adapter/core/cms.js").CoreCMS<{
                 heading: string;
                 text: string;
                 snippet: string;
-            } & import("../../core/ListRow.js").ListRow, {
+            } & import("alinea").ListRow, {
                 _type: "callout";
                 heading: string;
                 text: string;
                 snippet: string;
-            } & import("../../core/ListRow.js").ListRow, import("../../field/list.js").ListOptions<{
+            } & import("alinea").ListRow, import("../../field/list.js").ListOptions<{
                 callout: import("alinea").Type<{
                     heading: import("../../field/text.js").TextField;
                     text: import("../../field/text.js").TextField;
@@ -112,5 +112,17 @@ export declare const cms: import("../../adapter/core/cms.js").CoreCMS<{
             pages: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
             media: import("../../core/media/MediaRoot.js").MediaRoot<import("../../core/Root.js").ChildrenDefinition>;
         }>;
+        manyRoots: import("alinea").Workspace<{
+            pages: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            articles: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            documentation: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            campaigns: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            translations: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            archive: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            settings: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            brandAssets: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            nestedContent: import("alinea").Root<import("../../core/Root.js").ChildrenDefinition>;
+            media: import("../../core/media/MediaRoot.js").MediaRoot<import("../../core/Root.js").ChildrenDefinition>;
+        }>;
     };
 }>;

package/dist/dashboard/fixture/cms.js

@@ -4,10 +4,17 @@ import "../../chunks/chunk-CQ52GEHY.js";
 import { createCMS } from "alinea/core";
 import { Config, Field } from "alinea/index";
 import {
+  IcOutlineFolder,
   IcOutlineGridView,
+  IcOutlineSettings,
+  IcRoundDescription,
   IcRoundHistory,
+  IcRoundImage,
+  IcRoundLanguage,
+  IcRoundPublic,
   IcRoundTranslate,
-  MiLayers
+  MiLayers,
+  LucideFolder
 } from "../icons.js";
 var Page = Config.document("Page", {
   contains: ["Page", "Folder"],
@@ -116,10 +123,7 @@ var Page = Config.document("Page", {
     publishDate: Field.date("Publish date", {
       width: 1 / 3
     }),
-    publishTime: Field.time("Publish time", {
-      width: 1 / 3,
-      step: 900
-    }),
+    publishTime: Field.time("Publish time", { width: 1 / 3 }),
     relatedLink: Field.link("Related link"),
     resources: Field.link.multiple("Resources"),
     inner: Field.object("Testje", {
@@ -214,6 +218,49 @@ var statuses = Config.workspace("Statuses", {
     media: Config.media()
   }
 });
+var manyRoots = Config.workspace("Many roots", {
+  source: "content/manyRoots",
+  icon: LucideFolder,
+  roots: {
+    pages: Config.root("Pages", {
+      contains: ["Page", "Folder"],
+      openByDefault: true
+    }),
+    articles: Config.root("Articles", {
+      contains: ["Page", "Folder"],
+      icon: IcRoundDescription
+    }),
+    documentation: Config.root("Documentation", {
+      contains: ["Page", "Folder"],
+      icon: IcOutlineFolder
+    }),
+    campaigns: Config.root("Campaigns", {
+      contains: ["Page", "Folder"],
+      icon: IcRoundPublic
+    }),
+    translations: Config.root("Translations", {
+      contains: ["Page", "Folder"],
+      icon: IcRoundLanguage
+    }),
+    archive: Config.root("Archive", {
+      contains: ["Page", "Folder"],
+      icon: IcRoundHistory
+    }),
+    settings: Config.root("Settings", {
+      contains: ["Page", "Folder"],
+      icon: IcOutlineSettings
+    }),
+    brandAssets: Config.root("Brand assets", {
+      contains: ["Page", "Folder"],
+      icon: IcRoundImage
+    }),
+    nestedContent: Config.root("Nested content", {
+      contains: ["Page", "Folder"],
+      icon: MiLayers
+    }),
+    media: Config.media()
+  }
+});
 var cms = createCMS({
   enableDrafts: true,
   schema: { Page, Folder },
@@ -222,7 +269,8 @@ var cms = createCMS({
     nested,
     many,
     i18n,
-    statuses
+    statuses,
+    manyRoots
   }
 });
 export {

package/dist/dashboard/hook/UseEntryEditor.d.ts

@@ -22,5 +22,8 @@ export interface EntryEditor {
 /**
  * Returns the consumer-facing entry editor shape. Only the fields declared by
  * EntryEditor are supported; dashboard atoms remain an internal detail.
+ *
+ * @deprecated Use `useEntry` from 'alinea/cms': it returns the entry being
+ * edited with its `id`, `locale`, `path`, `title`, `type` and `status`.
  */
 export declare function useEntryEditor(): EntryEditor | undefined;

package/dist/dashboard/hook/UseGraph.d.ts

@@ -1,5 +1,7 @@
 import type { Graph } from 'alinea/core/Graph';
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ *
+ * @deprecated Use `useGraph` from 'alinea/cms'.
  */
 export declare function useGraph(): Graph;

package/dist/dashboard/hook/UseGraph.js

@@ -1,13 +1,13 @@
 import {
-  useAtomValue
-} from "../../chunks/chunk-U4VOHNR2.js";
-import "../../chunks/chunk-Y7XOMJOC.js";
+  useAtomValueRaw
+} from "../../chunks/chunk-D6UJHBJJ.js";
+import "../../chunks/chunk-CFNRVI3Y.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/hook/UseGraph.ts
 import { graphAtom } from "../atoms/core.js";
 function useGraph() {
-  return useAtomValue(graphAtom);
+  return useAtomValueRaw(graphAtom);
 }
 export {
   useGraph

package/dist/dashboard/hook/UseLocale.d.ts

@@ -1,4 +1,6 @@
 /**
- * @deprecated Compatibility hook for legacy dashboard extensions.
+ * Compatibility hook for dashboard extensions written for Alinea 1.x.
+ *
+ * @deprecated Use `useLocale` from 'alinea/cms'.
  */
 export declare function useLocale(): string | null;