@chelone/core 0.6.0 → 0.9.0

package/dist/resource/registry-store.d.ts

@@ -10,12 +10,44 @@
  * a plain keyed store with a whole-map snapshot, mirroring the store /
  * MicroStore notification pattern.
  */
+/**
+ * The augmentation point for the types a resource definition carries that
+ * depend on the UI framework. An adapter names them once, as `Register` does
+ * for resources:
+ *
+ * ```ts
+ * declare module "@chelone/core" {
+ *   interface ResourceSlots {
+ *     icon: ComponentType;
+ *     representation: RecordRepresentation;
+ *     component: ComponentType;
+ *   }
+ * }
+ * ```
+ *
+ * Augmenting is global to a TypeScript program, so a program that includes
+ * both adapters would see both. Without an augmentation each type is
+ * `unknown`.
+ */
+export interface ResourceSlots {
+}
+/** A resource's menu icon: the adapter's icon type, or `unknown` when none is declared. */
+export type ResourceIcon = ResourceSlots extends {
+    icon: infer TIcon;
+} ? TIcon : unknown;
+/** How a record renders as a label: the adapter's type, or `unknown` when none is declared. */
+export type ResourceRepresentation = ResourceSlots extends {
+    representation: infer TRepresentation;
+} ? TRepresentation : unknown;
+/** A resource's list, create, edit or show view: the adapter's component type, or `unknown` when none is declared. */
+export type ResourceComponent = ResourceSlots extends {
+    component: infer TComponent;
+} ? TComponent : unknown;
 /**
  * What a single mounted resource exposes to the shell. `hasList/hasCreate/…`
- * drive the routing engine and the menu; `icon` / `recordRepresentation` are
- * framework-neutral here (`unknown`) — the React layer narrows them to a
- * component / render function. `options` is an open extension bag (D9: the
- * shadcn menu reads `options.group`).
+ * drive the routing engine and the menu; `icon` / `recordRepresentation` take
+ * the adapter's types through {@link ResourceSlots}. `options` is an open
+ * extension bag (D9: the shadcn menu reads `options.group`).
  */
 export interface ResourceDefinition {
     name: string;
@@ -23,10 +55,8 @@ export interface ResourceDefinition {
     hasCreate: boolean;
     hasEdit: boolean;
     hasShow: boolean;
-    /** Framework-neutral: a React component in `@chelone/react`. */
-    icon?: unknown;
-    /** Framework-neutral: `string | function | ReactNode` in `@chelone/react`. */
-    recordRepresentation?: unknown;
+    icon?: ResourceIcon;
+    recordRepresentation?: ResourceRepresentation;
     /** Open extension bag — e.g. `{ group: "content" }` for menu grouping (D9). */
     options?: Record<string, unknown>;
 }
@@ -60,18 +90,18 @@ export interface ResourceRegistry {
 /** Framework-neutral props `computeDefinition` derives a definition from. */
 export interface ComputeDefinitionProps {
     name: string;
-    /** A list component/route (any value); presence sets `hasList`. */
-    list?: unknown;
-    create?: unknown;
-    edit?: unknown;
-    show?: unknown;
+    /** A list component; presence sets `hasList`. */
+    list?: ResourceComponent;
+    create?: ResourceComponent;
+    edit?: ResourceComponent;
+    show?: ResourceComponent;
     /** Explicit overrides OR-ed with component presence (`!!list || !!hasList`). */
     hasList?: boolean;
     hasCreate?: boolean;
     hasEdit?: boolean;
     hasShow?: boolean;
-    icon?: unknown;
-    recordRepresentation?: unknown;
+    icon?: ResourceIcon;
+    recordRepresentation?: ResourceRepresentation;
     options?: Record<string, unknown>;
 }
 /**

package/dist/resource/registry-store.js

@@ -1,68 +1,75 @@
+// src/resource/registry-store.ts
+/**
+* Derive a `ResourceDefinition` from resource props: a route flag is true when
+* EITHER the component is present OR the explicit `has*` flag is set
+* (`hasList = !!list || !!hasList`), matching ra-core's Resource registration.
+*/
 function computeDefinition(props) {
-  return {
-    name: props.name,
-    hasList: !!props.list || !!props.hasList,
-    hasCreate: !!props.create || !!props.hasCreate,
-    hasEdit: !!props.edit || !!props.hasEdit,
-    hasShow: !!props.show || !!props.hasShow,
-    icon: props.icon,
-    recordRepresentation: props.recordRepresentation,
-    options: props.options
-  };
+	return {
+		name: props.name,
+		hasList: !!props.list || !!props.hasList,
+		hasCreate: !!props.create || !!props.hasCreate,
+		hasEdit: !!props.edit || !!props.hasEdit,
+		hasShow: !!props.show || !!props.hasShow,
+		icon: props.icon,
+		recordRepresentation: props.recordRepresentation,
+		options: props.options
+	};
 }
+/** Shallow-compare two `options` bags (own enumerable keys, `Object.is` values). */
 function optionsEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const key of aKeys) {
-    if (!Object.is(a[key], b[key])) return false;
-  }
-  return true;
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) if (!Object.is(a[key], b[key])) return false;
+	return true;
 }
+/**
+* Whether two definitions are observably equal: scalar fields by `Object.is`,
+* `options` shallow-compared. Used to no-op needless re-registrations so the
+* React register-on-render loop doesn't churn subscribers (parity §0a-8).
+*/
 function definitionEqual(a, b) {
-  return a.name === b.name && a.hasList === b.hasList && a.hasCreate === b.hasCreate && a.hasEdit === b.hasEdit && a.hasShow === b.hasShow && Object.is(a.icon, b.icon) && Object.is(a.recordRepresentation, b.recordRepresentation) && optionsEqual(a.options, b.options);
+	return a.name === b.name && a.hasList === b.hasList && a.hasCreate === b.hasCreate && a.hasEdit === b.hasEdit && a.hasShow === b.hasShow && Object.is(a.icon, b.icon) && Object.is(a.recordRepresentation, b.recordRepresentation) && optionsEqual(a.options, b.options);
 }
 function createResourceRegistry() {
-  const definitions = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let snapshot = null;
-  const notify = () => {
-    snapshot = null;
-    for (const listener of listeners) listener();
-  };
-  return {
-    register(definition) {
-      const current = definitions.get(definition.name);
-      if (current && definitionEqual(current, definition)) return;
-      definitions.set(definition.name, definition);
-      notify();
-    },
-    unregister(name) {
-      if (!definitions.delete(name)) return;
-      notify();
-    },
-    get(name) {
-      return definitions.get(name);
-    },
-    getAll() {
-      if (snapshot === null) {
-        const next = {};
-        for (const [name, definition] of definitions) next[name] = definition;
-        snapshot = next;
-      }
-      return snapshot;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    }
-  };
+	const definitions = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let snapshot = null;
+	const notify = () => {
+		snapshot = null;
+		for (const listener of listeners) listener();
+	};
+	return {
+		register(definition) {
+			const current = definitions.get(definition.name);
+			if (current && definitionEqual(current, definition)) return;
+			definitions.set(definition.name, definition);
+			notify();
+		},
+		unregister(name) {
+			if (!definitions.delete(name)) return;
+			notify();
+		},
+		get(name) {
+			return definitions.get(name);
+		},
+		getAll() {
+			if (snapshot === null) {
+				const next = {};
+				for (const [name, definition] of definitions) next[name] = definition;
+				snapshot = next;
+			}
+			return snapshot;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
 }
-export {
-  computeDefinition,
-  createResourceRegistry
-};
+export { computeDefinition, createResourceRegistry };

package/dist/resource/registry.d.ts

@@ -35,6 +35,16 @@ type Checked<T extends ResourceMap> = {
         };
     };
 };
+/**
+ * A resource map whose every resource has `TRecord` as its record. A view
+ * generic over its record passes it to a hook that is generic over a map, so
+ * `RecordOf<RecordResources<TRecord>, string>` is `TRecord`.
+ */
+export type RecordResources<TRecord> = {
+    [name: string]: {
+        schema: StandardSchemaV1<unknown, TRecord>;
+    };
+};
 /**
  * The record type for a given resource name in a registry:
  * the schema's Standard Schema output type when a schema is present, else `LooseRecord`.

package/dist/resource/registry.js

@@ -1,6 +1,10 @@
+// src/resource/registry.ts
+/**
+* Identity helper that pins literal resource names + schema types via `const`.
+* `defineResources({ posts: { schema: postSchema } })` keeps `"posts"` literal
+* and `typeof postSchema` exact, enabling end-to-end inference.
+*/
 function defineResources(resources) {
-  return resources;
+	return resources;
 }
-export {
-  defineResources
-};
+export { defineResources };

package/dist/resource/source-path.d.ts

@@ -56,16 +56,37 @@ export type SourcePath<TRecord> = unknown extends TRecord ? string : Paths<TReco
 /**
  * The value type at `TPath`, including the `null`/`undefined` of every parent
  * along it — what reading `record.author?.name` gives. `unknown` for a loose
- * record.
+ * record, and for a path typed as a bare `string` (no path to walk).
+ *
+ * The guard is load-bearing even though `Get` makes the same check: without it
+ * here, `Get` over a field's open `TRecord` hangs `vue-tsc`.
  */
 export type SourceValue<TRecord, TPath extends string> = unknown extends TRecord ? unknown : Get<TRecord, TPath, {
     nullish: "path";
 }>;
+/**
+ * The value a `format`/`parse` transform carries at `TPath`.
+ *
+ * {@link SourceValue} walks from the record root, so a source relative to a row
+ * (`qty` under `items[]`) or a filter key (`published_at_gte`) walks to `never`.
+ * Both are legal {@link SourceProp}s and their value is simply unknown to the
+ * type, so a transform over one stays loose instead of demanding a `never` no
+ * callback can return.
+ */
+export type SourceTransformValue<TRecord, TPath extends string> = [
+    SourceValue<TRecord, TPath>
+] extends [never] ? unknown : SourceValue<TRecord, TPath>;
 /**
  * The top-level keys of `TRecord`, for props that read or write one flat key
  * (a filter's field, a reference's target). `string` for a loose record.
+ *
+ * The guard is {@link SourceProp}'s, not the `unknown extends` the other path
+ * types use: `keyof TRecord` of an unresolved type parameter resolves to the
+ * keys of its constraint, and every shared record type is now bounded by
+ * `ResourceRecord`, whose only key is `id`. A generic field's sibling prop
+ * (`limitSource`) would then take `"id"` and nothing else.
  */
-export type SourceKey<TRecord> = unknown extends TRecord ? string : keyof TRecord & string;
+export type SourceKey<TRecord> = LooseRecord extends TRecord ? string : keyof TRecord & string;
 /**
  * The paths *relative to an array item* of every array in `TRecord`: `sku` is
  * one for a record with `items: { sku: string }[]`.

package/dist/rich-text/rich-text-extras.d.ts

@@ -0,0 +1,134 @@
+import { type RichTextToolbarGroup } from "./rich-text.js";
+/** The image size every Chelone editor offers: 5 MB. */
+export declare const MAX_IMAGE_BYTES: number;
+export interface RichTextImageRules {
+    /** Exact types, or `type/*` for any subtype. SVG never passes. */
+    allowedMimeTypes: readonly string[];
+    /** Bytes. */
+    maxFileSize: number;
+    allowBase64: boolean;
+}
+/** shadmin's image settings: any image, 5 MB, base64 allowed. */
+export declare const defaultRichTextImageRules: Readonly<RichTextImageRules>;
+/** Why an image file is refused, or `null` when it is accepted. */
+export declare function checkRichTextImageFile(file: {
+    type: string;
+    size: number;
+}, rules: RichTextImageRules): "type" | "size" | null;
+export interface RichTextUpload {
+    id: string | null;
+    src: string;
+}
+/** What an upload handler may return: a URL, or a URL with the stored file's id. */
+export declare function normalizeRichTextUpload(result: string | {
+    id: string | number;
+    src: string;
+}, rules?: Pick<RichTextImageRules, "allowBase64">): RichTextUpload | null;
+/** `width` rounded and held in `min`..`max`. `max` wins when it is below `min`. */
+export declare function clampRichTextImageWidth(width: number, { min, max }: {
+    min: number;
+    max: number;
+}): number;
+/** `<name>.<extension>` for downloading an image, from its alt text and mime type. */
+export declare function richTextImageFileName(alt: string, mimeType: string): string;
+export type RichTextImageActionId = "view" | "download" | "copyImage" | "copyLink" | "remove";
+export interface RichTextImageAction {
+    id: RichTextImageActionId;
+    /** Translation key, always `chelone.rich_text.image.<id>`. */
+    labelKey: `chelone.rich_text.image.${RichTextImageActionId}`;
+    defaultLabel: string;
+}
+/** The image popover's actions, in display order. */
+export declare const richTextImageActions: readonly Readonly<RichTextImageAction>[];
+export type RichTextColorPalette = "default" | "bright" | "soft" | "muted";
+export interface RichTextColor {
+    id: string;
+    palette: RichTextColorPalette;
+    /** Translation key, always `chelone.rich_text.color.<id>`. */
+    labelKey: `chelone.rich_text.color.${string}`;
+    defaultLabel: string;
+    /** A `var(--rich-text-color-<id>)` reference, or `null` for the entry that clears the color. */
+    value: `var(--rich-text-color-${string})` | null;
+}
+/**
+ * The color picker's entries: `default` (clears the color), then three
+ * palettes of seven. The adapter's stylesheet defines each
+ * `--rich-text-color-<id>`.
+ */
+export declare const richTextColors: readonly Readonly<RichTextColor>[];
+/**
+ * `color: <value>` when `style` is one `color` declaration with a palette
+ * `var(...)`, hex, `rgb()`, `rgba()`, `hsl()` or `hsla()` value, else `null`.
+ * Everything else a style attribute can carry is dropped.
+ */
+export declare function sanitizeRichTextStyle(style: string): string | null;
+/**
+ * `richTextSanitizeOptions` with `style` allowed through, for adapters that
+ * run `sanitizeRichTextStyle` on every `style` attribute.
+ */
+export declare const richTextStyledSanitizeOptions: Readonly<{
+    FORBID_TAGS: readonly ["style", "form", "input", "button", "textarea", "select", "iframe", "object", "embed"];
+    FORBID_ATTR: readonly string[];
+}>;
+/** Options for tiptap's `CodeBlockLowlight.configure`, as shadmin sets them. */
+export declare const richTextCodeBlockOptions: Readonly<{
+    languageClassPrefix: "language-";
+    defaultLanguage: null;
+    exitOnTripleEnter: true;
+    exitOnArrowDown: true;
+    enableTabIndentation: false;
+    tabSize: 4;
+}>;
+export type RichTextExtraToolbarItemId = "image" | "color";
+export interface RichTextExtraToolbarItem {
+    id: RichTextExtraToolbarItemId;
+    group: RichTextToolbarGroup;
+    /** Translation key, always `chelone.rich_text.<id>`. */
+    labelKey: `chelone.rich_text.${RichTextExtraToolbarItemId}`;
+    defaultLabel: string;
+    /** A binding in the syntax of `matchesHotkey`, e.g. `"mod+b"`. */
+    shortcut?: string;
+}
+/** The toolbar buttons an image or color extension adds, shaped like `richTextToolbarItems`. */
+export declare const richTextExtraToolbarItems: readonly Readonly<RichTextExtraToolbarItem>[];
+interface NamedMark {
+    type: {
+        name: string;
+    };
+}
+/** The slice of a ProseMirror state `endColorOnEnter` reads, so core names no ProseMirror type. */
+interface EnterState<Mark extends NamedMark, Transaction> {
+    selection: {
+        $from: {
+            marks(): readonly Mark[];
+            nodeAfter: {
+                marks: readonly Mark[];
+            } | null;
+        };
+    };
+    storedMarks: readonly Mark[] | null;
+    tr: {
+        setStoredMarks(marks: readonly Mark[] | null): Transaction;
+    };
+}
+/**
+ * The two ProseMirror plugin hooks that end a text color with its line.
+ * Splitting a block would carry the color into the next one, so after Enter
+ * the color's `textStyle` mark is dropped from the stored marks, unless colored
+ * text follows the cursor. An adapter wires them into
+ * `new Plugin({ props: { handleKeyDown }, appendTransaction })` and runs that
+ * plugin before the keymap, which handles Enter.
+ */
+export declare function endColorOnEnter(): {
+    handleKeyDown<View>(_view: View, event: {
+        key: string;
+        shiftKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        altKey: boolean;
+    }): false;
+    appendTransaction<Mark extends NamedMark, Transaction, PreviousState>(transactions: readonly {
+        docChanged: boolean;
+    }[], _previous: PreviousState, state: EnterState<Mark, Transaction>): Transaction | null;
+};
+export {};

package/dist/rich-text/rich-text-extras.js

@@ -0,0 +1,181 @@
+import { isSafeImageSrc, richTextSanitizeOptions } from "./rich-text.js";
+// src/rich-text/rich-text-extras.ts
+var CONTROL = /[\u0000-\u001f\u007f]/g;
+/** The image size every Chelone editor offers: 5 MB. */
+var MAX_IMAGE_BYTES = 5242880;
+/** shadmin's image settings: any image, 5 MB, base64 allowed. */
+var defaultRichTextImageRules = Object.freeze({
+	allowedMimeTypes: Object.freeze(["image/*"]),
+	maxFileSize: MAX_IMAGE_BYTES,
+	allowBase64: true
+});
+/** The `type/subtype` of a MIME type, lowercased, without parameters such as `;charset=utf-8`. */
+function baseMimeType(mimeType) {
+	return (mimeType.split(";")[0] ?? "").trim().toLowerCase();
+}
+function mimeMatches(pattern, type) {
+	const wanted = pattern.toLowerCase();
+	if (wanted.endsWith("/*")) return type.startsWith(wanted.slice(0, -1));
+	return type === wanted;
+}
+/** Why an image file is refused, or `null` when it is accepted. */
+function checkRichTextImageFile(file, rules) {
+	const type = baseMimeType(file.type);
+	if (type === "image/svg+xml") return "type";
+	if (!rules.allowedMimeTypes.some((pattern) => mimeMatches(pattern, type))) return "type";
+	return file.size > rules.maxFileSize ? "size" : null;
+}
+/** What an upload handler may return: a URL, or a URL with the stored file's id. */
+function normalizeRichTextUpload(result, rules = defaultRichTextImageRules) {
+	const upload = typeof result === "string" ? {
+		id: null,
+		src: result
+	} : {
+		id: String(result.id),
+		src: result.src
+	};
+	return isSafeImageSrc(upload.src, { allowDataImages: rules.allowBase64 }) ? upload : null;
+}
+/** `width` rounded and held in `min`..`max`. `max` wins when it is below `min`. */
+function clampRichTextImageWidth(width, { min, max }) {
+	return Math.min(max, Math.max(min, Number.isNaN(width) ? min : Math.round(width)));
+}
+var EXTENSIONS = /* @__PURE__ */ new Map([
+	["jpeg", "jpg"],
+	["svg+xml", "svg"],
+	["x-icon", "ico"],
+	["vnd.microsoft.icon", "ico"]
+]);
+/** `<name>.<extension>` for downloading an image, from its alt text and mime type. */
+function richTextImageFileName(alt, mimeType) {
+	const name = alt.replace(CONTROL, "").replace(/[/\\]/g, "").trim().replace(/^\.+/, "").trim();
+	const subtype = baseMimeType(mimeType).split("/")[1] ?? "";
+	const extension = EXTENSIONS.get(subtype) || subtype.replace(/[^a-z0-9]/g, "") || "png";
+	return `${name || "image"}.${extension}`;
+}
+function imageAction(id, defaultLabel) {
+	return Object.freeze({
+		id,
+		labelKey: `chelone.rich_text.image.${id}`,
+		defaultLabel
+	});
+}
+/** The image popover's actions, in display order. */
+var richTextImageActions = Object.freeze([
+	imageAction("view", "View image"),
+	imageAction("download", "Download image"),
+	imageAction("copyImage", "Copy image"),
+	imageAction("copyLink", "Copy link"),
+	imageAction("remove", "Remove image")
+]);
+var COLOR_NAMES = [
+	"red",
+	"orange",
+	"yellow",
+	"green",
+	"blue",
+	"purple",
+	"pink"
+];
+function color(id, palette, defaultLabel, value) {
+	return Object.freeze({
+		id,
+		palette,
+		labelKey: `chelone.rich_text.color.${id}`,
+		defaultLabel,
+		value
+	});
+}
+function palette(name, label) {
+	return COLOR_NAMES.map((base) => {
+		const id = `${name}-${base}`;
+		return color(id, name, `${label} ${base}`, `var(--rich-text-color-${id})`);
+	});
+}
+/**
+* The color picker's entries: `default` (clears the color), then three
+* palettes of seven. The adapter's stylesheet defines each
+* `--rich-text-color-<id>`.
+*/
+var richTextColors = Object.freeze([
+	color("default", "default", "Default", null),
+	...palette("bright", "Bright"),
+	...palette("soft", "Soft"),
+	...palette("muted", "Muted")
+]);
+var NUMBER = String.raw`[+-]?(?:\d+\.?\d*|\.\d+)%?`;
+var SEPARATOR = String.raw`(?:\s*[,/]\s*|\s+)`;
+var HEX_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var FUNCTION_COLOR = new RegExp(String.raw`^(?:rgba?|hsla?)\(\s*${NUMBER}(?:${SEPARATOR}${NUMBER}){2,3}\s*\)$`, "i");
+var PALETTE_VALUES = new Set(richTextColors.flatMap((entry) => entry.value ? [entry.value] : []));
+function isSafeColorValue(value) {
+	return PALETTE_VALUES.has(value) || HEX_COLOR.test(value) || FUNCTION_COLOR.test(value);
+}
+/**
+* `color: <value>` when `style` is one `color` declaration with a palette
+* `var(...)`, hex, `rgb()`, `rgba()`, `hsl()` or `hsla()` value, else `null`.
+* Everything else a style attribute can carry is dropped.
+*/
+function sanitizeRichTextStyle(style) {
+	const [declaration, ...rest] = style.split(";").map((declaration) => declaration.trim()).filter((declaration) => declaration !== "");
+	if (declaration === void 0 || rest.length > 0) return null;
+	const colon = declaration.indexOf(":");
+	if (colon === -1) return null;
+	if (declaration.slice(0, colon).trim().toLowerCase() !== "color") return null;
+	const value = declaration.slice(colon + 1).trim();
+	return isSafeColorValue(value) ? `color: ${value}` : null;
+}
+/**
+* `richTextSanitizeOptions` with `style` allowed through, for adapters that
+* run `sanitizeRichTextStyle` on every `style` attribute.
+*/
+var richTextStyledSanitizeOptions = Object.freeze({
+	FORBID_TAGS: richTextSanitizeOptions.FORBID_TAGS,
+	FORBID_ATTR: Object.freeze(richTextSanitizeOptions.FORBID_ATTR.filter((attribute) => attribute !== "style"))
+});
+/** Options for tiptap's `CodeBlockLowlight.configure`, as shadmin sets them. */
+var richTextCodeBlockOptions = Object.freeze({
+	languageClassPrefix: "language-",
+	defaultLanguage: null,
+	exitOnTripleEnter: true,
+	exitOnArrowDown: true,
+	enableTabIndentation: false,
+	tabSize: 4
+});
+function extraItem(id, group, defaultLabel) {
+	return Object.freeze({
+		id,
+		group,
+		labelKey: `chelone.rich_text.${id}`,
+		defaultLabel
+	});
+}
+/** The toolbar buttons an image or color extension adds, shaped like `richTextToolbarItems`. */
+var richTextExtraToolbarItems = Object.freeze([extraItem("image", "insert", "Image"), extraItem("color", "mark", "Text color")]);
+/**
+* The two ProseMirror plugin hooks that end a text color with its line.
+* Splitting a block would carry the color into the next one, so after Enter
+* the color's `textStyle` mark is dropped from the stored marks, unless colored
+* text follows the cursor. An adapter wires them into
+* `new Plugin({ props: { handleKeyDown }, appendTransaction })` and runs that
+* plugin before the keymap, which handles Enter.
+*/
+function endColorOnEnter() {
+	let enterPressed = false;
+	return {
+		handleKeyDown(_view, event) {
+			enterPressed = event.key === "Enter" && !event.shiftKey && !event.ctrlKey && !event.metaKey && !event.altKey;
+			return false;
+		},
+		appendTransaction(transactions, _previous, state) {
+			if (!enterPressed || !transactions.some((tr) => tr.docChanged)) return null;
+			enterPressed = false;
+			const { $from } = state.selection;
+			if (($from.nodeAfter?.marks ?? []).some((mark) => mark.type.name === "textStyle")) return null;
+			const marks = state.storedMarks ?? $from.marks();
+			const kept = marks.filter((mark) => mark.type.name !== "textStyle");
+			return kept.length === marks.length ? null : state.tr.setStoredMarks(kept);
+		}
+	};
+}
+export { MAX_IMAGE_BYTES, checkRichTextImageFile, clampRichTextImageWidth, defaultRichTextImageRules, endColorOnEnter, normalizeRichTextUpload, richTextCodeBlockOptions, richTextColors, richTextExtraToolbarItems, richTextImageActions, richTextImageFileName, richTextStyledSanitizeOptions, sanitizeRichTextStyle };