@eldrajs/theme-vue 0.0.0 → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,542 @@
+import { InjectionKey, MaybeRefOrGetter, PropType, Ref, VNode, VNodeChild } from "vue";
+import { ThemeMessages } from "@eldrajs/theme-core/i18n";
+import { BlockFieldDefinition, BlockFieldsMap, BuildRichTextTreeOptions, DEFAULT_IMAGE_FRAMING, EldraClient, EntryDoc, EntryQuery, ImageFraming, PageLike, ReusableComponentProjection, RichTextFieldIdentity, RichTextMark, RichTextNode, RichTextRenderChild, RichTextRenderNode, RouteTemplateLike, ThemeDesignTokens, buildRichTextTree, imageFramingAttrs, imageFramingStyle, isBlockFieldLocalized, normalizeImageFraming, registerBlockFields } from "@eldrajs/theme-core";
+import { LinkKind, LinkRouteContext, LinkTarget, LinkTargetInfo, LinkTargetInfo as LinkTargetInfo$1, LinkValue, ResolvedLink, ResolvedLink as ResolvedLink$1, linkTargetKeys, resolveLink, safeLinkHref } from "@eldrajs/theme-core/links";
+import { BridgePayloads } from "@eldrajs/theme-core/bridge";
+//#region src/context.d.ts
+/**
+ * One rendered editor slot marker's geometry. Derives from the bridge payload
+ * type so the wire format stays the single source of truth.
+ */
+type SlotGeometry = BridgePayloads['theme:slots-rendered']['slots'][number];
+type SlotGeometryReporter = (slots: SlotGeometry[]) => void;
+/**
+ * What `resolveLink` needs, as one reactive slice of the theme context: the
+ * site's pages and route templates, and what it knows about the objects its
+ * links point at, keyed `${_type}:${id}`. An adapter fills it where it already
+ * resolves the route — one place, one read per type — so a prerendered page
+ * carries every href in its payload.
+ */
+interface EldraLinkState {
+  pages: PageLike[];
+  templates: RouteTemplateLike[];
+  targets: Map<string, LinkTargetInfo$1>;
+}
+/**
+ * Which content locale the page a visitor is looking at is, and what the others are — the slice an
+ * adapter fills from the site's own routing so a **block** can read it without reaching for the
+ * router or the runtime config.
+ *
+ * It lives on the theme context rather than in a framework composable for the same reason the link
+ * state does: a block must render in a Storybook story and a unit test with no Nuxt around it, so
+ * everything it needs arrives through one `inject`. `useEldraLocale()` is the accessor.
+ *
+ * `path` is the one every link goes through and it is **idempotent** — see the adapter's own
+ * implementation (`@eldrajs/theme-nuxt`'s `localeHref`): a destination can pass through more than
+ * one prefixer, and a second prefix would produce a path nothing on the site answers.
+ */
+interface EldraLocaleState {
+  /**
+   * The active content locale, or `null` on a site that configures none. In a Studio preview this
+   * is the locale the editor is driving, which wins over the one the path names.
+   */
+  active: string | null;
+  /** The locale served at `/`, unprefixed. `null` on a site that configures none. */
+  defaultLocale: string | null;
+  /** Every locale the site serves, `defaultLocale` first. Empty on a site that configures none. */
+  supported: readonly string[];
+  /**
+   * One locale's name **in that locale** — "íslenska (Ísland)", "American English" — for a language
+   * switcher's option label, with the tag itself as the fallback.
+   *
+   * It is on the state rather than left to the caller because the answer is ICU data and a renderer
+   * and a browser do not always have the same of it: Node answers "íslenska (Ísland)" for `is-IS`
+   * where a reduced-ICU browser build answers "Icelandic (Iceland)". An adapter therefore resolves
+   * these **once, on the server**, and carries them to the browser, so a switcher that renders one
+   * does not hydrate into a mismatch and repaint.
+   */
+  name: (locale: string) => string;
+  /**
+   * One same-site destination (`/products/x`, `/search?q=mug`) under the active locale. Anything
+   * that is not a path on this site — an absolute URL, `mailto:`, `#main` — and anything already
+   * spelled in one of the site's locales comes back untouched.
+   */
+  path: (href: string) => string;
+  /** The page the visitor is on, spelled in `locale`. The default locale's spelling has no prefix. */
+  switchPath: (locale: string) => string;
+  /** Go to `switchPath(locale)` — what a language switcher calls when its value changes. */
+  select: (locale: string) => void;
+}
+interface EldraContext {
+  client: EldraClient;
+  links: EldraLinkState;
+  /**
+   * Optional so a context assembled before locales existed still type-checks and still renders:
+   * every reader treats its absence as "one unprefixed site, no switcher", which is what such a
+   * site is.
+   */
+  locales?: EldraLocaleState;
+  /**
+   * The theme's resolved message catalogue — the manifest's own `messages` block (or the fallback
+   * catalogue, `{ defaultLocale: 'en-US', locales: {} }`, for a theme that ships no `i18n/`
+   * directory), merged with the platform's own overrides and resolved over the organisation's
+   * locales at build time (`@eldrajs/theme-nuxt`'s module, `@eldrajs/theme-core/i18n`'s
+   * `resolveMessageCatalogue`). Flat dotted keys, one record per locale tag — the starter's
+   * `vue-i18n` plugin is the one consumer that unflattens it.
+   *
+   * Reactive so a live `editor:theme-messages` push from Studio's preview (`useEldraPreview`)
+   * updates every block reading a message through it with no re-render plumbing of its own.
+   */
+  messages: ThemeMessages;
+  preview: {
+    active: boolean;
+    mode: 'preview' | 'edit';
+    locale: string | null;
+    sourceDrafts: Record<string, Record<string, unknown>>;
+    drafts: Record<string, Record<string, unknown>>;
+    draftSchemaApiIds: Record<string, string>;
+    refreshRevision: number;
+    revision: number;
+    designTokensRevision: number;
+    /**
+     * The revision of the last `editor:theme-messages` push applied to `context.messages`.
+     * Mirrors `designTokensRevision`'s role: a push whose `revision` is not strictly greater than
+     * this is stale (an out-of-order delivery, a reconnect replay) and is ignored rather than
+     * rolling a live edit backwards.
+     */
+    messagesRevision: number;
+    /**
+     * Bumped every time `editor:init` carries a preview token that differs
+     * from the one before it — so a consumer can tell "the editor handed me a
+     * *new* token" apart from "the editor sent another content update"
+     * (`refreshRevision` bumps for both). `useEldraPage` reads it to decide
+     * whether a 401 is the first failure of a token, which the editor may
+     * still recover from, or the failure of a token it has already replaced,
+     * which is the operator's to see.
+     */
+    tokenRevision: number;
+    /**
+     * Negotiated from the editor's editor:hello capabilities (the
+     * `block-slots` capability), re-negotiated on every hello. Gates the
+     * editor-only slot markers, which `EldraLayout` renders — the one
+     * negotiated capability a Vue component has to read.
+     *
+     * The `image-framing` and `rich-text-inline` gates are deliberately not
+     * mirrored here: theme-core's preview message router negotiates them and
+     * forwards them straight to the overlay runtime
+     * (`setFramingEnabled`/`setRichTextEnabled`), so there is one owner per
+     * capability rather than one per framework binding.
+     */
+    editorSupportsSlots: boolean;
+    /**
+     * §18 v3: bumped once for every change theme-core reports through
+     * `onRichTextRenderState`, so a rich-text field re-evaluates whether its
+     * render is deferred. It is only a change signal — the answer itself is
+     * `isRichTextRenderDeferred`, which is core's, not a mirror of it.
+     */
+    richTextRenderRevision: number;
+    /**
+     * §18 v3: theme-core's predicate, installed by startEldraPreview. While it
+     * answers true for a field, the browser owns that field's DOM (a native
+     * text op is in flight) and the renderer must not replace it. Undefined in
+     * static output and outside a preview, where nothing is ever deferred.
+     */
+    isRichTextRenderDeferred?: (identity: RichTextFieldIdentity) => boolean;
+    /**
+     * Installed by startEldraPreview; posts bounded theme:slots-rendered
+     * geometry over the bridge. Undefined in static output.
+     */
+    slotGeometryReporter?: SlotGeometryReporter;
+  };
+  designTokens: ThemeDesignTokens;
+}
+export declare const ELDRA_KEY: InjectionKey<EldraContext>;
+/**
+ * The preview slice of a fresh theme context, reactive and complete. Every
+ * adapter that assembles an `EldraContext` by hand — theme-nuxt's runtime
+ * plugin, or an equivalent entry for another framework — must build it from
+ * here: the hand-written literal had already drifted several fields behind
+ * this interface, and a missing field is a runtime error rather than a type
+ * error once the object is assembled elsewhere.
+ */
+export declare function createEldraPreviewState(): EldraContext['preview'];
+/**
+ * The link slice of a fresh theme context, reactive and empty. Built here for
+ * the same reason `createEldraPreviewState` is: a missing field is a runtime
+ * error rather than a type error once the object is assembled elsewhere.
+ */
+/**
+ * The locale slice of a context with no router behind it — a Storybook story, a unit-test mount, a
+ * site whose organisation configures no locales. Every answer is the one-unprefixed-site answer,
+ * so a block written against `useEldraLocale()` renders identically in all three.
+ *
+ * An adapter that *has* routing builds its own (see `@eldrajs/theme-nuxt`'s runtime plugin): the
+ * active locale and the paths are derived from the route, which this layer knows nothing about.
+ */
+export declare function createEldraLocaleState(): EldraLocaleState;
+export declare function createEldraLinkState(): EldraLinkState;
+export declare function provideEldra(opts: {
+  client: EldraClient;
+  designTokens?: unknown;
+  /** Defaults to the fallback catalogue (`{ defaultLocale: 'en-US', locales: {} }`) — a Storybook mount
+   * or a unit test that does not pass one renders exactly as a theme with no `i18n/` directory
+   * does. An adapter with a real build (`@eldrajs/theme-nuxt`'s runtime plugin) passes the
+   * resolved `virtual:eldra/messages` content instead. */
+  messages?: ThemeMessages;
+}): EldraContext;
+export declare function useEldra(): EldraContext;
+//#endregion
+//#region src/useEldraLink.d.ts
+/**
+ * Resolve a `link` field's value against the site's own routes.
+ *
+ * Call it once per component and keep the returned function — it closes over
+ * the reactive link state, so every call reads whatever the adapter has filled
+ * in by then, and a row re-resolves when a target arrives or a preview draft
+ * changes the value.
+ *
+ * Outside a themed app (a block rendered in isolation, a story with no
+ * provider) it resolves nothing: every value comes back `null`, which a block
+ * already has to handle for a target that no longer exists.
+ *
+ * Every href it hands back is spelled in the **active content locale**
+ * (`useEldraLocale()`), so a navigation resolved on `/is-IS/about` points at
+ * `/is-IS/products/x` and a visitor cannot be dropped back into the default
+ * language by following a link. The rewrite is idempotent, which is what lets a
+ * theme's router-link component prefix as well without the two compounding.
+ */
+export declare function useEldraLink(): (value: unknown) => ResolvedLink$1 | null;
+//#endregion
+//#region src/useEldraLocale.d.ts
+/**
+ * The locale this page is in, the locales the site serves, and how to spell a destination in one
+ * of them.
+ *
+ * Call it once per component and keep what it returns — the state is reactive, so a template that
+ * reads `active` or calls `path()` re-renders when the visitor changes language.
+ *
+ * Outside a themed app, and on a site whose organisation configures no locales, it answers the
+ * one-unprefixed-site answer: `active` and `defaultLocale` `null`, `supported` empty, `path()` the
+ * identity. A block can therefore read it unconditionally and render the same markup in a
+ * Storybook story as on a single-locale site — which is also why a language switcher's own rule is
+ * `supported.length > 1`, never "is there a locale at all".
+ */
+export declare function useEldraLocale(): EldraLocaleState;
+//#endregion
+//#region src/EldraBlockZone.d.ts
+/** Resolve the schema API id across both supported gateway response shapes. */
+export declare function getBlockSchemaApiId(entry: EntryDoc): string | null;
+export declare const EldraBlockZone: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  blocks: {
+    type: PropType<EntryDoc[]>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  blocks: {
+    type: PropType<EntryDoc[]>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/EldraLayout.d.ts
+/**
+ * Render a validated responsive layout with the same model and stylesheet used
+ * by static generation. Invalid documents and unresolved entry references fail
+ * closed before any customer block component is mounted.
+ */
+export declare const EldraLayout: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  layout: {
+    type: PropType<unknown>;
+    required: true;
+  };
+  blocks: {
+    type: PropType<EntryDoc[]>;
+    required: true;
+  };
+  nonce: {
+    type: StringConstructor;
+    required: false;
+    default: undefined;
+  };
+  designTokens: {
+    type: PropType<unknown>;
+    required: false;
+    default: undefined;
+  };
+  reusableComponentProjection: {
+    type: PropType<ReusableComponentProjection | undefined>;
+    required: false;
+    default: undefined;
+  };
+  templateEntry: {
+    type: PropType<EntryDoc | undefined>;
+    required: false;
+    default: undefined;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  layout: {
+    type: PropType<unknown>;
+    required: true;
+  };
+  blocks: {
+    type: PropType<EntryDoc[]>;
+    required: true;
+  };
+  nonce: {
+    type: StringConstructor;
+    required: false;
+    default: undefined;
+  };
+  designTokens: {
+    type: PropType<unknown>;
+    required: false;
+    default: undefined;
+  };
+  reusableComponentProjection: {
+    type: PropType<ReusableComponentProjection | undefined>;
+    required: false;
+    default: undefined;
+  };
+  templateEntry: {
+    type: PropType<EntryDoc | undefined>;
+    required: false;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  nonce: string;
+  designTokens: undefined;
+  reusableComponentProjection: ReusableComponentProjection | undefined;
+  templateEntry: EntryDoc | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/EldraRichText.d.ts
+/**
+ * Renders a §18 rich-text field's TipTap JSON document. Read render only —
+ * the theme SDK is a bridge, not an editor: it hosts no editing UI and
+ * depends on neither TipTap nor a component library.
+ *
+ * §18 v3: the operator edits this render natively — theme-core's overlay
+ * makes the root `contenteditable` in edit mode and reports selection, text
+ * ops and commands in ProseMirror document positions; Studio owns the one
+ * headless editor and the docked toolbar and echoes the document back
+ * through `editor:content-update`. While Studio is editing, the root is
+ * marked `data-eldra-rich-text-editing`; nothing is hidden or overlaid.
+ *
+ * The root carries the marking attributes the overlay's
+ * `decorateStegaTextNodes`/`applyEditable`/`reconcileExternalDrafts`
+ * recognize (`[data-eldra-rich-text]`) so the overlay skips per-leaf stega
+ * decoration here and hands click-to-select to `theme:field-clicked`
+ * instead (see theme-core's `overlay.ts`).
+ *
+ * Per-block toolbar: the `metadata.toolbar` data path is unchanged
+ * (`block.json` → manifest → Core field metadata → Studio), but the theme no
+ * longer reads it — Studio's docked toolbar does. The vite plugin's scanner
+ * still validates the control ids at build time.
+ *
+ * Locale: an omitted `locale` prop defaults to the preview's active content
+ * locale when the manifest marks the field `localized`, and to `null`
+ * otherwise. That resolved locale is what `data-eldra-locale` carries, so
+ * Studio edits the locale the render actually used.
+ *
+ * Heading outline: `minHeadingLevel` floors every heading tag at render time,
+ * so one stored document fits under two different page outlines without being
+ * rewritten (see that prop's own comment).
+ */
+export declare const EldraRichText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  entryId: {
+    type: StringConstructor;
+    required: true;
+  };
+  field: {
+    type: StringConstructor;
+    required: true;
+  };
+  locale: {
+    type: PropType<string | null>;
+    required: false;
+    default: null;
+  };
+  doc: {
+    type: PropType<unknown>;
+    required: true;
+  };
+  /** The owning block's schema id — a block component passes `getBlockSchemaApiId(entry)`.
+   * Used to resolve the field's `localized` flag from the block manifest. */
+  apiId: {
+    type: PropType<string | null | undefined>;
+    required: false;
+    default: undefined;
+  };
+  /**
+   * A floor for every heading in the document: a `heading` node renders as
+   * `h{max(minHeadingLevel, level)}`, still capped at 6. Defaults to 1 — the
+   * generic clamp, i.e. whatever level the document carries.
+   *
+   * A page owns its heading outline; a rich-text field does not. The same body
+   * document is legitimately an h2-and-down section in one block and an
+   * h3-and-down one in another (the starter's `article` body starts at h2, its
+   * `rich-text` block at h3), and nothing in the document or in `block.json`
+   * can say so — `metadata.toolbar`'s `heading` control id is one
+   * level-agnostic entry, so an editor can insert any level anywhere. Without
+   * this prop the only place to enforce it was a per-block transform over the
+   * TipTap JSON before handing it in (the starter shipped one); doing it here
+   * instead means the **document is never rewritten** — no copy, no
+   * reactive-state surgery, and an editor's own level survives a round trip
+   * through Studio untouched, because only the rendered tag moves.
+   *
+   * A floor, never an offset: an author who already wrote h3 under
+   * `minHeadingLevel: 3` keeps h3, and h4 stays h4 — only levels above the
+   * floor move. Every guard is in `@eldrajs/theme-core`'s own
+   * `clampHeadingLevel`, so an out-of-range or non-integer value can never
+   * produce an `<h0>`/`<h7>`.
+   *
+   * Rendering-only, deliberately: the value takes no part in position
+   * stamping (`data-eldra-pos` is the document's own numbering, which a
+   * rendered tag name cannot change), so native editing, selection reporting
+   * and `restampRichTextPositions` all behave exactly as they do without it.
+   */
+  minHeadingLevel: {
+    type: NumberConstructor;
+    required: false;
+    default: number;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  entryId: {
+    type: StringConstructor;
+    required: true;
+  };
+  field: {
+    type: StringConstructor;
+    required: true;
+  };
+  locale: {
+    type: PropType<string | null>;
+    required: false;
+    default: null;
+  };
+  doc: {
+    type: PropType<unknown>;
+    required: true;
+  };
+  /** The owning block's schema id — a block component passes `getBlockSchemaApiId(entry)`.
+   * Used to resolve the field's `localized` flag from the block manifest. */
+  apiId: {
+    type: PropType<string | null | undefined>;
+    required: false;
+    default: undefined;
+  };
+  /**
+   * A floor for every heading in the document: a `heading` node renders as
+   * `h{max(minHeadingLevel, level)}`, still capped at 6. Defaults to 1 — the
+   * generic clamp, i.e. whatever level the document carries.
+   *
+   * A page owns its heading outline; a rich-text field does not. The same body
+   * document is legitimately an h2-and-down section in one block and an
+   * h3-and-down one in another (the starter's `article` body starts at h2, its
+   * `rich-text` block at h3), and nothing in the document or in `block.json`
+   * can say so — `metadata.toolbar`'s `heading` control id is one
+   * level-agnostic entry, so an editor can insert any level anywhere. Without
+   * this prop the only place to enforce it was a per-block transform over the
+   * TipTap JSON before handing it in (the starter shipped one); doing it here
+   * instead means the **document is never rewritten** — no copy, no
+   * reactive-state surgery, and an editor's own level survives a round trip
+   * through Studio untouched, because only the rendered tag moves.
+   *
+   * A floor, never an offset: an author who already wrote h3 under
+   * `minHeadingLevel: 3` keeps h3, and h4 stays h4 — only levels above the
+   * floor move. Every guard is in `@eldrajs/theme-core`'s own
+   * `clampHeadingLevel`, so an out-of-range or non-integer value can never
+   * produce an `<h0>`/`<h7>`.
+   *
+   * Rendering-only, deliberately: the value takes no part in position
+   * stamping (`data-eldra-pos` is the document's own numbering, which a
+   * rendered tag name cannot change), so native editing, selection reporting
+   * and `restampRichTextPositions` all behave exactly as they do without it.
+   */
+  minHeadingLevel: {
+    type: NumberConstructor;
+    required: false;
+    default: number;
+  };
+}>> & Readonly<{}>, {
+  locale: string | null;
+  apiId: string | null | undefined;
+  minHeadingLevel: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/richTextRender.d.ts
+/**
+ * Vue binding for theme-core's framework-neutral rich-text render tree. Every
+ * node/mark rule, the `safeHref` gating and the attribute whitelist live in
+ * `buildRichTextTree`; this file only maps the resulting tree onto `h()` and
+ * supplies the vnode keys Vue wants (the tree itself carries none — keys are
+ * a framework concern).
+ */
+type RenderRichTextOptions = BuildRichTextTreeOptions;
+/**
+ * Render a TipTap JSON document's content as Vue VNodes. Non-doc input renders
+ * as an empty root.
+ *
+ * `generation` changes the key prefix, which makes Vue discard the subtree and
+ * build it again instead of patching. §18 v3's deferred rendering needs that
+ * exactly once per deferral: while a field is deferred the browser edits the
+ * DOM behind Vue's back, so the vnode tree Vue is holding no longer describes
+ * what is on screen, and an ordinary patch can skip a change it believes is
+ * already applied. Generation 0 keeps the original keys, so nothing about the
+ * ordinary render path changes.
+ */
+export declare function renderRichTextDoc(doc: unknown, options: RenderRichTextOptions, generation?: number): VNodeChild[];
+//#endregion
+//#region src/useEldraEntry.d.ts
+export declare function useEldraEntry(opts: {
+  schemaApiId: string;
+  entryId?: MaybeRefOrGetter<string | undefined>;
+  uniqueField?: {
+    fieldId: string;
+    value: MaybeRefOrGetter<string>;
+  };
+  query?: EntryQuery;
+}): {
+  entry: Ref<EntryDoc | null>;
+  pending: Ref<boolean>;
+  error: Ref<string | null>;
+  refresh: () => Promise<void>;
+};
+//#endregion
+//#region src/useEldraBlockField.d.ts
+/**
+ * Vue-facing name for theme-core's block-field lookup. The registry and the
+ * `localized` resolution live in `@eldrajs/theme-core` so every framework
+ * binding shares one implementation; this wrapper exists only so themes keep
+ * calling a composable-shaped API.
+ *
+ * There is no `toolbar` here any more: §18 v3 keeps the rich-text toolbar in
+ * Studio, which reads `metadata.toolbar` from Core's field definitions. The
+ * vite plugin still validates the control ids at build time.
+ */
+export declare function useEldraBlockField(apiId: string | undefined, fieldId: string): {
+  localized: boolean;
+};
+//#endregion
+//#region src/useEldraPreview.d.ts
+export declare function startEldraPreview(context: EldraContext, opts: {
+  allowedOrigins: string[];
+  onNavigate?: (path: string) => void;
+}): {
+  active: Readonly<Ref<boolean>>;
+  destroy: () => void;
+};
+export declare function useEldraPreview(opts: {
+  allowedOrigins: string[];
+  onNavigate?: (path: string) => void;
+}): {
+  active: Readonly<Ref<boolean>>;
+};
+//#endregion
+export { type BlockFieldDefinition, type BlockFieldsMap, DEFAULT_IMAGE_FRAMING, type EldraContext, type EldraLinkState, type EldraLocaleState, type ImageFraming, type LinkKind, type LinkRouteContext, type LinkTarget, type LinkTargetInfo, type LinkValue, type RenderRichTextOptions, type ResolvedLink, type RichTextMark, type RichTextNode, type RichTextRenderChild, type RichTextRenderNode, type SlotGeometry, type SlotGeometryReporter, buildRichTextTree, imageFramingAttrs, imageFramingStyle, isBlockFieldLocalized, linkTargetKeys, normalizeImageFraming, registerBlockFields, resolveLink, safeLinkHref };