@xiongtao.xt/tau-plugins 0.0.0-stage → 0.2.0

package/types/packages/editor/src/components/HoveringToolbar/floatingPosition.d.ts

@@ -0,0 +1,22 @@
+export type FloatingPlacement = "top" | "bottom";
+export type FloatingAnchorRect = {
+    top: number;
+    bottom: number;
+    left: number;
+    width: number;
+};
+export type CalculateFloatingPositionInput = {
+    anchorRect: FloatingAnchorRect;
+    viewportWidth: number;
+    viewportHeight: number;
+    floatingWidth: number;
+    floatingHeight: number;
+    gap?: number;
+    preferredPlacement?: FloatingPlacement;
+};
+export type FloatingPosition = {
+    top: number;
+    left: number;
+    placement: FloatingPlacement;
+};
+export declare function calculateFloatingPosition(input: CalculateFloatingPositionInput): FloatingPosition;

package/types/packages/editor/src/components/InlineChromiumBugFix/index.d.ts

@@ -0,0 +1,2 @@
+declare const InlineChromiumBugfix: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export default InlineChromiumBugfix;

package/types/packages/editor/src/components/OverlayBackDismiss/index.d.ts

@@ -0,0 +1,4 @@
+import { type OverlayBackDismissProps } from "../../services/overlayBackDismiss";
+import React from "react";
+/** 仅在 open 期间挂载宿主登记器；未提供服务时由浮层的按钮及焦点链关闭。 */
+export default function OverlayBackDismiss(props: OverlayBackDismissProps): React.ReactElement<OverlayBackDismissProps, string | React.JSXElementConstructor<any>> | null;

package/types/packages/editor/src/hooks/useIsLastElement.d.ts

@@ -0,0 +1,3 @@
+import { Element } from "slate";
+declare const useIsLastElement: (element: Element) => boolean;
+export default useIsLastElement;

package/types/packages/editor/src/kit/elementEmpty.d.ts

@@ -0,0 +1,5 @@
+import { Element, type Descendant, type Editor } from "slate";
+import type { ElementSpec } from "../api/extension";
+export declare const registerElementEmpty: (editor: Editor, elements: readonly ElementSpec[]) => void;
+export declare const isNodeEmpty: (node: Descendant, editor?: Editor) => boolean;
+export declare const isDeclaredElementEmpty: (editor: Editor | undefined, element: Element) => boolean;

package/types/packages/editor/src/menu/conversion.d.ts

@@ -0,0 +1,3 @@
+import type { EditorMenuContribution, EditorMenuEntry } from "../api/menu";
+/** 只组合转换菜单的展示结构，源类型与具体转换由领域提供。 */
+export declare function createBlockConversionMenu(sourceTypes: readonly string[], entries: readonly EditorMenuEntry[]): Readonly<Record<string, EditorMenuContribution>>;

package/types/packages/editor/src/model/paragraph.d.ts

@@ -0,0 +1,5 @@
+import { type Node } from "slate";
+import type { ParagraphElement } from "../types/element/paragraph";
+export type { ParagraphElement } from "../types/element/paragraph";
+export declare const createParagraph: () => ParagraphElement;
+export declare const isParagraphElement: (node: Node) => node is ParagraphElement;

package/types/packages/editor/src/services/editorNotifier.d.ts

@@ -0,0 +1,4 @@
+import type { Editor } from "slate";
+import { type EditorNotifier } from "./notifier";
+/** 提示服务按编辑器绑定；服务派生后继续读取当前作用域。 */
+export declare function notifierOf(editor: Editor): EditorNotifier;

package/types/packages/editor/src/services/errorReporter.d.ts

@@ -0,0 +1,13 @@
+/** 扩展运行期错误的上报（01 §5.2）：宿主可接入自己的日志 / 提示，缺省只写控制台 */
+export interface ExtensionErrorEvent {
+    /** 出错扩展的元素 type；内核自带的快捷键记为 "editor" */
+    extension: string;
+    phase: "render" | "plugin" | "behavior" | "hotkey" | "command" | "ingest" | "copy" | "decorate";
+    error: unknown;
+    /** 这次错误是否触发熔断（该扩展的行为与快捷键此后停用） */
+    disabled: boolean;
+}
+export interface ExtensionErrorReporter {
+    report(event: ExtensionErrorEvent): void;
+}
+export declare const consoleErrorReporter: ExtensionErrorReporter;

package/types/packages/editor/src/services/hooks.d.ts

@@ -0,0 +1,11 @@
+import type { ServiceIdentifier } from "./tokens";
+import type { ServiceRegistry } from "./registry";
+import type { EditorNotifier } from "./notifier";
+/** 获取注册表本身，用于派生子注册表或非 React 场景转发 */
+export declare function useServiceRegistry(): ServiceRegistry;
+/** 获取必选服务，未注册时抛错 */
+export declare function useService<T>(id: ServiceIdentifier<T>): T;
+/** 获取可选服务，未注册时返回 undefined，由消费侧显式降级 */
+export declare function useOptionalService<T>(id: ServiceIdentifier<T>): T | undefined;
+/** 轻提示与确认：宿主没注册时用默认实现，编辑器组件不需要判空 */
+export declare function useNotifier(): EditorNotifier;

package/types/packages/editor/src/services/notifier.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 编辑器内的轻提示与确认（取代 antd message / modal）。
+ * 默认实现：提示走 `@tau/ui` 的 toast（宿主须挂 `<ToastHost />`），确认与输入走 `@tau/ui` 的对话框
+ * （编辑器自带挂载点）。有自己提示体系的宿主（mobile）注册自己的实现。
+ */
+export interface EditorNotifier {
+    success(message: string): void;
+    error(message: string): void;
+    warning(message: string): void;
+    /** 常驻的进行中提示；返回的句柄用来把同一条提示落定为成功 / 失败 */
+    loading(message: string): EditorLoadingHandle;
+    /** 危险操作的确认；用户确认返回 true */
+    confirm(options: EditorConfirmOptions): Promise<boolean>;
+    /** 单行文本输入（如媒体的网络地址）；提交返回去掉首尾空白的值，取消返回 null */
+    prompt(options: EditorPromptOptions): Promise<string | null>;
+}
+export interface EditorLoadingHandle {
+    success(message: string): void;
+    error(message: string): void;
+}
+export interface EditorConfirmOptions {
+    title: string;
+    description?: string;
+    confirmText?: string;
+    cancelText?: string;
+    danger?: boolean;
+}
+export interface EditorPromptOptions {
+    /** 发起编辑器隐藏、卸载或换源时取消；宿主须关闭对应输入框并返回 null。 */
+    signal?: AbortSignal;
+    title: string;
+    placeholder?: string;
+    defaultValue?: string;
+    confirmText?: string;
+    cancelText?: string;
+    /** 虚拟键盘类型（同 HTML inputMode）：url 让手机弹出网址键盘 */
+    inputMode?: "text" | "url";
+    /**
+     * 提交前校验（入参已去首尾空白，空值不会进来）：返回错误文案则输入框保持打开并就地提示。
+     * 须是纯判断——输入框可能多次提交，副作用放在 prompt resolve 之后。
+     */
+    validate?: (value: string) => string | undefined;
+}
+/** 菜单构建函数等只需要结果反馈的地方收这个窄接口 */
+export type EditorFeedback = Pick<EditorNotifier, "success" | "error" | "warning">;
+export declare const defaultEditorNotifier: EditorNotifier;

package/types/packages/editor/src/services/overlayBackDismiss.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentType } from "react";
+export interface OverlayBackDismissProps {
+    open: boolean;
+    onDismiss: () => void;
+}
+export interface OverlayBackDismissAdapter {
+    /** 在当前编辑器所在的页面上下文登记退场；不渲染 UI，不监听全局按键。 */
+    Layer: ComponentType<OverlayBackDismissProps>;
+}
+export declare const IOverlayBackDismiss: import("../../../shared/service-contract").ServiceIdentifier<OverlayBackDismissAdapter>;

package/types/packages/editor/src/services/registry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 服务注册表实现已下沉到 @tau/shared/service-registry（编辑器与白板等宿主共用），
+ * 此处保留原导入路径与公共 API 不变。
+ */
+export { createServiceRegistry, createChildRegistry } from "../../../shared/service-registry";
+export type { ServiceRegistry, ServiceRegister, ServiceRegistration, } from "../../../shared/service-registry";

package/types/packages/editor/src/services/tokens.d.ts

@@ -0,0 +1,10 @@
+import type { ThemeService } from "../theme/ThemeService";
+import type { ExtensionErrorReporter } from "./errorReporter";
+import type { EditorNotifier } from "./notifier";
+export { createServiceId, type ServiceIdentifier } from "../../../shared/service-contract";
+/** 主题服务：未注册时编辑器用 DOM 默认实现（读 <html> 的 data-mode / data-theme） */
+export declare const IThemeService: import("../../../shared/service-contract").ServiceIdentifier<ThemeService>;
+/** 轻提示与确认：未注册时用 @tau/ui 的 toast（宿主需挂 ToastHost）与原生 confirm */
+export declare const IEditorNotifier: import("../../../shared/service-contract").ServiceIdentifier<EditorNotifier>;
+/** 扩展运行期错误上报：未注册时写控制台 */
+export declare const IExtensionErrorReporter: import("../../../shared/service-contract").ServiceIdentifier<ExtensionErrorReporter>;

package/types/packages/editor/src/theme/ThemeService.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 主题服务：编辑器读取「当前明暗」与「token 实际取值」的唯一入口。
+ *
+ * CSS 能表达的地方一律写 --ed-*（见 editor.css），不必经过本服务；本服务服务于 CSS 表达不了
+ * 的场景：mermaid / shiki / codemirror / canvas 这类要把颜色当值传进去的渲染器。
+ */
+export type EditorThemeMode = "light" | "dark";
+export interface ThemeService {
+    /** 生效明暗 */
+    readonly mode: EditorThemeMode;
+    /** 宿主当前主题族的 key（桌面 paper/ocean…，移动端 apricot/midnight…）；宿主未标注时为空串 */
+    readonly themeKey: string;
+    /** 读取 CSS 变量的计算值，传入不带 `--` 的词（`ink-1` 取 --tau-ink-1，`code-bg` 取 --ed-code-bg） */
+    token(word: string): string;
+    /** 主题变化时通知；返回取消订阅 */
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * 默认实现：明暗与主题族从 DOM 读（`data-mode` / `data-theme`），token 取计算样式。
+ * 传入 scope 可让 token 从编辑器子树读起（局部强制明暗的场景）。
+ */
+export declare function createDomThemeService(root?: HTMLElement, scope?: () => HTMLElement | null): ThemeService;
+/** 固定明暗的实现：预览、导出、测试等不跟随宿主的场景 */
+export declare function createStaticThemeService(mode: EditorThemeMode, tokens?: Record<string, string>): ThemeService;

package/types/packages/editor/src/theme/context.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from "react";
+import { type EditorThemeMode, type ThemeService } from "./ThemeService";
+/** 宿主用：让子树里的编辑器按给定明暗 / 主题族渲染，不跟随宿主；缺省的维度不覆盖 */
+export declare function EditorThemeOverride({ mode, themeKey, children, }: {
+    mode?: EditorThemeMode;
+    themeKey?: string;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** 编辑器内部用：确定本编辑器的主题服务，并告知根节点是否要补作用域属性 */
+export declare function EditorThemeScope({ service, children, }: {
+    /** 服务注册表里的 IThemeService；上下文里有服务时以上下文为准 */
+    service?: ThemeService;
+    children: (scope: {
+        themeKey: string;
+        mode: EditorThemeMode;
+        overridden: boolean;
+    }) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export interface EditorTheme {
+    mode: EditorThemeMode;
+    isDark: boolean;
+    /** 读取 token 实际取值，给 mermaid / shiki / canvas 这类需要色值的渲染器用 */
+    token: (word: string) => string;
+}
+/** 编辑器内部读主题：明暗 + token 取值。未挂载 Editor 时回落 DOM 实现。 */
+export declare function useEditorTheme(): EditorTheme;

package/types/packages/editor/src/types/block-panel.d.ts

@@ -0,0 +1,12 @@
+import { Editor } from "slate";
+import React from "react";
+export interface IBlockPanelListItem {
+    icon: React.ComponentType<{
+        className?: string;
+    }>;
+    title: string;
+    keywords: string[];
+    description: string;
+    onClick?: (editor: Editor) => void;
+    children?: IBlockPanelListItem[];
+}

package/types/packages/editor/src/types/custom-element.d.ts

@@ -0,0 +1,10 @@
+import type { ParagraphElement } from "./element/paragraph";
+import type { FormattedText } from "./text";
+import type { ExtensionElementMap, ExtensionInlineElementMap } from "../../api";
+export interface BuiltinElementMap {
+    paragraph: ParagraphElement;
+}
+export type CustomElement = (BuiltinElementMap & ExtensionElementMap)[keyof (BuiltinElementMap & ExtensionElementMap)];
+export type InlineElement = ExtensionInlineElementMap[keyof ExtensionInlineElementMap];
+export type CustomText = FormattedText;
+export type BlockElement = Exclude<CustomElement, InlineElement>;

package/types/packages/editor/src/types/editor.d.ts

@@ -0,0 +1,37 @@
+import { BaseEditor, Editor as SlateEditor, Point } from "slate";
+import { ReactEditor } from "slate-react";
+import { HistoryEditor } from "slate-history";
+import { CustomElement, CustomText } from "./custom-element";
+import type { ServiceIdentifier } from "../services/tokens";
+export type CustomField = {
+    type: string;
+    /** 非React插件代码获取必选服务，未注册时抛错 */
+    getService: <T>(id: ServiceIdentifier<T>) => T;
+    /** 非React插件代码获取可选服务，未注册时返回 undefined */
+    tryGetService: <T>(id: ServiceIdentifier<T>) => T | undefined;
+    /** 拖放落点交认领管线（withIngest）分发 */
+    handleDrop: (data: DataTransfer, point: Point) => Promise<void>;
+    /** 命令注册表的程序化入口（api/command.ts）；热键、菜单、宿主统一经它执行 */
+    commands?: import("../api/command").EditorCommandsHandle;
+};
+export type CustomEditor = BaseEditor & ReactEditor & HistoryEditor & CustomField;
+/**
+ * Editor component ref interface exposed via forwardRef
+ */
+export interface EditorRef {
+    /** Focus the editor and move cursor to the end */
+    focus: () => void;
+    /** Deselect the current selection */
+    deselect: () => void;
+    /** Get the underlying Slate editor instance */
+    getEditor: () => SlateEditor;
+    /** Check if the editor is currently focused */
+    isFocus: () => boolean;
+}
+declare module "slate" {
+    interface CustomTypes {
+        Editor: CustomEditor;
+        Element: CustomElement;
+        Text: CustomText;
+    }
+}

package/types/packages/editor/src/types/element/paragraph.d.ts

@@ -0,0 +1,6 @@
+import type { InlineElement } from "../custom-element";
+import type { FormattedText } from "../text";
+export interface ParagraphElement {
+    type: "paragraph";
+    children: Array<InlineElement | FormattedText>;
+}

package/types/packages/editor/src/types/hotkeys.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from "slate";
+import React from "react";
+export type IHotKeyConfig = {
+    hotKey: string | string[];
+    action: (editor: Editor, event: React.KeyboardEvent<HTMLDivElement>) => void;
+};

package/types/packages/editor/src/types/hovering-bar.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export interface IConfigItem {
+    id: string;
+    element: React.FC;
+    order: number;
+    /** 紧凑工具条的展示分组；未声明时保持独立条目。 */
+    compactGroup?: "text-style" | "more";
+}

package/types/packages/editor/src/types/index.d.ts

@@ -0,0 +1,7 @@
+export type { ParagraphElement } from "./element/paragraph";
+export type { FormattedText } from "./text";
+export * from "./editor";
+export * from "./block-panel";
+export * from "./hovering-bar";
+export * from "./hotkeys";
+export * from "./custom-element";

package/types/packages/editor/src/types/text.d.ts

@@ -0,0 +1 @@
+export type { FormattedText } from "../../../markdown/src/model";

package/types/packages/editor/src/types.d.ts

@@ -0,0 +1 @@
+export * from "./types/index";

package/types/packages/editor/src/ui/CaretRight.d.ts

@@ -0,0 +1,3 @@
+import type { SVGProps } from "react";
+/** 实心右三角（折叠箭头）；随字号缩放，展开时由调用方旋转 90° */
+export declare function CaretRight({ className, ...props }: SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;

package/types/packages/editor/src/ui/Tooltip.d.ts

@@ -0,0 +1,7 @@
+import { type TooltipProps } from "../../../ui/src/index";
+/**
+ * 编辑器内的提示：外观同 @tau/ui，层级抬到悬浮工具条（z 9999）与编辑器浮层（~10100）之上，
+ * 否则工具条按钮的提示会被工具条自身盖住。
+ */
+export declare function Tooltip({ className, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export type { TooltipProps };

package/types/packages/editor/src/utils/blockNavigation.d.ts

@@ -0,0 +1,28 @@
+import { Editor, Element as SlateElement, NodeEntry, Path } from "slate";
+import type { ElementSpec } from "../api/extension";
+export declare const registerBlockNavigationBoundaries: (editor: Editor, elements: readonly ElementSpec[]) => void;
+export type BlockFocusPosition = "start" | "end";
+export type BlockNavigationReason = "delete" | "arrow" | "enter";
+export type BlockNavigationDirection = "backward" | "forward";
+export interface BlockNavigationMeta {
+    reason: BlockNavigationReason;
+    direction: BlockNavigationDirection;
+}
+export interface BlockFocusContext {
+    editor: Editor;
+    element: SlateElement;
+    meta: BlockNavigationMeta;
+}
+export type BlockFocusHandler = (context: BlockFocusContext) => boolean;
+export interface BlockNavigationHandler {
+    focusStart?: BlockFocusHandler;
+    focusEnd?: BlockFocusHandler;
+}
+export declare const registerBlockNavigation: (element: SlateElement, handler: BlockNavigationHandler) => void;
+export declare const unregisterBlockNavigation: (element: SlateElement) => void;
+export declare const hasBlockNavigation: (element: SlateElement) => boolean;
+export declare const focusElementByNavigator: (editor: Editor, element: SlateElement, position: BlockFocusPosition, meta: BlockNavigationMeta) => boolean;
+export declare const getSiblingBlockEntry: (editor: Editor, fromPath: Path, direction: BlockNavigationDirection) => NodeEntry<import("../../api").ParagraphElement> | undefined;
+export declare const focusPreviousBlock: (editor: Editor, fromPath: Path, meta: BlockNavigationMeta) => boolean;
+export declare const focusNextBlock: (editor: Editor, fromPath: Path, meta: BlockNavigationMeta) => boolean;
+export declare const hasBlockNavigationBoundary: (editor: Editor, path: Path) => boolean;

package/types/packages/editor/src/utils/commandTarget.d.ts

@@ -0,0 +1,4 @@
+import { Editor, type Path } from "slate";
+import type { EditorCommandContext } from "../api/command";
+/** 写入命令必须命中仍在当前文档中的原元素，菜单保存的旧路径不能指向替代节点。 */
+export declare function getCommandElementPath(editor: Editor, context: EditorCommandContext): Path | null;

package/types/packages/editor/src/utils/container.d.ts

@@ -0,0 +1,3 @@
+import { Editor, NodeEntry } from "slate";
+export declare const exitContainerOnEmptyParagraph: (editor: Editor, parentType: string) => boolean;
+export declare const hitEmptyOrInlineChild: (editor: Editor, [node, path]: NodeEntry, parentType: string) => boolean;

package/types/packages/editor/src/utils/editor.d.ts

@@ -0,0 +1,16 @@
+import { Editor, Node, Element, NodeMatch, NodeEntry, Path } from "slate";
+import { ParagraphElement, BlockElement } from "../types";
+export declare const getCurrentTextNode: (editor: Editor) => NodeEntry<Node>;
+export declare const getClosestCurrentElement: (editor: Editor) => NodeEntry<BlockElement>;
+export declare const getLeafParent: (editor: Editor) => NodeEntry<import("slate").Ancestor> | undefined;
+export declare const getElementParent: (editor: Editor) => NodeEntry<import("slate").Ancestor> | undefined;
+export declare const isAtParagraphStart: (editor: Editor) => boolean;
+export declare const insertParagraphAndFocus: (editor: Editor, node: Element) => Path | null;
+export declare const replaceNode: (editor: Editor, node: Node, match: NodeMatch<Node>, options?: {}) => Path | undefined;
+export declare const isParagraphAndEmpty: (editor: Editor) => boolean;
+export declare const isCollapsed: (editor: Editor) => boolean;
+export declare const getCurrentEmptyNode: (editor: Editor) => NodeEntry<ParagraphElement> | undefined;
+export declare const focusBlockElement: (editor: Editor, node: Node) => void;
+export declare const removeCurrentEmptyNodeAndFocusPreviousNode: (editor: Editor) => void;
+export declare const isFirstChild: (editor: Editor, node: Node) => boolean;
+export declare const isLastChild: (editor: Editor, node: Node) => boolean;

package/types/packages/editor/src/utils/element.d.ts

@@ -0,0 +1,11 @@
+import { CustomElement } from "../types";
+import { Node, Editor } from "slate";
+import { isNodeEmpty } from "../kit/elementEmpty";
+export { isParagraphElement } from "../model/paragraph";
+export declare const isLeafNode: (node: Node) => boolean;
+export declare const isElementNode: (node: Node) => node is CustomElement;
+export declare const getParentNodeByNode: (editor: Editor, node: Node) => import("slate").NodeEntry<import("slate").Ancestor>;
+export declare const getPreviousSiblingNode: (editor: Editor, node: Node) => import("slate").NodeEntry | null;
+export { isNodeEmpty };
+export declare const isInlineElementEmpty: (node: import("slate").Descendant, editor?: Editor) => boolean;
+export declare const isBlockElementEmpty: (node: import("slate").Descendant, editor?: Editor) => boolean;

package/types/packages/editor/src/utils/insertElement.d.ts

@@ -0,0 +1,11 @@
+import { Editor, Path } from "slate";
+import { BlockElement } from "../types";
+interface InsertElementOptions {
+    select?: boolean;
+    reverse?: boolean;
+}
+export declare const focusInsertedPreviewElement: (editor: Editor, path?: Path, retry?: number) => void;
+/** 当前选区能否 setOrInsertNode：需折叠且落在段落内（先问再弹输入框等场景用） */
+export declare const canSetOrInsertNode: (editor: Editor) => boolean;
+export declare const setOrInsertNode: (editor: Editor, node: BlockElement, options?: InsertElementOptions) => Path | undefined;
+export {};

package/types/packages/editor/src/utils/nodeOperations.d.ts

@@ -0,0 +1,19 @@
+import { Editor, Node, Path } from "slate";
+import type { EditorFeedback } from "../services/notifier";
+/**
+ * 复制节点到剪贴板
+ * 支持两种格式：JSON 和纯文本
+ */
+export declare function copyNodeToClipboard(_editor: Editor, element: Node, message?: EditorFeedback, options?: {
+    allowPlainTextFallback?: boolean;
+    signal?: AbortSignal;
+}): Promise<boolean>;
+/**
+ * 删除节点
+ * 如果是最后一个节点，则清空内容而不删除节点本身
+ */
+export declare function deleteNode(editor: Editor, path: Path): void;
+/**
+ * 删除 void 块并补一个空段落承接焦点（图片 / 音视频 / 代码块等不可聚焦块的统一删除语义）
+ */
+export declare function deleteVoidBlock(editor: Editor, path: Path): void;

package/types/packages/editor/src/utils/paragraphShortcut.d.ts

@@ -0,0 +1,4 @@
+import { Editor, type NodeEntry } from "slate";
+import type { FormattedText } from "../types/text";
+/** 空格触发的段落快捷语法只读取段落首个文本节点，语法判断由扩展负责。 */
+export declare function getParagraphShortcutEntry(editor: Editor, text: string): NodeEntry<FormattedText> | undefined;

package/types/packages/editor/src/utils/path.d.ts

@@ -0,0 +1,6 @@
+import { Editor, Node, Path } from "slate";
+export declare const getPrevPath: (path: Path) => Path | undefined;
+export declare const getNextPath: (path: Path) => Path;
+export declare const getParentPath: (path: Path) => number[];
+export declare const findPathSafely: (editor: Editor, node: Node) => Path | undefined;
+export declare const getNodeAtPathSafely: (editor: Editor, path: Path) => Node | undefined;

package/types/packages/editor/src/utils/plugin.d.ts

@@ -0,0 +1,4 @@
+import { Editor } from "slate";
+/** 原始 Slate 插件：受信任层（ER-005），只给表达不了声明式行为的编辑器级改写用 */
+export type Plugin = (editor: Editor) => Editor;
+export declare const applyPlugin: (editor: Editor, plugins: Plugin[]) => import("../types").CustomEditor;

package/types/packages/editor/src/utils/selectionSnapshot.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from "slate";
+export declare const getSelectionSnapshot: (selection: Editor["selection"]) => string | null;
+export declare const isSelectionSnapshotUnchanged: (editor: Editor, expectedSnapshot: string | null) => boolean;

package/types/packages/editor/src/utils/zoomPan.d.ts

@@ -0,0 +1,14 @@
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * 以某点为锚缩放时的新平移量：锚点下的内容保持不动。
+ * 坐标都相对舞台中心，内容以 `translate(pan) scale(zoom)` 摆放、变换原点在中心。
+ */
+export declare const panAroundAnchor: (pan: Point, zoom: number, nextZoom: number, anchor: Point) => Point;
+/** 指针事件相对元素中心的坐标 */
+export declare const pointFromCenter: (element: HTMLElement, event: {
+    clientX: number;
+    clientY: number;
+}) => Point;

package/types/packages/markdown/src/codec.d.ts

@@ -0,0 +1,86 @@
+import type { Descendant, Element } from "slate";
+import type { MarkdownSerializer } from "./markdownSerializerRegistry";
+/** 业务 directive 解析器：键为 directive 名，返回 null 视为丢弃该节点 */
+export type CustomDirectiveHandler = (attributes: Record<string, string | undefined>) => Descendant | null;
+/** mdast 节点（remark 解析产物）的最小形状，importNode 认领时只允许读这些字段 */
+export interface MarkdownImportNode {
+    type: string;
+    value?: string;
+    url?: string;
+    alt?: string;
+    lang?: string;
+    meta?: string;
+    depth?: 1 | 2 | 3 | 4 | 5 | 6;
+    ordered?: boolean;
+    identifier?: string;
+    htmlType?: "block" | "inline";
+    attributes?: Record<string, string | undefined>;
+    children?: MarkdownImportNode[];
+    [key: string]: unknown;
+}
+/** importNode 的认领上下文：块级 / 行内判断与脚注取值用 */
+export interface MarkdownImportContext {
+    parent: MarkdownImportNode | null;
+    siblings: readonly MarkdownImportNode[];
+    /** 脚注定义正文（footnoteReference 认领方用） */
+    getFootnote: (identifier: string) => string;
+}
+/**
+ * 一个元素类型的 Markdown 编解码（01 §8.2）。框架不自带任何元素类型：
+ * 各扩展在自己的 markdown.ts（纯函数文件）里声明 codec，宿主把 codec 列表
+ * 合成一次交给 createMarkdownProcessor，kit 与 Electron 主进程共用。
+ */
+export interface MarkdownCodec {
+    /** 元素 type */
+    type: string;
+    /** 导入：按 directive 名解析（container / leaf / text 三种都查），优先于内置分支 */
+    directives?: Record<string, CustomDirectiveHandler>;
+    /**
+     * 导入：声明式围栏认领——```lang 的代码围栏映射为 { type, [property]: 源码 }。
+     * 语言小写匹配；同一语言被两个 codec 认领时建处理器直接报错
+     */
+    fence?: {
+        language: string | readonly string[];
+        /** 源码落进元素的字段名，默认 "content"（mermaid 用 "chart"） */
+        property?: string;
+    };
+    /**
+     * 导入：通用 mdast 认领。返回元素（children 留空，由框架回填）或 null（不认领）。
+     * 按声明顺序遍历、首个认领生效——宽认领（如 code-block 认领所有 code 节点）
+     * 必须排在窄认领之后，由聚合列表的顺序保证
+     */
+    importNode?: (node: MarkdownImportNode, context: MarkdownImportContext) => Descendant | null;
+    /** 导出 */
+    serializer?: Omit<MarkdownSerializer, "type">;
+    /** void 元素：位置映射只记元素级范围（导入、导出两个方向都生效） */
+    isVoid?: boolean;
+    /**
+     * 行内包裹：导入时该 text directive 的子文本按 directive 整体范围记前后缀（位置映射用），
+     * 值为 directive 名
+     */
+    inlineWrapperDirective?: string;
+    /** 配对 HTML 标签的行内认领；框架匹配同名嵌套标签并回填 children，领域负责创建节点。 */
+    inlineHtmlWrapper?: {
+        tag: string;
+        create: (opening: MarkdownImportNode) => Element;
+    };
+    /** 导入后规范化：返回替换本元素的序列（空数组 = 删除）或 null（保持原样） */
+    normalize?: (element: any, context: {
+        parent: Descendant | null;
+        previousSibling: Descendant | null;
+        nextSibling: Descendant | null;
+        /** 把块级子元素降级为行内形态（image→inline-image、html-block→html-inline），无声明则原样返回 */
+        demote: (child: Descendant) => Descendant;
+    }) => Descendant[] | null;
+    /** 按目标类型贡献规范化，先于该类型自身 normalize；按 codec 顺序首个非 null 替换生效。 */
+    normalizeFor?: Readonly<Record<string, NonNullable<MarkdownCodec["normalize"]>>>;
+    /** 段落内行内形态的构造（导入规范化时框架经 ctx.demote 调用） */
+    inlineForm?: (element: any) => Descendant;
+    /**
+     * 导入：从 code 节点（围栏或缩进代码块）认领的 void 元素，把源码区间记为
+     * 该属性的属性级位置映射（如 code-block 的 "code"）；缺省只有元素级映射
+     */
+    fenceSourceProperty?: string;
+    /** 导出：子块级元素之间的接续符，默认 "\n\n"；列表与表格声明 "\n" */
+    childSeparator?: "\n" | "\n\n";
+}

package/types/packages/markdown/src/index.d.ts

@@ -0,0 +1,7 @@
+export { createMarkdownProcessor, type MarkdownProcessor, type MarkdownProcessorOptions, } from "./processor";
+export type { MarkdownTextCodec, MarkdownTextRule, LeafSerializationResult } from "./textCodec";
+export type { MarkdownCodec, CustomDirectiveHandler, MarkdownImportNode, MarkdownImportContext, } from "./codec";
+export { isMarkdownLikeText, type ImportFromMarkdownOptions, type SlateWithPositions, } from "./markdown";
+export { addExportFootnote, type MarkdownWithPositions } from "./markdown-helper";
+export { MarkdownSerializerRegistry, type MarkdownSerializer, type SerializerOutput, } from "./markdownSerializerRegistry";
+export { PositionMapper, type MarkdownPosition, type SlatePosition, type TextMapping, type ElementMapping, type PositionMapping, } from "./positionMapper";

package/types/packages/markdown/src/markdown-helper.d.ts

@@ -0,0 +1,28 @@
+import type { Descendant } from "slate";
+import type { CustomElement } from "./types";
+import type { MarkdownSerializerRegistry } from "./markdownSerializerRegistry";
+import { PositionMapper } from "./positionMapper";
+import type { MarkdownTextRegistry } from "./textCodec";
+/** 处理器级导出配置：注册表 + void 类型表 + 子元素接续表（内置 + 宿主 codec） */
+export interface ExportConfig {
+    textRegistry: MarkdownTextRegistry;
+    registry: MarkdownSerializerRegistry;
+    voidTypes: ReadonlySet<string>;
+    /** 元素类型的子块级接续符（列表 / 表格为 "\n"，缺省 "\n\n"） */
+    childSeparators: ReadonlyMap<string, "\n" | "\n\n">;
+}
+/** codec 的序列化器登记脚注（如 annotation 的 [^n]），由导出入口统一追加到文末 */
+export declare const addExportFootnote: (content: string) => number;
+export declare const getMarkdownUsing: (config: ExportConfig, value: Descendant[]) => string;
+export declare const elementToMarkdownUsing: (config: ExportConfig, element: CustomElement, parentElement: CustomElement | null) => string;
+/**
+ * 带位置信息的 Markdown 输出
+ */
+export interface MarkdownWithPositions {
+    markdown: string;
+    positionMap: PositionMapper;
+}
+/**
+ * 带位置跟踪的序列化函数（重新设计）
+ */
+export declare const getMarkdownWithPositionsUsing: (config: ExportConfig, value: Descendant[]) => MarkdownWithPositions;