@effitor/assist-ai 0.2.0

package/README.md

@@ -0,0 +1 @@
+# @effitor/assist-ai

package/dist/index.css

@@ -0,0 +1,35 @@
+
+#Et_ai-deco {
+  display: none;
+  position: fixed;
+  top: 0;
+  left: 0;
+  min-height: 1em;
+  z-index: 9999;
+
+  &.Et_ai-mask {
+    width: 48px;
+    background-image: linear-gradient(to right, transparent, var(--et-color-bg));
+    transform: translateX(-36px);
+  }
+
+  &.Et_ai-caret {
+    /* 需给编辑器设置 caret-color: transparent 隐藏原生光标 */
+    &::after {
+      content: '';
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      right: 0;
+      border-right: 1px solid;
+      filter: brightness(2);
+      animation: caret-blink 1s steps(1) infinite;
+    }
+  }
+}
+
+@keyframes caret-blink {
+  50% {
+    opacity: 0;
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,119 @@
+import { Et } from '@effitor/core';
+
+type MarkdownTextMapping = Record<string, MarkdownTextMappingFn> & {
+    beforeStart?: (ctx: Et.EditorContext) => null;
+    afterEnd?: (ctx: Et.EditorContext) => null;
+};
+interface MarkdownTextMappingFn {
+    /**
+     * 处理markdown特殊字符; 如连续的**, 要转为加粗, 而不是插入两个*
+     * @param index 当前字符在文本中的索引
+     * @param text 完整文本
+     * @returns 映射结果
+     */
+    (ctx: Et.EditorContext, index: number, text: string): MarkdownTextMappingFnResult;
+}
+/**
+ * 返回null, 无特殊处理\
+ * 返回{ key, data, nextIndex }, 表示将char替换为按下key或输入data, 并将索引设置到nextIndex;
+ * 返回(ctx: Et.EditorContext) => number, 表示自行处理, 返回下一个索引
+ */
+type MarkdownTextMappingFnResult = null | ((ctx: Et.EditorContext) => number) | {
+    /** keydown的key值 或 beforeinput输入的data文本 */
+    value: string;
+    /** 映射类型, 表示value是keydown的key值 还是 beforeinput输入的data文本 */
+    type: 'key' | 'data';
+    /**
+     * 下一个输入的起始索引, 若该索引不是某个字素的首个字符索引, 则索引所在的整个字素会被跳过;
+     * 正常来讲, 要跳过`n`个字符(包括当前char) 就返回 `index + n` 即可
+     */
+    nextIndex: number;
+};
+interface CreateEffitorAIOptions {
+    /** 是否显示打字机效果的mask */
+    typingMask?: boolean;
+    /** 是否显示打字机效果的光标 */
+    typingCaret?: boolean;
+    /** 要添加的Markdown特殊字符的映射函数 */
+    markdownTextMappings?: MarkdownTextMapping[];
+}
+
+interface TypingResult {
+    /** 输入结果Promise, 完成时fulfilled, 失败时rejected */
+    finished: Promise<void>;
+    /** 暂停输入 */
+    pause: () => void;
+    /** 恢复输入 */
+    resume: () => void;
+    /** 取消后续输入 */
+    cancel: () => void;
+}
+type TypingMarkdownArray = readonly (readonly [number, number, boolean, string])[];
+declare class EffitorAI {
+    private readonly _ctx;
+    private _markdownTextMapping;
+    private _useDeco;
+    private readonly _beforeCallbacks;
+    private readonly _afterCallbacks;
+    private readonly _maskEl;
+    constructor(_ctx: Et.EditorContext, options?: CreateEffitorAIOptions);
+    /**
+     * 添加Markdown特殊字符的映射函数; 当先添加的映射函数返回值非null时, 后续映射函数将不会被调用
+     * @param mapping 映射对象
+     */
+    addMarkdownTextMapping(mapping: MarkdownTextMapping): void;
+    /**
+     * 设置Markdown特殊字符的映射函数; 已存在会被覆盖
+     * @param char 特殊字符
+     * @param mappingFn 映射函数
+     */
+    setMarkdownTextMapping(char: string, mappingFn: MarkdownTextMappingFn): void;
+    setTypingDeco(typingCaret?: boolean, typingMask?: boolean): void;
+    /**
+     * 将Markdown内容依次输入到编辑器中
+     * * 目前此方法直接触发相关事件，依据当前光标位置插入内容；调用者需保证整个typing过程中，
+     *   编辑器内的光标不被意外的干扰，否则可能导致插入内容错误
+     * @param mdText Markdown文本；
+     *               在文本中，可用\x00引导一个按键，如："\x00KeyZ,1000{21}"表示按下 Ctrl+Z 21 次；
+     *               修饰键用 4 个二进制位表示，顺序依次为：Ctrl, Shift, Alt, Meta
+     * @param byWord 是否按单词输入, 默认为true
+     * @param delay 每个字符之间的延迟时间（毫秒）,最小值为30（默认 50ms）
+     */
+    typingMarkdown(mdText: string, byWord?: boolean, delay?: number): TypingResult;
+    /**
+     * 将Markdown内容依次输入到编辑器中
+     * * 目前此方法直接触发相关事件，依据当前光标位置插入内容；调用者需保证整个typing过程中，
+     *   编辑器内的光标不被意外的干扰，否则可能导致插入内容错误
+     * @param mdArray 输入数组, 每个元素为 [本轮结束后延迟, 每次输入延迟, 是否按单词输入, Markdown文本]
+     */
+    typingMarkdown(mdArray: TypingMarkdownArray): TypingResult;
+    private _genMdText;
+    private _startTyping;
+    private _stopTyping;
+    private _runBeforeCallbacks;
+    private _runAfterCallbacks;
+    private _startMask;
+    private _stopMask;
+    private _updateMask;
+    typeKey(init: KeyboardEventInit): void;
+    typeText(data: string): void;
+}
+
+declare const mappingForBlockquote: MarkdownTextMapping;
+
+declare const mappingForCode: MarkdownTextMapping;
+
+declare const mappingForList: MarkdownTextMapping;
+
+declare const mappingForMark: MarkdownTextMapping;
+
+declare module '@effitor/core' {
+    interface EditorAssists {
+        ai: EffitorAI;
+    }
+}
+
+type AIAssistOptions = {} & CreateEffitorAIOptions;
+declare const useAIAssist: (options?: AIAssistOptions) => Et.EditorPlugin;
+
+export { type AIAssistOptions, type TypingMarkdownArray, type TypingResult, mappingForBlockquote, mappingForCode, mappingForList, mappingForMark, useAIAssist };

package/dist/index.js

@@ -0,0 +1,698 @@
+// src/index.ts
+import "./index.css";
+
+// src/EffitorAI.ts
+import { reduceFnMappings } from "@effitor/core";
+
+// src/mapping/builtin.ts
+var builtinMapping = {
+  "\\": (_, i, s) => {
+    const n = s[i + 1];
+    if (n === "*" || n === "`" || n === "_" || n === "\\" || n === "=" || n === "~") {
+      return {
+        value: n,
+        type: "data",
+        nextIndex: i + 2
+      };
+    }
+    if (n === "\n") {
+      return (ctx) => {
+        ctx.body.dispatchInputEvent("beforeinput", { inputType: "insertLineBreak" });
+        return i + 2;
+      };
+    }
+    return null;
+  },
+  " ": (_, i, s) => {
+    if (s[i + 1] === " " && s[i + 2] === "\n") {
+      return (ctx) => {
+        ctx.body.dispatchInputEvent("beforeinput", { inputType: "insertLineBreak" });
+        return i + 2;
+      };
+    }
+    return null;
+  },
+  "\n": (ctx, i, s) => {
+    if (s[i + 1] === "\n" && ctx.isPlainParagraph(ctx.focusParagraph)) {
+      return (ctx2) => {
+        ctx2.body.dispatchInputEvent("beforeinput", { inputType: "insertParagraph" });
+        return i + 2;
+      };
+    }
+    return {
+      value: "Enter",
+      type: "key",
+      nextIndex: i + 1
+    };
+  },
+  "	": (_, i) => {
+    return {
+      value: "Tab",
+      type: "key",
+      nextIndex: i + 1
+    };
+  }
+};
+
+// src/EffitorAI.ts
+var EffitorAI = class {
+  constructor(_ctx, options = {}) {
+    this._ctx = _ctx;
+    const mappings = [
+      ...options.markdownTextMappings || [],
+      builtinMapping
+    ].map((map) => {
+      const { beforeStart, afterEnd, ...rest } = map;
+      if (beforeStart) this._beforeCallbacks.push(beforeStart);
+      if (afterEnd) this._afterCallbacks.push(afterEnd);
+      return rest;
+    });
+    this._markdownTextMapping = reduceFnMappings(
+      mappings,
+      true
+    );
+    const mask = document.createElement("div");
+    mask.id = "Et_ai-deco" /* Id_Deco */;
+    if (options.typingCaret) {
+      this._useDeco = true;
+      mask.classList.add("Et_ai-caret" /* Class_Caret */);
+    }
+    if (options.typingMask) {
+      this._useDeco = true;
+      mask.classList.add("Et_ai-mask" /* Class_Mask */);
+    }
+    this._ctx.root.appendChild(mask);
+    this._maskEl = mask;
+  }
+  _markdownTextMapping;
+  _useDeco = false;
+  _beforeCallbacks = [];
+  _afterCallbacks = [];
+  _maskEl;
+  /**
+   * 添加Markdown特殊字符的映射函数; 当先添加的映射函数返回值非null时, 后续映射函数将不会被调用
+   * @param mapping 映射对象
+   */
+  addMarkdownTextMapping(mapping) {
+    if (!Object.keys(this._markdownTextMapping).length) {
+      Object.assign(this._markdownTextMapping, mapping);
+      return;
+    }
+    const { beforeStart, afterEnd, ...rest } = mapping;
+    if (beforeStart) this._beforeCallbacks.push(beforeStart);
+    if (afterEnd) this._afterCallbacks.push(afterEnd);
+    this._markdownTextMapping = reduceFnMappings([this._markdownTextMapping, rest], true);
+  }
+  /**
+   * 设置Markdown特殊字符的映射函数; 已存在会被覆盖
+   * @param char 特殊字符
+   * @param mappingFn 映射函数
+   */
+  setMarkdownTextMapping(char, mappingFn) {
+    this._markdownTextMapping[char] = mappingFn;
+  }
+  setTypingDeco(typingCaret = false, typingMask = false) {
+    this._useDeco = typingCaret || typingMask;
+    this._maskEl.classList.toggle("Et_ai-caret" /* Class_Caret */, typingCaret);
+    this._maskEl.classList.toggle("Et_ai-mask" /* Class_Mask */, typingMask);
+  }
+  typingMarkdown(mdTextOrArray, byWord = true, delay = 50) {
+    if (delay && delay < 30) {
+      delay = 30;
+    }
+    if (typeof mdTextOrArray === "string") {
+      mdTextOrArray = [[0, delay, byWord, mdTextOrArray]];
+    }
+    const state = {
+      canceled: Promise.resolve(false),
+      timer: 0,
+      pause: void 0,
+      resume: void 0,
+      doJob: void 0,
+      rejectJob: void 0,
+      cancelRun: void 0
+    };
+    const isReadonly = this._ctx.editor.status.readonly;
+    const run = async () => {
+      if (await state.canceled) return Promise.reject();
+      if (await state.canceled) return Promise.reject();
+      if (!isReadonly) {
+        this._ctx.editor.setReadonly(true);
+      }
+      this._startTyping();
+      for (const [perDelay, charDelay, byWord2, mdText] of mdTextOrArray) {
+        delay = charDelay;
+        const gen = this._genMdText(mdText, byWord2);
+        if (await state.canceled) return Promise.reject();
+        await new Promise((res, rej) => {
+          state.rejectJob = rej;
+          state.doJob = () => {
+            const timer = state.timer = window.setInterval(async () => {
+              if ((await gen.next()).done) {
+                res();
+                clearInterval(timer);
+              }
+            }, delay);
+          };
+          state.doJob();
+        });
+        await new Promise((res) => setTimeout(res, perDelay));
+      }
+    };
+    state.pause = () => {
+      const _pause = state.pause;
+      state.pause = void 0;
+      clearInterval(state.timer);
+      state.canceled = new Promise((res) => {
+        state.cancelRun = () => res(true);
+        state.resume = () => {
+          state.pause = _pause;
+          state.resume = void 0;
+          res(false);
+          state.doJob?.();
+        };
+      });
+    };
+    return {
+      finished: run().finally(() => {
+        if (!isReadonly) {
+          this._ctx.editor.setReadonly(false);
+        }
+        this._stopTyping();
+      }),
+      pause: () => state.pause?.(),
+      resume: () => state.resume?.(),
+      cancel: () => {
+        clearInterval(state.timer);
+        state.canceled = Promise.resolve(true);
+        state.pause = void 0;
+        state.resume = void 0;
+        state.cancelRun?.();
+        state.rejectJob?.();
+      }
+    };
+  }
+  async *_genMdText(mdText, byWord) {
+    const segItor = byWord ? this._ctx.segmenter.segmentWordItor(mdText) : this._ctx.segmenter.segmentGraphemeItor(mdText);
+    let nextIdx = 0;
+    const parseKey = async (start) => {
+      const j = mdText.indexOf(",", start);
+      if (j < 0) {
+        return start;
+      }
+      const code = mdText.slice(start, j);
+      const ctrlKey = mdText[j + 1] === "1";
+      const shiftKey = mdText[j + 2] === "1";
+      const altKey = mdText[j + 3] === "1";
+      const metaKey = mdText[j + 4] === "1";
+      const key = code === "Space" ? " " : code.startsWith("Key") ? shiftKey ? code.slice(3).toLowerCase() : code.slice(3) : code;
+      if (mdText[j + 5] === "{") {
+        const k = mdText.indexOf("}", j + 5);
+        const count = parseInt(mdText.slice(j + 6, k));
+        if (!isNaN(count)) {
+          return new Promise((res) => {
+            let i = 0;
+            const it = setInterval(() => {
+              this.typeKey({ key, code, ctrlKey, shiftKey, altKey, metaKey });
+              if (++i >= count) {
+                clearInterval(it);
+                res(k + 1);
+              }
+            }, 50);
+          });
+        }
+      }
+      this.typeKey({ key, code, ctrlKey, shiftKey, altKey, metaKey });
+      return j + 5;
+    };
+    const typeNext = async (segment, index) => {
+      if (segment === "\0" /* Typing_Key_Char */) {
+        nextIdx = await parseKey(index + 1);
+        return;
+      }
+      if (segment.length > 1 || segment.charCodeAt(0) > 127) {
+        return this.typeText(segment);
+      }
+      const ret = this._markdownTextMapping[segment]?.(this._ctx, index, mdText);
+      if (!ret) {
+        return this.typeKey({ key: segment, code: segment });
+      }
+      if (typeof ret === "function") {
+        nextIdx = ret(this._ctx);
+        return;
+      }
+      const { value, type, nextIndex } = ret;
+      nextIdx = nextIndex;
+      if (!value) {
+        return;
+      }
+      if (type === "key") {
+        this.typeKey({ key: value, code: value });
+      } else {
+        this.typeText(value);
+      }
+    };
+    let next;
+    while (!(next = segItor.next()).done) {
+      const { segment, index } = next.value;
+      if (!segment || nextIdx > index) {
+        continue;
+      }
+      if (!this._ctx.selection.range || !this._ctx.isUpdated()) {
+        this._ctx.focusToBodyEnd();
+      }
+      yield typeNext(segment, index);
+    }
+  }
+  _startTyping() {
+    this._ctx.editor.setReadonly(true);
+    this._ctx.bodyEl.style.pointerEvents = "none";
+    this._runBeforeCallbacks();
+    this._startMask();
+  }
+  _stopTyping() {
+    this._ctx.bodyEl.style.pointerEvents = "";
+    this._runAfterCallbacks();
+    this._stopMask();
+  }
+  _runBeforeCallbacks() {
+    this._beforeCallbacks.forEach((cb) => cb(this._ctx));
+  }
+  _runAfterCallbacks() {
+    this._afterCallbacks.forEach((cb) => cb(this._ctx));
+  }
+  _startMask() {
+    this._ctx.bodyEl.style.caretColor = "transparent";
+  }
+  _stopMask() {
+    this._ctx.bodyEl.style.caretColor = "";
+    this._maskEl.style.display = "none";
+  }
+  _updateMask() {
+    if (!this._useDeco) {
+      return;
+    }
+    if (this._ctx.selection.rawEl) {
+      this._maskEl.style.display = "none";
+      return;
+    }
+    const rect = this._ctx.selection.range?.getClientRects()[0];
+    if (rect) {
+      this._maskEl.style.height = `${rect.height}px`;
+      this._maskEl.style.translate = `${rect.left + 5}px ${rect.top}px`;
+      this._maskEl.style.display = "block";
+    }
+  }
+  typeKey(init) {
+    this._ctx.bodyEl.dispatchEvent(new KeyboardEvent("keydown", init));
+    this._ctx.bodyEl.dispatchEvent(new KeyboardEvent("keyup", init));
+    this._updateMask();
+  }
+  typeText(data) {
+    this._ctx.body.dispatchInputEvent("beforeinput", {
+      data,
+      inputType: "insertText"
+    });
+    this._updateMask();
+  }
+};
+
+// src/mapping/mappingForBlockquote.ts
+import { dom } from "@effitor/core";
+var blockquoteDepth = (ctx) => {
+  if (!ctx.focusParagraph) {
+    return 0;
+  }
+  let d = 0;
+  for (const p of ctx.body.outerParagraphs(ctx.focusParagraph)) {
+    if (p && ctx.schema.blockquote?.is(p) && !p.dataset.type?.startsWith("pg")) {
+      d++;
+    }
+  }
+  return d;
+};
+var checkInBlockquote = (ctx) => {
+  return ctx.schema.blockquote?.is(ctx.focusParagraph?.parentNode);
+};
+var mappingForBlockquote = {
+  ">": (ctx, i, s) => {
+    if (s[i + 1] !== " ") {
+      return null;
+    }
+    if (ctx.isPlainParagraph(ctx.focusParagraph) && dom.isEmptyContentNode(ctx.focusParagraph)) {
+      if (s[i + 2] === "[") {
+        return null;
+      }
+      const depth = blockquoteDepth(ctx);
+      if (!depth) {
+        return () => {
+          ctx.assists.ai.typeText(">");
+          ctx.assists.ai.typeKey({ key: "Enter", code: "Enter" });
+          return i + 2;
+        };
+      }
+      let k = i + 2;
+      for (let j = 1; j < depth; j++) {
+        if (s[k] === ">" && s[k + 1] === " ") {
+          if (s[k + 2] === "[") {
+            break;
+          }
+          k += 2;
+          continue;
+        }
+        break;
+      }
+      if (s[k] === ">" && s[k + 1] === " " && s[k + 2] !== "[") {
+        return () => {
+          ctx.assists.ai.typeText(">");
+          ctx.assists.ai.typeKey({ key: "Enter", code: "Enter" });
+          return i + 2;
+        };
+      }
+      return () => k;
+    }
+    return null;
+  },
+  "\n": (ctx, i, s) => {
+    if (s[i + 1] === ">") {
+      if (!checkInBlockquote(ctx)) {
+        return null;
+      }
+      return {
+        type: "key",
+        value: "Enter",
+        nextIndex: i + 2
+      };
+    }
+    if (!checkInBlockquote(ctx)) {
+      return null;
+    }
+    if (s[i + 1] === "\n" && i + 2 < s.length && s[i + 2] !== ">" && s[i + 2] !== "\n") {
+      return () => {
+        ctx.commonHandler.appendParagraph(null, { topLevel: true });
+        return i + 2;
+      };
+    }
+    return () => {
+      while (s[i] === "\n") {
+        i++;
+        ctx.assists.ai.typeKey({ key: "Enter", code: "Enter" });
+      }
+      return i;
+    };
+  }
+};
+
+// src/mapping/mappingForCode.ts
+var checkInCodeEnd = (ctx, idx) => {
+  return ctx.focusEtElement?.localName === "et-code" ? (_ctx) => {
+    _ctx.commonHandler.appendParagraph(null);
+    return idx;
+  } : null;
+};
+var mappingForCode = {
+  "beforeStart": (ctx) => {
+    ctx.pctx.$codePx.autoComplete = false;
+    return null;
+  },
+  "afterEnd": (ctx) => {
+    ctx.pctx.$codePx.autoComplete = true;
+    return null;
+  },
+  " ": (_ctx, i, s) => {
+    if (s[i - 1] === " ") {
+      return {
+        type: "data",
+        value: " ",
+        nextIndex: i + 1
+      };
+    }
+    return null;
+  },
+  "`": (ctx, i, s) => {
+    if (s[i - 1] === "\n" && s[i + 1] === "`" && s[i + 2] === "`") {
+      return checkInCodeEnd(ctx, s[i + 3] === "\n" ? i + 4 : i + 3);
+    }
+    return null;
+  },
+  "\n": (ctx, i, s) => {
+    if (s[i + 1] === "`" && s[i + 2] === "`" && s[i + 3] === "`") {
+      return checkInCodeEnd(ctx, s[i + 4] === "\n" ? i + 5 : i + 4);
+    }
+    if (ctx.focusEtElement?.localName === "et-code") {
+      return {
+        type: "data",
+        value: "\n",
+        nextIndex: i + 1
+      };
+    }
+    return null;
+  }
+};
+
+// src/mapping/mappingForList.ts
+var checkInUnorderedListHead = (ctx, i, s) => {
+  if (s[i + 1] !== " " || ctx.focusParagraph?.localName !== "et-li" || ctx.focusParagraph.textContent.length > 1) {
+    return null;
+  }
+  return () => i + 2;
+};
+var checkInOrderedListHead = (ctx, i, s) => {
+  if (ctx.focusParagraph?.localName !== "et-li" || ctx.focusParagraph.textContent.length > 1) {
+    return null;
+  }
+  return checkIsValidOrdered(i, s);
+};
+var checkIsValidOrdered = (i, s) => {
+  const j = s.indexOf(". ", i);
+  if (j === -1) {
+    return null;
+  }
+  const val = parseInt(s.slice(i, j));
+  if (isNaN(val)) {
+    return null;
+  }
+  return () => j + 2;
+};
+var indentToTab = (ctx, indent) => {
+  indent = Math.floor(indent / 4);
+  for (let j = 0; j < indent; j++) {
+    ctx.assists.ai.typeKey({ key: "Tab", code: "Tab" });
+  }
+};
+var mappingForList = {
+  "-": checkInUnorderedListHead,
+  "*": checkInUnorderedListHead,
+  "1": checkInOrderedListHead,
+  "2": checkInOrderedListHead,
+  "3": checkInOrderedListHead,
+  "4": checkInOrderedListHead,
+  "5": checkInOrderedListHead,
+  "6": checkInOrderedListHead,
+  "7": checkInOrderedListHead,
+  "8": checkInOrderedListHead,
+  "9": checkInOrderedListHead,
+  "\n": (ctx, i, s) => {
+    const n = s[i + 1];
+    if (n === "\n") {
+      if (ctx.focusEtElement?.localName === "et-li") {
+        return (_ctx) => {
+          _ctx.commonHandler.appendParagraph(null, { newP: ctx.createPlainParagraph() });
+          return i + 2;
+        };
+      }
+    } else if ((n === "-" || n === "*") && s[i + 2] === " ") {
+      if (ctx.focusEtElement?.localName === "et-li") {
+        return {
+          value: "Enter",
+          type: "key",
+          nextIndex: i + 3
+        };
+      }
+    } else {
+      for (let j = 1; j < 5; j++) {
+        if (s[i + j] === ".") {
+          if (s[i + j + 1] === " " && Number.isInteger(Number(s.slice(i, i + j)))) {
+            return {
+              value: "Enter",
+              type: "key",
+              nextIndex: i + j + 2
+            };
+          }
+          break;
+        }
+      }
+    }
+    return null;
+  },
+  " ": (ctx, i, s) => {
+    if (i !== 0 || s[i - 1] !== "\n" || ctx.focusParagraph?.localName !== "et-li") {
+      return null;
+    }
+    let indent = 1;
+    while (s[i + 1] === " ") {
+      i++;
+      indent++;
+    }
+    const nCode = s[i + 1]?.charCodeAt(0);
+    if (!nCode) {
+      return null;
+    }
+    if (nCode === 42 || nCode === 45) {
+      if (s[i + 2] !== " ") {
+        return null;
+      }
+      return () => {
+        indentToTab(ctx, indent);
+        return i + 3;
+      };
+    }
+    if (nCode >= 48 && nCode <= 57) {
+      const check = checkIsValidOrdered(i, s);
+      if (!check) {
+        return null;
+      }
+      return () => {
+        indentToTab(ctx, indent);
+        return check();
+      };
+    }
+    return null;
+  }
+};
+
+// src/mapping/mappingForMark.ts
+var startBackquoteNum = 0;
+var checkInMark = (ctx, type) => {
+  const el = ctx.focusEtElement;
+  return el?.localName === "et-mark" && el.markType === type;
+};
+var checkToTabout = (ctx, i, s, type, char, dbl) => {
+  if (!checkInMark(ctx, type)) {
+    return null;
+  }
+  if (char === "`") {
+    if (s[i - 1] !== char && s[i + 1] !== char) {
+      return {
+        type: "key",
+        value: "Tab",
+        nextIndex: i + 1
+      };
+    }
+    return {
+      type: "data",
+      value: "`",
+      nextIndex: i + 1
+    };
+  } else if (dbl ? s[i + 1] === char : s[i - 1] !== char) {
+    return {
+      value: "Tab",
+      type: "key",
+      nextIndex: dbl ? i + 2 : i + 1
+    };
+  }
+  return null;
+};
+var mappingForMark = {
+  "*": (ctx, i, s) => {
+    if (s[i - 1] === "\n" && s[i + 1] === " ") {
+      return {
+        value: "*",
+        type: "data",
+        nextIndex: i + 1
+      };
+    }
+    return checkToTabout(ctx, i, s, "bold", "*", true) ?? checkToTabout(ctx, i, s, "italic", "*", false);
+  },
+  "`": (ctx, i, s) => {
+    const ret = checkToTabout(ctx, i, s, "code", "`", false);
+    if (ret) {
+      return ret;
+    }
+    if (s[i + 1] === " ") {
+      return {
+        type: "key",
+        value: "`",
+        nextIndex: i + 2
+      };
+    }
+    if (s[i + 1] !== "`") {
+      return null;
+    }
+    let j = i + 1;
+    while (s[j] === "`") {
+      j++;
+    }
+    if (s[j] === " ") {
+      const end = s.indexOf(" " + "`".repeat(j - i), j + 1);
+      if (end === -1) {
+        return {
+          type: "data",
+          value: s.slice(i, j + 1),
+          nextIndex: j + 1
+        };
+      }
+      startBackquoteNum = j - i;
+      return {
+        type: "key",
+        value: "`",
+        nextIndex: j + 1
+      };
+    }
+    return null;
+  },
+  " ": (ctx, i, s) => {
+    if (s[i + 1] !== "`") {
+      return null;
+    }
+    if (checkInMark(ctx, "code")) {
+      let nextIndex = i + 1;
+      if (s[i + 2] !== "`") {
+        nextIndex = i + 2;
+      } else if (s.slice(nextIndex, nextIndex + startBackquoteNum) === "`".repeat(startBackquoteNum)) {
+        nextIndex = nextIndex + startBackquoteNum;
+      }
+      if (nextIndex !== i + 1) {
+        return {
+          type: "key",
+          value: "Tab",
+          nextIndex
+        };
+      }
+    }
+    return null;
+  },
+  "~": (ctx, i, s) => {
+    return checkToTabout(ctx, i, s, "delete", "~", true);
+  },
+  "=": (ctx, i, s) => {
+    return checkToTabout(ctx, i, s, "highlight", "=", true);
+  }
+};
+
+// src/index.ts
+var useAIAssist = (options) => {
+  options = {
+    markdownTextMappings: [
+      mappingForCode,
+      mappingForMark,
+      mappingForList,
+      mappingForBlockquote
+    ]
+  };
+  return {
+    name: "@effitor/assist-ai",
+    effector: [{
+      onMounted: (ctx) => {
+        ctx.assists.ai = new EffitorAI(ctx, options);
+      }
+    }]
+  };
+};
+export {
+  mappingForBlockquote,
+  mappingForCode,
+  mappingForList,
+  mappingForMark,
+  useAIAssist
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@effitor/assist-ai",
+  "version": "0.2.0",
+  "description": "A lightweight AI assistant for Effitor.",
+  "keywords": [
+    "editor",
+    "wysiwyg",
+    "markdown"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "author": "Henvn Leaf",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ausprain/effitor.git",
+    "directory": "packages/assist-ai"
+  },
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@effitor/core": "workspace:*"
+  }
+}