@blocklet/editor-lite 2.6.0

package/lib/ext/translation/translation-utils.js

@@ -0,0 +1,63 @@
+import { $isParagraphNode, $isTextNode, $isElementNode, $createNodeSelection, $createTextNode, } from 'lexical';
+import { $isHeadingNode, $isQuoteNode } from '@lexical/rich-text';
+import { $isListNode, $isListItemNode } from '@lexical/list';
+import { $dfs } from '@lexical/utils';
+import { $generateHtmlFromNodes, $generateNodesFromDOM } from '@lexical/html';
+import { $isExcalidrawNode } from '../../main/nodes/ExcalidrawNode';
+import { $isMentionNode } from '../../main/nodes/MentionNode';
+export const $nodeToHtml = (editor, node) => {
+    const selection = $createNodeSelection();
+    const children = node.getChildren();
+    // 剔除嵌套 list 节点
+    children
+        .filter((x) => !$isListNode(x))
+        .forEach((child) => $dfs(child)
+        .filter((x) => !$isExcalidrawNode(x.node))
+        .forEach((x) => selection.add(x.node.getKey())));
+    const html = $generateHtmlFromNodes(editor, selection);
+    return html;
+};
+export const $htmlToNodes = (editor, text) => {
+    try {
+        const dom = new DOMParser().parseFromString(text, 'text/html');
+        return $generateNodesFromDOM(editor, dom);
+    }
+    catch (e) {
+        console.error(e, text);
+        return [$createTextNode(text)];
+    }
+};
+/**
+ * 判断 node 是否是有效的 TextNode
+ * - $isTextNode => true
+ * - format 不是 code
+ */
+export const $isValidTextNode = (node) => {
+    return $isTextNode(node) && node.getTextContent().trim() && !$isMentionNode(node);
+};
+/**
+ * 判断一个 ElementNode 是否含有效的 TextNode 的 child
+ */
+export const $hasValidTextNode = (elementNode) => {
+    return elementNode.getChildren().some($isValidTextNode);
+};
+export const $findTranslatableElementNodes = () => {
+    const nodes = $dfs()
+        .map((x) => x.node)
+        .filter((node) => $isElementNode(node) &&
+        ($isHeadingNode(node) || $isParagraphNode(node) || $isQuoteNode(node) || $isListItemNode(node)))
+        .filter($hasValidTextNode);
+    return nodes;
+};
+// 创建映射表: node key -> node sequential ID
+export const $createNodeKeyToSidMap = () => {
+    const nodes = $dfs();
+    let counter = 0;
+    return new Map(nodes.map((x) => [x.node.getKey(), `${counter++}`]));
+};
+// 创建映射表: node sequential ID -> node key
+export const $createSidToNodeKeyMap = () => {
+    const nodes = $dfs();
+    let counter = 0;
+    return new Map(nodes.map((x) => [`${counter++}`, x.node.getKey()]));
+};

package/lib/ext/utils.d.ts

@@ -0,0 +1,21 @@
+import { LinkNode } from '@lexical/link';
+import { type LexicalEditor } from 'lexical';
+export declare function isValidUrl(url: string): boolean;
+export declare const safeParseJSON: (json: string, defaultValue?: any) => any;
+export declare const getBlockletMountPointInfo: (name: string) => any;
+export declare const discussKitMountPoint: any;
+export declare const discussKitUploadsUrl: string;
+export declare const blockletExists: (name: string) => boolean;
+export declare const fetchOpenGraphInfo: (openGraphEndpoint: string, url: string) => Promise<{
+    url: any;
+    title: any;
+    description: any;
+    image: any;
+    favicon: any;
+} | null>;
+export declare const $getLinkNode: (editor: LexicalEditor) => LinkNode | null;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const minDelay: <T>(promise: Promise<T>, ms: number) => Promise<T>;
+export declare function exhaustiveGuard(_value: never): never;
+export declare const isSameHost: (url: string | URL) => boolean;
+export declare const isBlockletRunning: (name: string) => boolean;

package/lib/ext/utils.js

@@ -0,0 +1,88 @@
+import { $isLinkNode, LinkNode } from '@lexical/link';
+import { $getNearestNodeOfType } from '@lexical/utils';
+import { $getSelection, $isRangeSelection } from 'lexical';
+import { joinURL } from 'ufo';
+export function isValidUrl(url) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+export const safeParseJSON = (json, defaultValue = null) => {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return defaultValue;
+    }
+};
+export const getBlockletMountPointInfo = (name) => {
+    return window.blocklet?.componentMountPoints?.find((x) => x.name === name);
+};
+export const discussKitMountPoint = window.blocklet?.componentMountPoints?.find((x) => x.did === 'z8ia1WEiBZ7hxURf6LwH21Wpg99vophFwSJdu')?.mountPoint || '/';
+export const discussKitUploadsUrl = joinURL(discussKitMountPoint || '', '/uploads');
+export const blockletExists = (name) => {
+    return !!getBlockletMountPointInfo(name);
+};
+export const fetchOpenGraphInfo = async (openGraphEndpoint, url) => {
+    const endpoint = new URL(openGraphEndpoint);
+    endpoint.searchParams.set('url', url);
+    try {
+        const response = await fetch(endpoint.href);
+        const openGraphInfo = (await response.json()) || {};
+        if (openGraphInfo) {
+            return {
+                url: openGraphInfo.url || openGraphInfo['og:url'],
+                title: openGraphInfo.title || openGraphInfo['og:title'],
+                description: openGraphInfo.description || openGraphInfo['og:description'],
+                image: openGraphInfo.image || openGraphInfo['og:image'],
+                favicon: openGraphInfo.favicon,
+            };
+        }
+        return null;
+    }
+    catch {
+        console.error('Failed to fetch open graph info');
+        return null;
+    }
+};
+// 获取当前光标处的 linkNode
+export const $getLinkNode = (editor) => {
+    return editor.getEditorState().read(() => {
+        const selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+            const anchorNode = selection.anchor.getNode();
+            const linkNode = $getNearestNodeOfType(anchorNode, LinkNode);
+            // 文本前嵌入时可能获取不到 linkNode, 检测 PreviousSibling 是否为 LinkNode
+            if (!linkNode && $isLinkNode(anchorNode.getPreviousSibling())) {
+                return anchorNode.getPreviousSibling();
+            }
+            return linkNode;
+        }
+        return null;
+    });
+};
+// eslint-disable-next-line no-promise-executor-return
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export const minDelay = (promise, ms) => {
+    return Promise.all([promise, sleep(ms)]).then(([result]) => result);
+};
+export function exhaustiveGuard(_value) {
+    throw new Error(`ERROR! Reached forbidden guard function with unexpected value: ${JSON.stringify(_value)}`);
+}
+export const isSameHost = (url) => {
+    try {
+        const urlObj = typeof url === 'string' ? new URL(url) : url;
+        return urlObj.host === window.location.host;
+    }
+    catch (e) {
+        return false;
+    }
+};
+export const isBlockletRunning = (name) => {
+    return getBlockletMountPointInfo(name)?.status === 'running';
+};

package/lib/global.d.ts

@@ -0,0 +1 @@
+/// <reference path="../../../global.d.ts" />

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import BlockletEditor from './main';
+export default BlockletEditor;
+export type { BlockletEditorProps } from './main';
+export * from './config';

package/lib/index.js

@@ -0,0 +1,5 @@
+import BlockletEditor from './main';
+// @deprecated
+// 建议使用 src/blocklet-editor.ts 代替
+export default BlockletEditor;
+export * from './config';

package/lib/lexical-utils/index.d.ts

@@ -0,0 +1,46 @@
+/** @module @lexical/utils */
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { EditorState, ElementNode, Klass, LexicalEditor, LexicalNode } from 'lexical';
+import { InitialEditorStateType } from '@lexical/react/LexicalComposer';
+export type DFSNode = Readonly<{
+    depth: number;
+    node: LexicalNode;
+}>;
+export declare function addClassNamesToElement(element: HTMLElement, ...classNames: Array<typeof undefined | boolean | null | string>): void;
+export declare function removeClassNamesFromElement(element: HTMLElement, ...classNames: Array<typeof undefined | boolean | null | string>): void;
+export declare function isMimeType(file: File, acceptableMimeTypes: Array<string>): boolean;
+/**
+ * Lexical File Reader with:
+ *  1. MIME type support
+ *  2. batched results (HistoryPlugin compatibility)
+ *  3. Order aware (respects the order when multiple Files are passed)
+ *
+ * const filesResult = await mediaFileReader(files, ['image/']);
+ * filesResult.forEach(file => editor.dispatchCommand('INSERT_IMAGE', {
+ *   src: file.result,
+ * }));
+ */
+export declare function mediaFileReader(files: Array<File>, acceptableMimeTypes: Array<string>): Promise<Array<{
+    file: File;
+    result: string;
+}>>;
+export declare function $dfs(startingNode?: LexicalNode, endingNode?: LexicalNode): Array<DFSNode>;
+export declare function $getDepth(node: LexicalNode): number;
+export declare function $getNearestNodeOfType<T extends ElementNode>(node: LexicalNode, klass: Klass<T>): T | null;
+export declare function $getNearestBlockElementAncestorOrThrow(startNode: LexicalNode): ElementNode;
+export type DOMNodeToLexicalConversion = (element: Node) => LexicalNode;
+export type DOMNodeToLexicalConversionMap = Record<string, DOMNodeToLexicalConversion>;
+export declare function $findMatchingParent(startingNode: LexicalNode, findFn: (node: LexicalNode) => boolean): LexicalNode | null;
+type Func = () => void;
+export declare function mergeRegister(...func: Array<Func>): () => void;
+export declare function registerNestedElementResolver<N extends ElementNode>(editor: LexicalEditor, targetNode: Klass<N>, cloneNode: (from: N) => N, handleOverlap: (from: N, to: N) => void): () => void;
+export declare function $restoreEditorState(editor: LexicalEditor, editorState: EditorState): void;
+export declare function $wrapNodeInElement(node: LexicalNode, createElementNode: () => ElementNode): ElementNode;
+export declare function getInitialEditorState(content: string, markdown?: boolean): InitialEditorStateType;
+export {};

package/lib/lexical-utils/index.js

@@ -0,0 +1,243 @@
+// TODO: 该文件由于官方未发布，直接拷贝过来的一份，等 lexical-utils 以后升级后，可将一下使用该模块的文件修正
+// plugins/DragDropPastePlugin/index.ts
+/** @module @lexical/utils */
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { $getRoot, $isElementNode, $setSelection, } from 'lexical';
+import { $convertFromMarkdownString } from '@lexical/markdown';
+import invariant from '../shared/invariant';
+import { PLAYGROUND_TRANSFORMERS } from '../main/plugins/MarkdownTransformers';
+export function addClassNamesToElement(element, ...classNames) {
+    classNames.forEach((className) => {
+        if (typeof className === 'string') {
+            const classesToAdd = className.split(' ').filter((n) => n !== '');
+            element.classList.add(...classesToAdd);
+        }
+    });
+}
+export function removeClassNamesFromElement(element, ...classNames) {
+    classNames.forEach((className) => {
+        if (typeof className === 'string') {
+            element.classList.remove(...className.split(' '));
+        }
+    });
+}
+export function isMimeType(file, acceptableMimeTypes) {
+    for (const acceptableType of acceptableMimeTypes) {
+        if (file.type.startsWith(acceptableType)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Lexical File Reader with:
+ *  1. MIME type support
+ *  2. batched results (HistoryPlugin compatibility)
+ *  3. Order aware (respects the order when multiple Files are passed)
+ *
+ * const filesResult = await mediaFileReader(files, ['image/']);
+ * filesResult.forEach(file => editor.dispatchCommand('INSERT_IMAGE', {
+ *   src: file.result,
+ * }));
+ */
+export function mediaFileReader(files, acceptableMimeTypes) {
+    const filesIterator = files[Symbol.iterator]();
+    return new Promise((resolve, reject) => {
+        const processed = [];
+        const handleNextFile = () => {
+            const { done, value: file } = filesIterator.next();
+            if (done) {
+                return resolve(processed);
+            }
+            const fileReader = new FileReader();
+            fileReader.addEventListener('error', reject);
+            fileReader.addEventListener('load', () => {
+                const { result } = fileReader;
+                if (typeof result === 'string') {
+                    processed.push({ file, result });
+                }
+                handleNextFile();
+            });
+            if (isMimeType(file, acceptableMimeTypes)) {
+                fileReader.readAsDataURL(file);
+            }
+            else {
+                handleNextFile();
+            }
+            return null;
+        };
+        handleNextFile();
+    });
+}
+export function $dfs(startingNode, endingNode) {
+    const nodes = [];
+    const start = (startingNode || $getRoot()).getLatest();
+    const end = endingNode || ($isElementNode(start) ? start.getLastDescendant() : start);
+    let node = start;
+    let depth = $getDepth(node);
+    while (node !== null && !node.is(end)) {
+        nodes.push({ depth, node });
+        if ($isElementNode(node) && node.getChildrenSize() > 0) {
+            node = node.getFirstChild();
+            depth++;
+        }
+        else {
+            // Find immediate sibling or nearest parent sibling
+            let sibling = null;
+            while (sibling === null && node !== null) {
+                sibling = node.getNextSibling();
+                if (sibling === null) {
+                    node = node.getParent();
+                    depth--;
+                }
+                else {
+                    node = sibling;
+                }
+            }
+        }
+    }
+    if (node !== null && node.is(end)) {
+        nodes.push({ depth, node });
+    }
+    return nodes;
+}
+export function $getDepth(node) {
+    let innerNode = node;
+    let depth = 0;
+    // eslint-disable-next-line no-cond-assign
+    while ((innerNode = innerNode.getParent()) !== null) {
+        depth++;
+    }
+    return depth;
+}
+export function $getNearestNodeOfType(node, klass) {
+    let parent = node;
+    while (parent != null) {
+        if (parent instanceof klass) {
+            return parent;
+        }
+        parent = parent.getParent();
+    }
+    return null;
+}
+export function $getNearestBlockElementAncestorOrThrow(startNode) {
+    const blockNode = $findMatchingParent(startNode, (node) => $isElementNode(node) && !node.isInline());
+    if (!$isElementNode(blockNode)) {
+        invariant(false, 'Expected node %s to have closest block element node.', startNode.__key);
+    }
+    return blockNode;
+}
+export function $findMatchingParent(startingNode, 
+// eslint-disable-next-line no-unused-vars
+findFn) {
+    let curr = startingNode;
+    while (curr !== $getRoot() && curr != null) {
+        if (findFn(curr)) {
+            return curr;
+        }
+        curr = curr.getParent();
+    }
+    return null;
+}
+export function mergeRegister(...func) {
+    return () => {
+        func.forEach((f) => f());
+    };
+}
+export function registerNestedElementResolver(editor, targetNode, 
+// eslint-disable-next-line no-unused-vars
+cloneNode, 
+// eslint-disable-next-line no-unused-vars
+handleOverlap) {
+    const $isTargetNode = (node) => {
+        return node instanceof targetNode;
+    };
+    function $findMatch(node) {
+        // First validate we don't have any children that are of the target,
+        // as we need to handle them first.
+        const children = node.getChildren();
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if ($isTargetNode(child)) {
+                return null;
+            }
+        }
+        let parentNode = node;
+        let childNode = node;
+        while (parentNode !== null) {
+            childNode = parentNode;
+            parentNode = parentNode.getParent();
+            if ($isTargetNode(parentNode)) {
+                return { child: childNode, parent: parentNode };
+            }
+        }
+        return null;
+    }
+    const elementNodeTransform = (node) => {
+        const match = $findMatch(node);
+        if (match !== null) {
+            const { child, parent } = match;
+            // Simple path, we can move child out and siblings into a new parent.
+            if (child.is(node)) {
+                handleOverlap(parent, node);
+                const nextSiblings = child.getNextSiblings();
+                const nextSiblingsLength = nextSiblings.length;
+                parent.insertAfter(child);
+                if (nextSiblingsLength !== 0) {
+                    const newParent = cloneNode(parent);
+                    child.insertAfter(newParent);
+                    for (let i = 0; i < nextSiblingsLength; i++) {
+                        newParent.append(nextSiblings[i]);
+                    }
+                }
+                if (!parent.canBeEmpty() && parent.getChildrenSize() === 0) {
+                    parent.remove();
+                }
+            }
+            else {
+                // Complex path, we have a deep node that isn't a child of the
+                // target parent.
+                // TODO: implement this functionality
+            }
+        }
+    };
+    return editor.registerNodeTransform(targetNode, elementNodeTransform);
+}
+export function $restoreEditorState(editor, editorState) {
+    const FULL_RECONCILE = 2;
+    const nodeMap = new Map(editorState._nodeMap);
+    const activeEditorState = editor._pendingEditorState;
+    if (activeEditorState) {
+        activeEditorState._nodeMap = nodeMap;
+    }
+    editor._dirtyType = FULL_RECONCILE;
+    const selection = editorState._selection;
+    $setSelection(selection === null ? null : selection.clone());
+}
+export function $wrapNodeInElement(node, createElementNode) {
+    const elementNode = createElementNode();
+    node.replace(elementNode);
+    elementNode.append(node);
+    return elementNode;
+}
+export function getInitialEditorState(content, markdown) {
+    if (markdown) {
+        return () => $convertFromMarkdownString(content, PLAYGROUND_TRANSFORMERS);
+    }
+    try {
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed === 'object') {
+            return content;
+        }
+        return () => $convertFromMarkdownString(content, PLAYGROUND_TRANSFORMERS);
+    }
+    catch (e) {
+        return () => $convertFromMarkdownString(content, PLAYGROUND_TRANSFORMERS);
+    }
+}

package/lib/libs/sort-array-by-key.d.ts

@@ -0,0 +1,4 @@
+declare function sortArrayByKey<T extends {
+    [key: string]: any;
+}>(arr: T[], keyword: string, key?: string): T[];
+export default sortArrayByKey;

package/lib/libs/sort-array-by-key.js

@@ -0,0 +1,68 @@
+import leven from 'leven';
+import orderBy from 'lodash/orderBy';
+function sortArrByIndex(arr, keyword = '', key = 'fullName') {
+    // 将关键字转换成小写，以便于搜索
+    const lowerKeyword = keyword.toLowerCase();
+    // 创建一个数组的映射，用于存储关键字的索引
+    const map = arr.map((item) => {
+        // 在项目的键值中查找关键字的索引
+        item._mapIndex = (item[key] || '').toLowerCase().indexOf(lowerKeyword);
+        return item;
+    });
+    // 返回数组，根据关键字的索引进行排序
+    const result = orderBy(map, ['_mapIndex', key], ['asc', 'asc']);
+    return result;
+}
+function sortArrBySimilarity(arr, keyword = '', key = 'fullName') {
+    // 将关键字转换为小写
+    const lowerKeyword = keyword.toLowerCase();
+    // 创建一个与原始数组长度相同的新数组
+    // 并将数组中的每个项目映射到新数组中
+    const map = arr.map((item) => {
+        // 计算关键字与当前项目名称之间的相似度
+        item._mapSimilarity = item[key].length - leven((item[key] || '').toLowerCase() || '', lowerKeyword);
+        return item;
+    });
+    // 按相似度分数降序排列数组
+    // 然后按名称升序排列
+    const result = orderBy(map, ['_mapSimilarity', key], ['desc', 'asc']);
+    return result;
+}
+// 定义一个函数，输入一个数组和关键字，先优先匹配关键字，然后模糊匹配关键字
+function sortArrayByKey(arr, keyword, key = 'fullName') {
+    if (!keyword) {
+        return arr;
+    }
+    if (!Array.isArray(arr)) {
+        throw new Error('The first argument must be an array.');
+    }
+    if (typeof keyword !== 'string') {
+        throw new Error('The second argument must be a string.');
+    }
+    if (typeof key !== 'string') {
+        throw new Error('The third argument must be a string.');
+    }
+    // 创建一个数组用于存储所有匹配的项
+    const allMatch = [];
+    // 创建一个数组用于存储所有不匹配的项
+    const otherMatch = [];
+    // 创建一个正则表达式对象用于匹配
+    const reg = new RegExp(keyword, 'i');
+    // 循环遍历数组来匹配
+    arr.forEach((item) => {
+        // 如果项匹配关键字，就将其推入allMatch数组中
+        if (reg.test(item[key])) {
+            allMatch.push(item);
+        }
+        else {
+            otherMatch.push(item);
+        }
+    });
+    // 按关键字的索引对allMatch数组进行排序
+    // 按关键字与项之间的相似度对otherMatch数组进行排序
+    // 然后将两个数组组合起来
+    const result = sortArrByIndex(allMatch, keyword, key).concat(sortArrBySimilarity(otherMatch, keyword, key));
+    // 返回结果
+    return result;
+}
+export default sortArrayByKey;

package/lib/libs/utm.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * 为外部 URL 添加 UTM 追踪参数
+ * @param url - 原始 URL 地址
+ * @returns 添加 UTM 参数后的 URL
+ * @see https://team.arcblock.io/comment/discussions/7504c5ce-7453-4223-a539-27620efcf38e#6fd5adb6-49ab-4ead-9233-240aa53d1058
+ *
+ */
+export declare function getUTMUrl(url: string): string;

package/lib/libs/utm.js

@@ -0,0 +1,43 @@
+import { withQuery, getQuery } from 'ufo';
+function isExternal(url) {
+    try {
+        const u = new URL(url);
+        return u.origin !== window.location.origin;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ *
+ * 为外部 URL 添加 UTM 追踪参数
+ * @param url - 原始 URL 地址
+ * @returns 添加 UTM 参数后的 URL
+ * @see https://team.arcblock.io/comment/discussions/7504c5ce-7453-4223-a539-27620efcf38e#6fd5adb6-49ab-4ead-9233-240aa53d1058
+ *
+ */
+export function getUTMUrl(url) {
+    try {
+        if (!isExternal(url)) {
+            return url;
+        }
+        const type = window.__discussKitPostType__ ?? 'discussion';
+        const existsQueryParams = getQuery(url);
+        const queryParams = {
+            // 自身站点的 hostname
+            utm_source: window.location.hostname,
+            // 标记导航点击
+            utm_medium: `${type}_link`,
+            // 全局导航统一标签
+            utm_campaign: 'default',
+            // 目标站点标识
+            utm_content: new URL(url).hostname,
+            ...existsQueryParams,
+        };
+        return withQuery(url, queryParams);
+    }
+    catch (error) {
+        console.error('Failed to generate UTM URL:', error);
+        return url;
+    }
+}

package/lib/main/appSettings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export type SettingName = 'disableBeforeInput' | 'measureTypingPerf' | 'isRichText' | 'isCharLimit' | 'isMaxLength' | 'isCharLimitUtf8' | 'isAutocomplete' | 'emptyEditor' | 'showTableOfContents';
+export type Settings = Record<SettingName, boolean>;
+export declare const isDevPlayground: boolean;
+export declare const DEFAULT_SETTINGS: Settings;

package/lib/main/appSettings.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const hostName = window.location.hostname;
+export const isDevPlayground = hostName !== 'playground.lexical.dev' && hostName !== 'lexical-playground.vercel.app';
+export const DEFAULT_SETTINGS = {
+    disableBeforeInput: false,
+    emptyEditor: isDevPlayground,
+    isAutocomplete: false,
+    isCharLimit: false,
+    isCharLimitUtf8: false,
+    isMaxLength: false,
+    isRichText: true,
+    measureTypingPerf: false,
+    showTableOfContents: false,
+};

package/lib/main/context/SharedAutocompleteContext.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { ReactNode, type JSX } from 'react';
+type Suggestion = null | string;
+type PublishFn = (newSuggestion: Suggestion) => void;
+type HookShape = [suggestion: Suggestion, setSuggestion: PublishFn];
+export declare function SharedAutocompleteContext({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+export declare const useSharedAutocompleteContext: () => HookShape;
+export {};