import { __INTERNAL_REMIRROR_IDENTIFIER_KEY__ } from '@remirror/core-constants'; import { AcceptUndefined } from '@remirror/core-types'; import { AnchorHeadProps } from '@remirror/core-types'; import { And } from '@remirror/core-types'; import { AnyConstructor } from '@remirror/core-types'; import { AnyFunction } from '@remirror/core-types'; import { applyClonedTransaction } from '@remirror/core-utils'; import { ApplySchemaAttributes } from '@remirror/core-types'; import { areSchemasCompatible } from '@remirror/core-utils'; import { areStatesEqual } from '@remirror/core-utils'; import { Array1 } from '@remirror/core-types'; import { Array2 } from '@remirror/core-types'; import { Array3 } from '@remirror/core-types'; import { assert } from '@remirror/core-helpers'; import { assertGet } from '@remirror/core-helpers'; import { Asyncify } from '@remirror/core-types'; import { AsyncReturnType } from '@remirror/core-types'; import { atDocEnd } from '@remirror/core-utils'; import { atDocStart } from '@remirror/core-utils'; import { AttributesProps } from '@remirror/core-types'; import { Brand } from '@remirror/core-types'; import { callIfDefined } from '@remirror/core-helpers'; import { CamelCase } from '@remirror/core-types'; import { camelCase } from '@remirror/core-helpers'; import { canInsertNode } from '@remirror/core-utils'; import { capitalCase } from '@remirror/core-helpers'; import { capitalize } from '@remirror/core-helpers'; import { Cast } from '@remirror/core-helpers'; import { chainableEditorState } from '@remirror/core-utils'; import { chainCommands } from '@remirror/core-utils'; import { chainKeyBindingCommands } from '@remirror/core-utils'; import { clamp } from '@remirror/core-helpers'; import { Class } from '@remirror/core-types'; import { ClassName } from '@remirror/core-helpers'; import { cleanupOS } from '@remirror/core-helpers'; import { clone } from '@remirror/core-helpers'; import { cloneTransaction } from '@remirror/core-utils'; import { CommandFunction } from '@remirror/core-types'; import { CommandFunctionProps } from '@remirror/core-types'; import { composeTransactionSteps } from '@remirror/core-utils'; import { ConditionalExcept } from '@remirror/core-types'; import { ConditionalKeys } from '@remirror/core-types'; import { ConditionalPick } from '@remirror/core-types'; import { ConditionalReturnKeys } from '@remirror/core-types'; import { ConditionalReturnPick } from '@remirror/core-types'; import { constantCase } from '@remirror/core-helpers'; import { containsAttributes } from '@remirror/core-utils'; import { containsNodesOfType } from '@remirror/core-utils'; import { convertCommand } from '@remirror/core-utils'; import { convertPixelsToDomUnit } from '@remirror/core-utils'; import { Coords } from '@remirror/core-types'; import { CoreIcon } from '@remirror/icons'; import { createDocumentNode } from '@remirror/core-utils'; import { CreateDocumentNodeProps } from '@remirror/core-utils'; import { CustomDocumentProps } from '@remirror/core-utils'; import { CustomHandler } from '@remirror/core-types'; import { CustomHandlerKey } from '@remirror/core-types'; import { CustomHandlerKeyList } from '@remirror/core-types'; import { CustomHandlerShape } from '@remirror/core-types'; import { cx } from '@remirror/core-helpers'; import { debounce } from '@remirror/core-helpers'; import { DebouncedFunction } from '@remirror/core-helpers'; import { Decoration } from '@remirror/core-types'; import { DecorationSet } from '@remirror/core-types'; import { DecorationSet as DecorationSet_2 } from '@remirror/pm/view'; import { deepMerge } from '@remirror/core-helpers'; import { DeepPartial } from '@remirror/core-types'; import { DeepString } from '@remirror/core-types'; import { DefaultDocNodeOptions } from '@remirror/core-utils'; import { defaultImport } from '@remirror/core-helpers'; import { DelimiterCase } from '@remirror/core-types'; import { Diff } from '@remirror/core-types'; import type { DirectEditorProps } from '@remirror/pm/view'; import { DispatchFunction } from '@remirror/core-types'; import { Dispose } from '@remirror/core-types'; import { DOM_SIZE_UNITS } from '@remirror/core-utils'; import { DOMCompatibleAttributes } from '@remirror/core-types'; import { DOMOutputSpec } from '@remirror/core-types'; import { DomSizeUnit } from '@remirror/core-utils'; import { Dynamic } from '@remirror/core-types'; import { DynamicAttributeCreator } from '@remirror/core-types'; import { DynamicKey } from '@remirror/core-types'; import { DynamicKeyList } from '@remirror/core-types'; import { DynamicShape } from '@remirror/core-types'; import { EditorSchema } from '@remirror/core-types'; import { EditorState } from '@remirror/core-types'; import { EditorState as EditorState_2 } from '@remirror/pm/state'; import { EditorStateProps } from '@remirror/core-types'; import { EditorView } from '@remirror/core-types'; import { EditorView as EditorView_2 } from '@remirror/pm/view'; import { EditorViewProps } from '@remirror/core-types'; import { EMPTY_ARRAY } from '@remirror/core-constants'; import { EMPTY_NODE } from '@remirror/core-constants'; import { EMPTY_PARAGRAPH_NODE } from '@remirror/core-constants'; import { EmptyShape } from '@remirror/core-types'; import { endPositionOfParent } from '@remirror/core-utils'; import { Entries } from '@remirror/core-types'; import { entries } from '@remirror/core-helpers'; import { Entry } from '@remirror/core-types'; import { environment } from '@remirror/core-utils'; import { ErrorConstant } from '@remirror/core-constants'; import { Except } from '@remirror/core-types'; import { ExtensionPriority } from '@remirror/core-constants'; import { ExtensionTag } from '@remirror/core-constants'; import { ExtensionTagType } from '@remirror/core-constants'; import { extractPixelSize } from '@remirror/core-utils'; import { findBlockNodes } from '@remirror/core-utils'; import { findChildren } from '@remirror/core-utils'; import { findChildrenByAttribute } from '@remirror/core-utils'; import { findChildrenByMark } from '@remirror/core-utils'; import { findChildrenByNode } from '@remirror/core-utils'; import { findElementAtPosition } from '@remirror/core-utils'; import { findInlineNodes } from '@remirror/core-utils'; import { findMatches } from '@remirror/core-helpers'; import { findNodeAtPosition } from '@remirror/core-utils'; import { findNodeAtSelection } from '@remirror/core-utils'; import { findParentNode } from '@remirror/core-utils'; import { findParentNodeOfType } from '@remirror/core-utils'; import { findPositionOfNodeAfter } from '@remirror/core-utils'; import { findPositionOfNodeBefore } from '@remirror/core-utils'; import { FindProsemirrorNodeResult } from '@remirror/core-utils'; import { findSelectedNodeOfType } from '@remirror/core-utils'; import { findTextNodes } from '@remirror/core-utils'; import { FixedLengthArray } from '@remirror/core-types'; import { flattenArray } from '@remirror/core-helpers'; import { Flavor } from '@remirror/core-types'; import { Flavoring } from '@remirror/core-types'; import { FlipPartialAndRequired } from '@remirror/core-types'; import { format } from '@remirror/core-helpers'; import { Fragment } from '@remirror/core-types'; import { FragmentStringHandlerOptions } from '@remirror/core-utils'; import { freeze } from '@remirror/core-helpers'; import { FromToProps } from '@remirror/core-types'; import { Get } from '@remirror/core-types'; import { get } from '@remirror/core-helpers'; import { GetAcceptUndefined } from '@remirror/core-types'; import { getActiveNode } from '@remirror/core-utils'; import { GetAttributes } from '@remirror/core-types'; import { GetAttributesProps } from '@remirror/core-types'; import { getChangedNodeRanges } from '@remirror/core-utils'; import { getChangedNodes } from '@remirror/core-utils'; import { getChangedRanges } from '@remirror/core-utils'; import { GetConstructorProps } from '@remirror/core-types'; import { getCursor } from '@remirror/core-utils'; import { GetCustomHandler } from '@remirror/core-types'; import { getDefaultBlockNode } from '@remirror/core-utils'; import { getDefaultDocNode } from '@remirror/core-utils'; import { getDocRange } from '@remirror/core-utils'; import { getDocument } from '@remirror/core-utils'; import { GetDynamic } from '@remirror/core-types'; import { GetFixed } from '@remirror/core-types'; import { GetFixedCustomHandler } from '@remirror/core-types'; import { GetFixedDynamic } from '@remirror/core-types'; import { GetFixedProps } from '@remirror/core-types'; import { GetFixedStatic } from '@remirror/core-types'; import { GetFlippedStatic } from '@remirror/core-types'; import { getFontSize } from '@remirror/core-utils'; import { GetHandler } from '@remirror/core-types'; import { getInvalidContent } from '@remirror/core-utils'; import { getLazyArray } from '@remirror/core-helpers'; import { GetMappedCustomHandler } from '@remirror/core-types'; import { GetMappedHandler } from '@remirror/core-types'; import { getMarkAttributes } from '@remirror/core-utils'; import { GetMarkRange } from '@remirror/core-utils'; import { getMarkRange } from '@remirror/core-utils'; import { getMarkRanges } from '@remirror/core-utils'; import { getMarkType } from '@remirror/core-utils'; import { getMatchString } from '@remirror/core-utils'; import { getNodeType } from '@remirror/core-utils'; import { GetPartialDynamic } from '@remirror/core-types'; import { getRemirrorJSON } from '@remirror/core-utils'; import { GetRequiredKeys } from '@remirror/core-types'; import { getSelectedGroup } from '@remirror/core-utils'; import { getSelectedWord } from '@remirror/core-utils'; import { getShortcutSymbols } from '@remirror/core-utils'; import { GetStatic } from '@remirror/core-types'; import { GetStaticAndDynamic } from '@remirror/core-types'; import { getStyle } from '@remirror/core-utils'; import { getTextContentFromSlice } from '@remirror/core-utils'; import { getTextSelection } from '@remirror/core-utils'; import { Handler } from '@remirror/core-types'; import { HandlerKey } from '@remirror/core-types'; import { HandlerKeyList } from '@remirror/core-types'; import { HandlerShape } from '@remirror/core-types'; import { hasOwnProperty } from '@remirror/core-helpers'; import { hasTransactionChanged } from '@remirror/core-utils'; import { htmlToProsemirrorNode } from '@remirror/core-utils'; import { I18nFormatter } from '@remirror/core-types'; import { IfEmpty } from '@remirror/core-types'; import { IfHasRequiredProperties } from '@remirror/core-types'; import { IfMatches } from '@remirror/core-types'; import { IfNoRequiredProperties } from '@remirror/core-types'; import { includes } from '@remirror/core-helpers'; import { IndexUnionFromTuple } from '@remirror/core-types'; import { InputRule } from '@remirror/core-types'; import { InvalidContentBlock } from '@remirror/core-utils'; import { InvalidContentHandler } from '@remirror/core-utils'; import { InvalidContentHandlerProps } from '@remirror/core-utils'; import { invariant } from '@remirror/core-helpers'; import { isAllSelection } from '@remirror/core-utils'; import { isAndroidOS } from '@remirror/core-helpers'; import { isArray } from '@remirror/core-helpers'; import { isBoolean } from '@remirror/core-helpers'; import { isChrome } from '@remirror/core-utils'; import { isClass } from '@remirror/core-helpers'; import { isDate } from '@remirror/core-helpers'; import { isDefaultBlockNode } from '@remirror/core-utils'; import { isDefaultDocNode } from '@remirror/core-utils'; import { isDirectInstanceOf } from '@remirror/core-helpers'; import { isDocNode } from '@remirror/core-utils'; import { isDocNodeEmpty } from '@remirror/core-utils'; import { isDomNode } from '@remirror/core-utils'; import { isEditorSchema } from '@remirror/core-utils'; import { isEditorState } from '@remirror/core-utils'; import { isElementDomNode } from '@remirror/core-utils'; import { isEmptyArray } from '@remirror/core-helpers'; import { isEmptyBlockNode } from '@remirror/core-utils'; import { isEmptyObject } from '@remirror/core-helpers'; import { isEndOfTextBlock } from '@remirror/core-utils'; import { isEqual } from '@remirror/core-helpers'; import { isError } from '@remirror/core-helpers'; import { isFunction } from '@remirror/core-helpers'; import { isIdentifierOfType } from '@remirror/core-utils'; import { isInstanceOf } from '@remirror/core-helpers'; import { isInteger } from '@remirror/core-helpers'; import { isJSONPrimitive } from '@remirror/core-helpers'; import { isMap } from '@remirror/core-helpers'; import { isMarkActive } from '@remirror/core-utils'; import { isMarkType } from '@remirror/core-utils'; import { isNativePromise } from '@remirror/core-helpers'; import { isNodeActive } from '@remirror/core-utils'; import { isNodeOfType } from '@remirror/core-utils'; import { isNodeSelection } from '@remirror/core-utils'; import { isNodeType } from '@remirror/core-utils'; import { isNonEmptyArray } from '@remirror/core-helpers'; import { isNull } from '@remirror/core-helpers'; import { isNullOrUndefined } from '@remirror/core-helpers'; import { isNumber } from '@remirror/core-helpers'; import { isObject } from '@remirror/core-helpers'; import { isPlainObject } from '@remirror/core-helpers'; import { isPrimitive } from '@remirror/core-helpers'; import { isPromise } from '@remirror/core-helpers'; import { isProsemirrorFragment } from '@remirror/core-utils'; import { isProsemirrorMark } from '@remirror/core-utils'; import { isProsemirrorNode } from '@remirror/core-utils'; import { isRegExp } from '@remirror/core-helpers'; import { isRemirrorJSON } from '@remirror/core-utils'; import { isRemirrorType } from '@remirror/core-utils'; import { isResolvedPos } from '@remirror/core-utils'; import { isSafari } from '@remirror/core-utils'; import { isSafeInteger } from '@remirror/core-helpers'; import { isSelection } from '@remirror/core-utils'; import { isSelectionEmpty } from '@remirror/core-utils'; import { isSet } from '@remirror/core-helpers'; import { isStartOfDoc } from '@remirror/core-utils'; import { isStartOfTextBlock } from '@remirror/core-utils'; import { isString } from '@remirror/core-helpers'; import { isSymbol } from '@remirror/core-helpers'; import { isTextDomNode } from '@remirror/core-utils'; import { isTextSelection } from '@remirror/core-utils'; import { isTransaction } from '@remirror/core-utils'; import { isUndefined } from '@remirror/core-helpers'; import { IterableElement } from '@remirror/core-types'; import { joinStyles } from '@remirror/core-utils'; import { JsonArray } from '@remirror/core-types'; import { JsonObject } from '@remirror/core-types'; import { JsonPrimitive } from '@remirror/core-types'; import { JsonValue } from '@remirror/core-types'; import { KebabCase } from '@remirror/core-types'; import { kebabCase } from '@remirror/core-helpers'; import { KeepPartialProperties } from '@remirror/core-types'; import { KeyBindingCommandFunction } from '@remirror/core-types'; import { KeyBindingNames } from '@remirror/core-types'; import { KeyBindingProps } from '@remirror/core-types'; import { KeyBindings } from '@remirror/core-types'; import { keys } from '@remirror/core-helpers'; import { last } from '@remirror/core-helpers'; import { LEAF_NODE_REPLACING_CHARACTER } from '@remirror/core-constants'; import { lift } from '@remirror/core-utils'; import { Listable } from '@remirror/core-types'; import { Literal } from '@remirror/core-types'; import { LiteralUnion } from '@remirror/core-types'; import { MakeNullable } from '@remirror/core-types'; import { MakeOptional } from '@remirror/core-types'; import { MakeReadonly } from '@remirror/core-types'; import { MakeRequired } from '@remirror/core-types'; import { MakeUndefined } from '@remirror/core-types'; import { ManagerPhase } from '@remirror/core-constants'; import { Mapping } from '@remirror/core-types'; import { Mark } from '@remirror/core-types'; import { Mark as Mark_2 } from '@remirror/pm/model'; import { markEqualsType } from '@remirror/core-utils'; import { MarkExtensionSpec } from '@remirror/core-types'; import { markInputRule } from '@remirror/core-utils'; import { MarkSpecOverride } from '@remirror/core-types'; import { MarkType } from '@remirror/core-types'; import { MarkTypeProps } from '@remirror/core-types'; import { MarkTypesProps } from '@remirror/core-types'; import { MarkWithAttributes } from '@remirror/core-types'; import { MarkWithAttributesProps } from '@remirror/core-types'; import { Merge } from '@remirror/core-types'; import { mergeDOMRects } from '@remirror/core-utils'; import { MergeExclusive } from '@remirror/core-types'; import { mergeKeyBindings } from '@remirror/core-utils'; import { mergeProsemirrorKeyBindings } from '@remirror/core-utils'; import { MinArray } from '@remirror/core-types'; import { mutateTag } from '@remirror/core-constants'; import { NamedShortcut } from '@remirror/core-constants'; import { NamedStringHandlers } from '@remirror/core-utils'; import { NodeExtensionSpec } from '@remirror/core-types'; import { nodeInputRule } from '@remirror/core-utils'; import { NodeMarkOptions } from '@remirror/core-types'; import { NodeSpecOverride } from '@remirror/core-types'; import { NodeStringHandlerOptions } from '@remirror/core-utils'; import { NodeType } from '@remirror/core-types'; import { NodeType as NodeType_2 } from '@remirror/pm/model'; import { NodeTypeProps } from '@remirror/core-types'; import { NodeTypesProps } from '@remirror/core-types'; import { NodeView } from '@remirror/core-types'; import { NodeViewMethod } from '@remirror/core-types'; import { NodeWithAttributes } from '@remirror/core-types'; import { NodeWithAttributesProps } from '@remirror/core-types'; import { NodeWithPosition } from '@remirror/core-utils'; import { NON_BREAKING_SPACE_CHAR } from '@remirror/core-constants'; import { nonChainable } from '@remirror/core-utils'; import { NonChainableCommandFunction } from '@remirror/core-types'; import { NonNullableShape } from '@remirror/core-types'; import { noop } from '@remirror/core-helpers'; import { NULL_CHARACTER } from '@remirror/core-constants'; import { Nullable } from '@remirror/core-types'; import { object } from '@remirror/core-helpers'; import { ObjectMark } from '@remirror/core-types'; import { ObservableLike } from '@remirror/core-types'; import { omit } from '@remirror/core-helpers'; import { omitExtraAttributes } from '@remirror/core-utils'; import { omitUndefined } from '@remirror/core-helpers'; import { Opaque } from '@remirror/core-types'; import { OptionalMarkProps } from '@remirror/core-types'; import { OptionalProsemirrorNodeProps } from '@remirror/core-types'; import { PackageJson } from '@remirror/core-types'; import { ParsedDomSize } from '@remirror/core-utils'; import { parseSizeUnit } from '@remirror/core-utils'; import { PartialDeep } from '@remirror/core-types'; import { PartialWithRequiredKeys } from '@remirror/core-types'; import { PascalCase } from '@remirror/core-types'; import { pascalCase } from '@remirror/core-helpers'; import { pathCase } from '@remirror/core-helpers'; import { pick } from '@remirror/core-helpers'; import { PickPartial } from '@remirror/core-types'; import { PickRequired } from '@remirror/core-types'; import { plainInputRule } from '@remirror/core-utils'; import { Plugin as Plugin_2 } from '@remirror/pm/state'; import { PluginKey } from '@remirror/core-types'; import type { PluginSpec } from '@remirror/pm/state'; import { PosProps } from '@remirror/core-types'; import { Predicate } from '@remirror/core-types'; import { PredicateProps } from '@remirror/core-types'; import { preserveSelection } from '@remirror/core-utils'; import { Primitive } from '@remirror/core-types'; import { PrimitiveSelection } from '@remirror/core-types'; import { Promisable } from '@remirror/core-types'; import { ProsemirrorAttributes } from '@remirror/core-types'; import { ProsemirrorCommandFunction } from '@remirror/core-types'; import { ProsemirrorKeyBindings } from '@remirror/core-types'; import { ProsemirrorNode } from '@remirror/core-types'; import { ProsemirrorNodeProps } from '@remirror/core-types'; import { prosemirrorNodeToDom } from '@remirror/core-utils'; import { prosemirrorNodeToHtml } from '@remirror/core-utils'; import { ProsemirrorPlugin } from '@remirror/core-types'; import { ProsemirrorPlugin as ProsemirrorPlugin_2 } from '@remirror/pm'; import { randomFloat } from '@remirror/core-helpers'; import { randomInt } from '@remirror/core-helpers'; import { range } from '@remirror/core-helpers'; import { rangeHasMark } from '@remirror/core-utils'; import { RangeProps } from '@remirror/core-types'; import { ReadonlyDeep } from '@remirror/core-types'; import { RegExpProps } from '@remirror/core-types'; import { REMIRROR_WEBVIEW_NAME } from '@remirror/core-constants'; import { RemirrorContentType } from '@remirror/core-types'; import { RemirrorError } from '@remirror/core-helpers'; import { RemirrorErrorOptions } from '@remirror/core-helpers'; import { RemirrorIdentifier } from '@remirror/core-constants'; import { RemirrorIdentifierShape } from '@remirror/core-types'; import { RemirrorJSON } from '@remirror/core-types'; import { RemirrorMessage } from '@remirror/core-types'; import { RemoveAnnotation } from '@remirror/core-types'; import { RemoveAnnotations } from '@remirror/core-types'; import { RemoveFlavoring } from '@remirror/core-types'; import { removeMark } from '@remirror/core-utils'; import { RemoveMarkProps } from '@remirror/core-utils'; import { removeNodeAfter } from '@remirror/core-utils'; import { removeNodeAtPosition } from '@remirror/core-utils'; import { removeNodeBefore } from '@remirror/core-utils'; import { Replace } from '@remirror/core-types'; import { replaceNodeAtPosition } from '@remirror/core-utils'; import { replaceText } from '@remirror/core-utils'; import { ReplaceTextProps } from '@remirror/core-utils'; import { RequireAtLeastOne } from '@remirror/core-types'; import { RequireExactlyOne } from '@remirror/core-types'; import { ResolvedPos } from '@remirror/core-types'; import { ResolvedPosProps } from '@remirror/core-types'; import { SchemaAttributes } from '@remirror/core-types'; import { SchemaAttributesObject } from '@remirror/core-types'; import { SchemaJSON } from '@remirror/core-utils'; import { SchemaProps } from '@remirror/core-types'; import { schemaToJSON } from '@remirror/core-utils'; import { SELECTED_NODE_CLASS_NAME } from '@remirror/core-constants'; import { SELECTED_NODE_CLASS_SELECTOR } from '@remirror/core-constants'; import { Selection as Selection_2 } from '@remirror/core-types'; import { SelectionProps } from '@remirror/core-types'; import { set } from '@remirror/core-helpers'; import { setBlockType } from '@remirror/core-utils'; import { SetOptional } from '@remirror/core-types'; import { SetRequired } from '@remirror/core-types'; import { SetReturnType } from '@remirror/core-types'; import { setStyle } from '@remirror/core-utils'; import { shallowClone } from '@remirror/core-helpers'; import { Shape } from '@remirror/core-types'; import { ShouldSkipFunction } from '@remirror/core-utils'; import { ShouldSkipProps } from '@remirror/core-utils'; import { shouldUseDomEnvironment } from '@remirror/core-utils'; import { Simplify } from '@remirror/core-types'; import { SkippableInputRule } from '@remirror/core-utils'; import { Slice } from '@remirror/core-types'; import { SnakeCase } from '@remirror/core-types'; import { snakeCase } from '@remirror/core-helpers'; import { sort } from '@remirror/core-helpers'; import { spaceCase } from '@remirror/core-helpers'; import { startCase } from '@remirror/core-helpers'; import { startPositionOfParent } from '@remirror/core-utils'; import { STATE_OVERRIDE } from '@remirror/core-constants'; import { StateJSON } from '@remirror/core-types'; import { Static } from '@remirror/core-types'; import { StaticKey } from '@remirror/core-types'; import { StaticKeyList } from '@remirror/core-types'; import { StaticShape } from '@remirror/core-types'; import { StrictReplace } from '@remirror/core-types'; import { StringHandler } from '@remirror/core-utils'; import { StringHandlerOptions } from '@remirror/core-utils'; import { StringHandlerProps } from '@remirror/core-utils'; import { Stringified } from '@remirror/core-types'; import { StringKey } from '@remirror/core-types'; import { Suggester } from '@remirror/pm/suggest'; import { SuggestState } from '@remirror/pm/suggest'; import { take } from '@remirror/core-helpers'; import { textBetween } from '@remirror/core-utils'; import { TextProps } from '@remirror/core-types'; import { throttle } from '@remirror/core-helpers'; import { ThrottledFunction } from '@remirror/core-helpers'; import { toggleBlockItem } from '@remirror/core-utils'; import { ToggleBlockItemProps } from '@remirror/core-utils'; import { toggleWrap } from '@remirror/core-utils'; import { toString as toString_2 } from '@remirror/core-helpers'; import { Transaction } from '@remirror/core-types'; import { Transaction as Transaction_2 } from '@remirror/pm/state'; import { TransactionProps } from '@remirror/core-types'; import { TransactionTransformer } from '@remirror/core-types'; import { TrStateProps } from '@remirror/core-types'; import { TsConfigJson } from '@remirror/core-types'; import { TupleOf } from '@remirror/core-types'; import { TupleUnion } from '@remirror/core-types'; import { TupleValue } from '@remirror/core-types'; import { TypedArray } from '@remirror/core-types'; import { UndefinedFlipPartialAndRequired } from '@remirror/core-types'; import { UndefinedPickPartial } from '@remirror/core-types'; import { UnionToIntersection } from '@remirror/core-types'; import { uniqueArray } from '@remirror/core-helpers'; import { uniqueBy } from '@remirror/core-helpers'; import { uniqueId } from '@remirror/core-helpers'; import { UnknownShape } from '@remirror/core-types'; import { unset } from '@remirror/core-helpers'; import { Unsubscribe } from 'nanoevents'; import { updateMark } from '@remirror/core-utils'; import { UpdateMarkProps } from '@remirror/core-utils'; import { UseDefault } from '@remirror/core-types'; import { ValidOptions } from '@remirror/core-types'; import { Value } from '@remirror/core-types'; import { ValueOf } from '@remirror/core-types'; import { values } from '@remirror/core-helpers'; import { within } from '@remirror/core-helpers'; import { wrapIn } from '@remirror/core-utils'; import { Writable } from '@remirror/core-types'; import { Writeable } from '@remirror/core-types'; import { ZERO_WIDTH_SPACE_CHAR } from '@remirror/core-constants'; export { __INTERNAL_REMIRROR_IDENTIFIER_KEY__ } /** * Any `ProsemirrorNode` can use the `uploadFile` function in this file as long * as its attributes implement this interface. */ declare interface AbstractNodeAttributes { id?: any; error?: string | null; } export { AcceptUndefined } export declare enum ActionType { ADD_PLACEHOLDER = 0, REMOVE_PLACEHOLDER = 1 } /** * The type which gets the active methods from the provided extensions. */ declare type ActiveFromExtensions = Record extends never ? string : GetNodeNameUnion, (attrs?: ProsemirrorAttributes) => boolean> & Record extends never ? string : GetMarkNameUnion, (attrs?: ProsemirrorAttributes) => boolean>; export { ActiveFromExtensions } export { ActiveFromExtensions as ActiveFromExtensions_alias_1 } export { ActiveFromExtensions as ActiveFromExtensions_alias_2 } declare type AddCustomHandler = (props: Partial>) => Dispose | undefined; export { AddCustomHandler } export { AddCustomHandler as AddCustomHandler_alias_1 } declare type AddFrameworkHandler = >(event: Key, cb: FrameworkEvents[Key]) => Unsubscribe; export { AddFrameworkHandler } export { AddFrameworkHandler as AddFrameworkHandler_alias_1 } declare type AddHandler = >(key: Key, method: GetHandler[Key]) => Dispose; export { AddHandler } export { AddHandler as AddHandler_alias_1 } /** * TODO see if this is needed or remove. */ export declare type AddHandlers = (props: Partial>) => Dispose; declare interface AddPlaceholderAction { type: ActionType.ADD_PLACEHOLDER; id: string; payload: any; pos: number; } export { AnchorHeadProps } export { And } export declare type AnyBaseClassConstructor = Replace, { new (...args: any[]): AnyFunction; }>; export declare interface AnyBaseClassOverrides { addCustomHandler: AnyFunction; addHandler: AnyFunction; clone: AnyFunction; } export { AnyConstructor } /** * The type which is applicable to any extension instance. * * **NOTE** `& object` forces VSCode to use the name `AnyExtension` rather than * print out `Replace, Remirror.AnyExtensionOverrides>` */ declare type AnyExtension = Replace, Remirror.AnyExtensionOverrides> & object; export { AnyExtension } export { AnyExtension as AnyExtension_alias_1 } export { AnyExtension as AnyExtension_alias_2 } /** * The type which is applicable to any extension instance. */ declare type AnyExtensionConstructor = Replace, { new (...args: any[]): AnyExtension; }>; export { AnyExtensionConstructor } export { AnyExtensionConstructor as AnyExtensionConstructor_alias_1 } export { AnyExtensionConstructor as AnyExtensionConstructor_alias_2 } export { AnyFunction } declare type AnyManagerStore = Remirror.ManagerStore; export { AnyManagerStore } export { AnyManagerStore as AnyManagerStore_alias_1 } export { AnyManagerStore as AnyManagerStore_alias_2 } /** * The type for any potential MarkExtension. */ declare type AnyMarkExtension = Replace, Remirror.AnyExtensionOverrides> & object; export { AnyMarkExtension } export { AnyMarkExtension as AnyMarkExtension_alias_1 } export { AnyMarkExtension as AnyMarkExtension_alias_2 } /** * The type for any potential NodeExtension. */ declare type AnyNodeExtension = Replace, Remirror.AnyExtensionOverrides> & object; export { AnyNodeExtension } export { AnyNodeExtension as AnyNodeExtension_alias_1 } export { AnyNodeExtension as AnyNodeExtension_alias_2 } /** * The type for any potential PlainExtension. */ declare type AnyPlainExtension = Replace, Remirror.AnyExtensionOverrides> & object; export { AnyPlainExtension } export { AnyPlainExtension as AnyPlainExtension_alias_1 } export { AnyPlainExtension as AnyPlainExtension_alias_2 } declare type AnyRemirrorManager = Simplify, { clone: () => AnyRemirrorManager; store: Replace, { chain: any; }>; output: Replace, { chain: any; manager: AnyRemirrorManager; }> | undefined; view: EditorView; addView: (view: EditorView) => void; attachFramework: (framework: any, updateHandler: (props: StateUpdateLifecycleProps) => void) => void; /** @internal */ ['~E']: AnyExtension; /** @internal */ ['~AN']: string; /** @internal */ ['~N']: string; /** @internal */ ['~M']: string; /** @internal */ ['~P']: string; }>>; export { AnyRemirrorManager } export { AnyRemirrorManager as AnyRemirrorManager_alias_1 } export { AnyRemirrorManager as AnyRemirrorManager_alias_2 } declare interface AppendLifecycleProps extends EditorStateProps { /** * Update this transaction in order to append. */ tr: Transaction; /** * The previous state. */ previousState: EditorState; /** * The transactions that have already been applied. */ transactions: readonly Transaction[]; } export { AppendLifecycleProps } export { AppendLifecycleProps as AppendLifecycleProps_alias_1 } export { applyClonedTransaction } /** * Apply the provided mark type and attributes. * * @param markType - the mark to apply. * @param attrs - the attributes to set on the applied mark. * @param selectionPoint - optionally specify where the mark should be applied. * Defaults to the current selection. */ export declare function applyMark(type: string | MarkType, attrs?: ProsemirrorAttributes, selectionPoint?: PrimitiveSelection): CommandFunction; export { ApplySchemaAttributes } declare interface ApplyStateLifecycleProps extends EditorStateProps { /** * The original transaction which caused this state update. */ tr: Transaction; /** * The previous state. */ previousState: EditorState; } export { ApplyStateLifecycleProps } export { ApplyStateLifecycleProps as ApplyStateLifecycleProps_alias_1 } export { areSchemasCompatible } export { areStatesEqual } export { Array1 } export { Array2 } export { Array3 } export { assert } export { assertGet } export { Asyncify } export { AsyncReturnType } export { atDocEnd } export { atDocStart } declare type AttributePropFunction = (params: RemirrorEventListenerProps) => Record; export { AttributePropFunction } export { AttributePropFunction as AttributePropFunction_alias_1 } export { AttributePropFunction as AttributePropFunction_alias_2 } /** * This extension allows others extension to add the `createAttributes` method * for adding attributes to the prosemirror dom element. * * @remarks * * Use this to include all the dynamically generated attributes provided by each * extension. High priority extensions have preference over the lower priority * extensions. * * @category Builtin Extension */ declare class AttributesExtension extends PlainExtension { get name(): "attributes"; private attributeList; private attributeObject; /** * Create the attributes object on initialization. * * @internal */ onCreate(): void; private readonly updateAttributes; private transformAttributes; } export { AttributesExtension } export { AttributesExtension as AttributesExtension_alias_1 } export { AttributesExtension as AttributesExtension_alias_2 } export { AttributesProps } /** * The type which gets the attributes for the provided node or mark. It returns * undefined if the node / mark is not active. */ declare type AttrsFromExtensions = Record extends never ? string : GetNodeNameUnion, (attrs?: ProsemirrorAttributes) => ProsemirrorAttributes | undefined> & Record extends never ? string : GetMarkNameUnion, (attrs?: ProsemirrorAttributes) => ProsemirrorAttributes | undefined>; export { AttrsFromExtensions } export { AttrsFromExtensions as AttrsFromExtensions_alias_1 } export { AttrsFromExtensions as AttrsFromExtensions_alias_2 } export declare abstract class BaseClass { /** * The default options for this extension. * * TODO see if this can be cast to something other than any and allow * composition. */ static readonly defaultOptions: any; /** * The static keys for this class. */ static readonly staticKeys: string[]; /** * The event handler keys. */ static readonly handlerKeys: string[]; /** * Customize the way the handler should behave. */ static handlerKeyOptions: Partial & { [GENERAL_OPTIONS]?: HandlerKeyOptions; }>; /** * The custom keys. */ static readonly customHandlerKeys: string[]; /** * This is not for external use. It is purely here for TypeScript inference of * the generic `Options` type parameter. * * @internal */ ['~O']: Options & DefaultStaticOptions; /** * This identifies this as a `Remirror` object. . * @internal */ abstract readonly [__INTERNAL_REMIRROR_IDENTIFIER_KEY__]: RemirrorIdentifier; /** * The unique name of this extension. * * @remarks * * Every extension **must** have a name. The name should have a distinct type * to allow for better type inference for end users. By convention the name * should be `camelCased` and unique within your editor instance. * * ```ts * class SimpleExtension extends Extension { * get name() { * return 'simple' as const; * } * } * ``` */ abstract get name(): string; /** * The options for this extension. * * @remarks * * Options are composed of Static, Dynamic, Handlers and ObjectHandlers. * * - `Static` - set at instantiation by the constructor. * - `Dynamic` - optionally set at instantiation by the constructor and also * set during the runtime. * - `Handlers` - can only be set during the runtime. * - `ObjectHandlers` - Can only be set during the runtime of the extension. */ get options(): RemoveAnnotations & DefaultStaticOptions>; /** * Get the dynamic keys for this extension. */ get dynamicKeys(): string[]; /** * The options that this instance was created with, merged with all the * default options. */ get initialOptions(): RemoveAnnotations & DefaultStaticOptions>; /** * The initial options at creation (used to reset). */ private readonly _initialOptions; /** * All the dynamic keys supported by this extension. */ private readonly _dynamicKeys; /** * Private instance of the extension options. */ private _options; /** * The mapped function handlers. */ private _mappedHandlers; constructor(defaultOptions: DefaultStaticOptions, ...[options]: ConstructorProps); /** * This method is called by the extension constructor. It is not strictly a * lifecycle method since at this point the manager has not yet been * instantiated. * * @remarks * * It should be used instead of overriding the constructor which is strongly * advised against. * * There are some limitations when using this method. * * - Accessing `this.store` will throw an error since the manager hasn't been * created and it hasn't yet been attached to the extensions. * - `this.type` in `NodeExtension` and `MarkExtension` will also throw an * error since the schema hasn't been created yet. * * You should use this to setup any instance properties with the options * provided to the extension. */ protected init(): void; /** * Clone the current instance with the provided options. If nothing is * provided it uses the same initial options as the current instance. */ abstract clone(...parameters: ConstructorProps): BaseClass; /** * Get the dynamic keys for this extension. */ private getDynamicKeys; /** * Throw an error if non dynamic keys are updated. */ private ensureAllKeysAreDynamic; /** * Update the properties with the provided partial value when changed. */ setOptions(update: GetPartialDynamic): void; /** * Reset the extension properties to their default values. * * @nonVirtual */ resetOptions(): void; /** * Override this to receive updates whenever the options have been updated on * this instance. This method is called after the updates have already been * applied to the instance. If you need more control over exactly how the * option should be applied you should set the option to be `Custom`. * * **Please Note**: * * This must be defined as a instance method and not a property since it is * called in the constructor. * * ```ts * class ThisPreset extends Preset { * // GOOD ✅ * onSetOptions(props: OnSetOptionsProps) {} * * // BAD ❌ * onSetOptions = (props: OnSetOptionsProps) => {} * } * ``` * * @abstract */ protected onSetOptions?(props: OnSetOptionsProps): void; /** * Update the private options. */ private getDynamicOptions; /** * Update the dynamic options. */ private updateDynamicOptions; /** * Set up the mapped handlers object with default values (an empty array); */ private populateMappedHandlers; /** * This is currently fudged together, I'm not sure it will work. */ private createDefaultHandlerOptions; /** * Add a handler to the event handlers so that it is called along with all the * other handler methods. * * This is helpful for integrating react hooks which can be used in multiple * places. The original problem with fixed properties is that you can only * assign to a method once and it overwrites any other methods. This pattern * for adding handlers allows for multiple usages of the same handler in the * most relevant part of the code. * * More to come on this pattern. * * @nonVirtual */ addHandler>(key: Key, method: GetHandler[Key], priority?: ExtensionPriority): Dispose; /** * Determines if handlers exist for the given key. * * Checking the existence of a handler property directly gives wrong results. * `this.options.onHandlerName` is always truthy because it is a reference to * the wrapper function that calls each handler. * * ```ts * * // GOOD ✅ * if (!this.hasHandlers('onHandlerName')) { * return; * } * * // BAD ❌ * if (!this.options.onHandlerName) { * return; * } * ``` * * @param key The handler to test */ hasHandlers>(key: Key): boolean; private sortHandlers; /** * A method that can be used to add a custom handler. It is up to the * extension creator to manage the handlers and dispose methods. */ addCustomHandler>(key: Key, value: Required>[Key]): Dispose; /** * Override this method if you want to set custom handlers on your extension. * * This must return a dispose function. */ protected onAddCustomHandler?: AddCustomHandler; } export declare interface BaseClass { constructor: BaseClassConstructor; } export declare interface BaseClassConstructor extends Function { new (...args: ConstructorProps): any; /** * The identifier for the constructor which can determine whether it is a node * constructor, mark constructor or plain constructor. * @internal */ readonly [__INTERNAL_REMIRROR_IDENTIFIER_KEY__]: RemirrorIdentifier; /** * Defines the `defaultOptions` for all extension instances. * * @remarks * * Once set it can't be updated during run time. Some of the settings are * optional and some are not. Any non-required settings must be specified in * the `defaultOptions`. * * **Please note**: There is a slight downside when setting up * `defaultOptions`. `undefined` is not supported for partial settings at this * point in time. As a workaround use `null` as the type and pass it as the * value in the default settings. * * @defaultValue {} * * @internal */ readonly defaultOptions: DefaultOptions; /** * An array of the keys that are static for this extension. * * This is actually currently unused, but might become useful in the future. * An auto-fix lint rule will be added should that be the case. */ readonly staticKeys: string[]; /** * An array of all the keys which correspond to the the event handler options. * * This **MUST** be present if you want to use event handlers in your * extension. * * Every key here is automatically removed from the `setOptions` method and is * added to the `addHandler` method for adding new handlers. The * `this.options[key]` is automatically replaced with a method that combines * all the handlers into one method that can be called effortlessly. All this * work is done for you. */ readonly handlerKeys: string[]; /** * Customize the way the handler should behave. */ readonly handlerKeyOptions: Partial & { __ALL__?: HandlerKeyOptions; }>; /** * A list of the custom keys in the extension or preset options. */ readonly customHandlerKeys: string[]; } declare interface BaseExtensionOptions extends Remirror.BaseExtensionOptions { /** * An object which excludes certain functionality from an extension. */ exclude?: ExcludeOptions; /** * The priority with which this extension should be loaded by the manager. * * @remarks * * Each priority level corresponds to a higher level of importance for the * extension within the editor. * * When this is set to `null` the `defaultPriority` level for the extension * will be used instead. */ priority?: ExtensionPriority; } export { BaseExtensionOptions } export { BaseExtensionOptions as BaseExtensionOptions_alias_1 } declare interface BaseFramework { /** * The name of the framework being used. */ readonly name: string; /** * The state that is initially passed into the editor. */ initialEditorState: EditorState; /** * The minimum required output from the framework. */ readonly frameworkOutput: FrameworkOutput; /** * Destroy the framework and cleanup all created listeners. */ destroy(): void; } export { BaseFramework } export { BaseFramework as BaseFramework_alias_1 } export { BaseFramework as BaseFramework_alias_2 } declare interface BasePlaceholder { /** * A custom class name to use for the placeholder decoration. All the trackers * will automatically be given the class name `remirror-tracker-position` * * @defaultValue '' */ className?: string; /** * A custom html element or string for a created element tag name. * * @defaultValue 'tracker' */ nodeName?: string; } export { Brand } declare interface BuiltinOptions extends SuggestOptions, KeymapOptions, DecorationsOptions, InputRulesOptions { } export { BuiltinOptions } export { BuiltinOptions as BuiltinOptions_alias_1 } export { BuiltinOptions as BuiltinOptions_alias_2 } declare type BuiltinPreset = TagsExtension | SchemaExtension | AttributesExtension | PluginsExtension | InputRulesExtension | PasteRulesExtension | NodeViewsExtension | SuggestExtension | CommandsExtension | HelpersExtension | KeymapExtension | DocChangedExtension | UploadExtension | DecorationsExtension; export { BuiltinPreset } export { BuiltinPreset as BuiltinPreset_alias_1 } export { BuiltinPreset as BuiltinPreset_alias_2 } /** * Provides all the builtin extensions to the editor. * * @remarks * * This is used automatically and (at the time of writing) can't be removed from * the editor. If you feel that there's a compelling reason to override these * extensions feel free to create a [discussion * here](https://github.com/remirror/remirror/discussions/category_choices) and * it can be addressed. * * @category Builtin Extension * * The order of these extension are important. * * - [[`TagsExtension`]] is places first because it provides tagging which is * used by the schema extension. * - [[`SchemeExtension`]] goes next because it's super important to the editor * functionality and needs to run before everything else which might depend * on it. */ declare function builtinPreset(options?: GetStaticAndDynamic): BuiltinPreset[]; export { builtinPreset } export { builtinPreset as builtinPreset_alias_1 } export { builtinPreset as builtinPreset_alias_2 } export { callIfDefined } export { CamelCase } export { camelCase } export { canInsertNode } export { capitalCase } export { capitalize } export { Cast } declare interface ChainableCommandDecoratorOptions extends Remirror.CommandDecoratorOptions { /** * Set this to `true` to disable chaining of this command. This means it will * no longer be available when running ` * * @defaultValue false */ disableChaining?: false; } export { chainableEditorState } export { chainCommands } declare interface ChainedCommandProps { /** * Dispatches the chained commands. * * ```ts * chain.insertText('hello').run(); * ``` * * This will run all commands in the chain regardless of whether a previous * command was not able to be run. * * If `exitEarly` is set to true the commands will stop running at the first * chainable command which doesn't return true. */ run: (options?: { exitEarly?: boolean; }) => void; /** * Applies the updates to the transaction without dispatching the transaction. * * This can be used to update a transaction without applying the update. */ tr: () => Transaction; /** * Check to see whether the command chain can be run. Returns true when the * command can be run. * * ```ts * if (chain.insertText('hello').enabled()) { * doSomething(); * } * ``` */ enabled: () => boolean; } export { ChainedCommandProps } export { ChainedCommandProps as ChainedCommandProps_alias_1 } export { ChainedCommandProps as ChainedCommandProps_alias_2 } declare type ChainedFromExtensions = ChainedIntersection> = _ChainedFromExtensions & ((tr: Transaction) => _ChainedFromExtensions); export { ChainedFromExtensions } export { ChainedFromExtensions as ChainedFromExtensions_alias_1 } export { ChainedFromExtensions as ChainedFromExtensions_alias_2 } declare type _ChainedFromExtensions = ChainedIntersection> = ChainedCommandProps & NewChainedCommandProps & { [Command in keyof Chained]: Chained[Command] extends (...args: any[]) => any ? (...args: Parameters) => ChainedFromExtensions : never; }; declare type ChainedIntersection = UnionToIntersection | GetDecoratedCommands>>; export { ChainedIntersection } export { ChainedIntersection as ChainedIntersection_alias_1 } export { ChainedIntersection as ChainedIntersection_alias_2 } export { chainKeyBindingCommands } /** * Highlights all the properties that have changed. */ declare type ChangedOptions = { [Key in keyof GetDynamic]: Changes[Key]>; }; export { ChangedOptions } export { ChangedOptions as ChangedOptions_alias_1 } declare type Changes = { /** * Whether or not the value has changed. * * - `false` when no change occurred. */ changed: false; } | { /** * - `true` when a change occurred. */ changed: true; /** * The previous value before the changed. This is only accessible when * `changed` is `true`. */ previousValue: Type; /** * The latest value after the change. This is only accessible when * `changed` is `true`. */ value: Type; }; export { clamp } export { Class } export { ClassName } export { cleanupOS } export { clone } export { cloneTransaction } /** * The shape of the tag data stored by the extension manager. * * This data can be used by other extensions to dynamically determine which * nodes should affected by commands / plugins / keys etc... */ declare type CombinedTags = Record; export { CombinedTags } export { CombinedTags as CombinedTags_alias_1 } export { CombinedTags as CombinedTags_alias_2 } /** * A decorator which can be applied to top level methods on an extension to * identify them as commands. This can be used as a replacement for the * `createCommands` method. * * If you prefer not to use decorators, then you can continue using * `createCommands`. Internally the decorators are being used as they are better * for documentation purposes. * * For automated type inference methods that use this decorator must implement * the following type signature. * * ```ts * import { CommandFunction } from '@remirror/core'; * * type Signature = (...args: any[]) => CommandFunction; * ``` * * The following is an example of how this can be used within your extension. * * ```ts * import { command, CommandFunction } from '@remirror/core'; * * class MyExtension { * get name() { * return 'my'; * } * * @command() * myCommand(text: string): CommandFunction { * return ({ tr, dispatch }) => { * dispatch?.(tr.insertText('my command ' + text)); * return true; * } * } * } * ``` * * The above command can now be used within your editor instance. * * ```tsx * import { useRemirrorContext } from '@remirror/react'; * * const MyEditorButton = () => { * const { commands } = useRemirrorContext(); * * return * } * ``` * * @category Method Decorator */ declare function command(options?: ChainableCommandDecoratorOptions>>): ExtensionDecorator; declare function command(options: NonChainableCommandDecoratorOptions>>): ExtensionDecorator; export { command } export { command as command_alias_1 } export { command as command_alias_2 } declare type CommandDecoratorMessage = CommandDecoratorValue; export { CommandDecoratorMessage } export { CommandDecoratorMessage as CommandDecoratorMessage_alias_1 } export { CommandDecoratorMessage as CommandDecoratorMessage_alias_2 } declare interface CommandDecoratorMessageProps { /** * True when the command is enabled. */ enabled: boolean; /** * True when the extension is active. */ active: boolean; /** * Predefined attributes which can influence the returned value. */ attrs: ProsemirrorAttributes | undefined; /** * A translation utility for translating a predefined string / or message * descriptor. */ t: I18nFormatter; } export { CommandDecoratorMessageProps } export { CommandDecoratorMessageProps as CommandDecoratorMessageProps_alias_1 } export { CommandDecoratorMessageProps as CommandDecoratorMessageProps_alias_2 } declare type CommandDecoratorOptions = ChainableCommandDecoratorOptions | NonChainableCommandDecoratorOptions; export { CommandDecoratorOptions } export { CommandDecoratorOptions as CommandDecoratorOptions_alias_1 } export { CommandDecoratorOptions as CommandDecoratorOptions_alias_2 } declare type CommandDecoratorShortcut = string | { shortcut: string; attrs: ProsemirrorAttributes; } | string[] | Array<{ shortcut: string; attrs: ProsemirrorAttributes; }>; export { CommandDecoratorShortcut } export { CommandDecoratorShortcut as CommandDecoratorShortcut_alias_1 } export { CommandDecoratorShortcut as CommandDecoratorShortcut_alias_2 } /** * @typeParam Value - the value which should be returned from the function or * used directly. */ declare type CommandDecoratorValue = ((props: CommandDecoratorMessageProps) => Value) | Value; export { CommandDecoratorValue } export { CommandDecoratorValue as CommandDecoratorValue_alias_1 } export { CommandDecoratorValue as CommandDecoratorValue_alias_2 } declare interface CommandExtensionMeta { forcedUpdates?: UpdatableViewProps[]; } export { CommandExtensionMeta } export { CommandExtensionMeta as CommandExtensionMeta_alias_1 } export { CommandExtensionMeta as CommandExtensionMeta_alias_2 } export { CommandFunction } export { CommandFunctionProps } declare interface CommandMetadata { type: 'command'; /** * Was this called as part of a chain? */ chain: boolean; /** * Is this a decorated command? */ decorated: boolean; /** * The name of the extension. */ extension: string; /** * The name of the command that was called. */ name: string; } /** * Utility type for pulling all the command names from a list */ declare type CommandNames = StringKey>; export { CommandNames } export { CommandNames as CommandNames_alias_1 } export { CommandNames as CommandNames_alias_2 } declare interface CommandOptions { /** * The className that is added to all tracker positions * * '@defaultValue 'remirror-tracker-position' */ trackerClassName?: Static; /** * The default element that is used for all trackers. * * @defaultValue 'span' */ trackerNodeName?: Static; } export { CommandOptions } export { CommandOptions as CommandOptions_alias_1 } export { CommandOptions as CommandOptions_alias_2 } /** * Generate chained and unchained commands for making changes to the editor. * * @remarks * * Typically actions are used to create interactive menus. For example a menu * can use a command to toggle bold formatting or to undo the last action. * * @category Builtin Extension */ declare class CommandsExtension extends PlainExtension { get name(): "commands"; /** * The current transaction which allows for making commands chainable. * * It is shared by all the commands helpers and can even be used in the * [[`KeymapExtension`]]. * * @internal */ get transaction(): Transaction; /** * This is the holder for the shared transaction which is shared by commands * in order to support chaining. * * @internal */ private _transaction?; /** * Track the decorated command data. */ private readonly decorated; onCreate(): void; /** * Attach commands once the view is attached. */ onView(view: EditorView_2): void; /** * Update the cached transaction whenever the state is updated. */ onStateUpdate({ state }: StateUpdateLifecycleProps): void; /** * Create a plugin that solely exists to track forced updates via the * generated plugin key. */ createPlugin(): CreateExtensionPlugin; /** * Enable custom commands to be used within the editor by users. * * This is preferred to the initial idea of setting commands on the * manager or even as a prop. The problem is that there's no typechecking * and it should be just fine to add your custom commands here to see the * dispatched immediately. * * To use it, firstly define the command. * * ```ts * import { CommandFunction } from 'remirror'; * * const myCustomCommand: CommandFunction = ({ tr, dispatch }) => { * dispatch?.(tr.insertText('My Custom Command')); * * return true; * } * ``` * * And then use it within the component. * * ```ts * import React, { useCallback } from 'react'; * import { useRemirror } from '@remirror/react'; * * const MyEditorButton = () => { * const { commands } = useRemirror(); * const onClick = useCallback(() => { * commands.customDispatch(myCustomCommand); * }, [commands]) * * return * } * ``` * * An alternative is to use a custom command directly from a * `prosemirror-*` library. This can be accomplished in the following way. * * * ```ts * import { joinDown } from 'prosemirror-commands'; * import { convertCommand } from 'remirror'; * * const MyEditorButton = () => { * const { commands } = useRemirror(); * const onClick = useCallback(() => { * commands.customDispatch(convertCommand(joinDown)); * }, [commands]); * * return ; * }; * ``` */ customDispatch(command: CommandFunction): CommandFunction; /** * Insert text into the dom at the current location by default. If a * promise is provided instead of text the resolved value will be inserted * at the tracked position. */ insertText(text: string | (() => Promise), options?: InsertTextOptions): CommandFunction; /** * Select the text within the provided range. * * Here are some ways it can be used. * * ```ts * // Set to the end of the document. * commands.selectText('end'); * * // Set the selection to the start of the document. * commands.selectText('start'); * * // Select all the text in the document. * commands.selectText('all') * * // Select a range of text. It's up to you to make sure the selected * // range is valid. * commands.selectText({ from: 10, to: 15 }); * * // Specify the anchor and range in the selection. * commands.selectText({ anchor: 10, head: 15 }); * * // Set to a specific position. * commands.selectText(10); * * // Use a ProseMirror selection * commands.selectText(TextSelection.near(state.doc.resolve(10))) * ``` * * Although this is called `selectText` you can provide your own selection * option which can be any type of selection. */ selectText(selection: PrimitiveSelection, options?: { forceUpdate?: boolean; }): CommandFunction; /** * Select the link at the current location. */ selectMark(type: string | MarkType): CommandFunction; /** * Delete the provided range or current selection. */ delete(range?: FromToProps): CommandFunction; /** * Fire an empty update to trigger an update to all decorations, and state * that may not yet have run. * * This can be used in extensions to trigger updates when certain options that * affect the editor state have changed. * * @param action - provide an action which is called just before the empty * update is dispatched (only when dispatch is available). This can be used in * chainable editor scenarios when you want to lazily invoke an action at the * point the update is about to be applied. */ emptyUpdate(action?: () => void): CommandFunction; /** * Force an update of the specific updatable ProseMirror props. * * This command is always available as a builtin command. * * @category Builtin Command */ forceUpdate(...keys: UpdatableViewProps[]): CommandFunction; /** * Update the attributes for the node at the specified `pos` in the * editor. * * @category Builtin Command */ updateNodeAttributes(pos: number, attrs: ProsemirrorAttributes): CommandFunction; /** * Set the content of the editor while preserving history. * * Under the hood this is replacing the content in the document with the new * state.doc of the provided content. * * If the content is a string you will need to ensure you have the proper * string handler set up in the editor. */ setContent(content: RemirrorContentType, selection?: PrimitiveSelection): CommandFunction; /** * Reset the content of the editor while preserving the history. * * This means that undo and redo will still be active since the doc is replaced with a new doc. */ resetContent(): CommandFunction; /** * Fire an update to remove the current range selection. The cursor will * be placed at the anchor of the current range selection. * * A range selection is a non-empty text selection. * * @category Builtin Command */ emptySelection(): CommandFunction; /** * Insert a new line into the editor. * * Depending on editor setup and where the cursor is placed this may have * differing impacts. * * @category Builtin Command */ insertNewLine(): CommandFunction; /** * Insert a node into the editor with the provided content. * * @category Builtin Command */ insertNode(node: string | NodeType | ProsemirrorNode | Fragment, options?: InsertNodeOptions): CommandFunction; /** * Set the focus for the editor. * * If using this with chaining this should only be placed at the end of * the chain. It can cause hard to debug issues when used in the middle of * a chain. * * ```tsx * import { useCallback } from 'react'; * import { useRemirrorContext } from '@remirror/react'; * * const MenuButton = () => { * const { chain } = useRemirrorContext(); * const onClick = useCallback(() => { * chain * .toggleBold() * .focus('end') * .run(); * }, [chain]) * * return * } * ``` */ focus(position?: FocusType): CommandFunction; /** * Blur focus from the editor and also update the selection at the same * time. */ blur(position?: PrimitiveSelection): CommandFunction; /** * Set the block type of the current selection or the provided range. * * @param nodeType - the node type to create * @param attrs - the attributes to add to the node type * @param selection - the position in the document to set the block node * @param preserveAttrs - when true preserve the attributes at the provided selection */ setBlockNodeType(nodeType: string | NodeType, attrs?: ProsemirrorAttributes, selection?: PrimitiveSelection, preserveAttrs?: boolean): CommandFunction; /** * Toggle between wrapping an inactive node with the provided node type, and * lifting it up into it's parent. * * @param nodeType - the node type to toggle * @param attrs - the attrs to use for the node * @param selection - the selection point in the editor to perform the action */ toggleWrappingNode(nodeType: string | NodeType, attrs?: ProsemirrorAttributes, selection?: PrimitiveSelection): CommandFunction; /** * Toggle a block between the provided type and toggleType. */ toggleBlockNodeItem(toggleProps: ToggleBlockItemProps): CommandFunction; /** * Wrap the selection or the provided text in a node of the given type with the * given attributes. */ wrapInNode(nodeType: string | NodeType, attrs?: ProsemirrorAttributes, range?: FromToProps | undefined): CommandFunction; /** * Removes a mark from the current selection or provided range. */ applyMark(markType: string | MarkType, attrs?: ProsemirrorAttributes, selection?: PrimitiveSelection): CommandFunction; /** * Removes a mark from the current selection or provided range. */ toggleMark(props: ToggleMarkProps): CommandFunction; /** * Removes a mark from the current selection or provided range. */ removeMark(props: RemoveMarkProps): CommandFunction; /** * Set the meta data to attach to the editor on the next update. */ setMeta(name: string, value: unknown): CommandFunction; /** * Select all text in the editor. */ selectAll(): CommandFunction; /** * Copy the selected content for non empty selections. */ copy(): CommandFunction; /** * Select all text in the editor. */ paste(): CommandFunction; /** * Cut the selected content. */ cut(): CommandFunction; /** * Replaces text with an optional appended string at the end. The replacement * can be text, or a custom node. * * @param props - see [[`ReplaceTextProps`]] */ replaceText(props: ReplaceTextProps): CommandFunction; /** * Get the all the decorated commands available on the editor instance. */ getAllCommandOptions(): Helper>>; /** * Get the options that were passed into the provided command. */ getCommandOptions(name: string): Helper | undefined>; /** * A short hand way of getting the `view`, `state`, `tr` and `dispatch` * methods. */ getCommandProp(): Helper>; /** * Update the command options via a shallow merge of the provided options. If * no options are provided the entry is deleted. * * @internal */ updateDecorated(name: string, options?: Partial>): void; /** * Needed on iOS since `requestAnimationFrame` doesn't breaks the focus * implementation. */ private handleIosFocus; /** * Focus the editor after a slight delay. */ private delayedFocus; /** * A helper for forcing through updates in the view layer. The view layer can * check for the meta data of the transaction with * `manager.store.getForcedUpdate(tr)`. If that has a value then it should use * the unique symbol to update the key. */ private readonly forceUpdateTransaction; /** * Check for a forced update in the transaction. This pulls the meta data * from the transaction and if it is true then it was a forced update. * * ```ts * import { CommandsExtension } from 'remirror/extensions'; * * const commandsExtension = manager.getExtension(CommandsExtension); * log(commandsExtension.getForcedUpdates(tr)) * ``` * * This can be used for updating: * * - `nodeViews` * - `editable` status of the editor * - `attributes` - for the top level node * * @internal */ private getForcedUpdates; /** * Get the command metadata. */ private getCommandMeta; private setCommandMeta; /** * Add the commands from the provided `commands` property to the `chained`, * `original` and `unchained` objects. */ private addCommands; /** * Create an unchained command method. */ private unchainedFactory; /** * Create the unchained command. */ private createUnchainedCommand; /** * Create a chained command method. */ private chainedFactory; } export { CommandsExtension } export { CommandsExtension as CommandsExtension_alias_1 } export { CommandsExtension as CommandsExtension_alias_2 } /** * Utility type which receives an extension and provides the type of actions it * makes available. * * @typeParam Extension - the extensions being used within the editor * @typeParam Expanded - auto generated from `Extension`. These are the * fully expanded extensions with all sub extensions automatically provided. You * never need to provide this type as it is automatically calculated. */ declare type CommandsFromExtensions> = UnionToIntersection | GetDecoratedCommands>>; export { CommandsFromExtensions } export { CommandsFromExtensions as CommandsFromExtensions_alias_1 } export { CommandsFromExtensions as CommandsFromExtensions_alias_2 } /** * The type of a non chainable command. It is a function with an `enabled` * method to check whether the command can be run. */ declare interface CommandShape { /** * Returns true when the command can be run and false when it can't be run. It * basically runs the command without dispatching it to see whether it returns * true or false. * * @remarks * * Some commands can have rules and restrictions. For example, formatting like *`bold` is disabled within a `codeBlock`. In this case *`commands.toggleBold.enabled()` returns `false` when within a `codeBlock` *and `true` when outside. * * @param args - The same arguments that are applied to the command function. */ enabled: (...args: Parameter) => boolean; /** * This function gives you access to the original command defined by the * extension in your editor exactly as it was defined. * * The function returns a function that takes the CommandFunctionProps of * `{ state, dispatch?, tr, view? }` object. * * ```ts * function command(...args: any[]) => CommandFunction; * ``` */ original: (...args: Parameter) => CommandFunction; /** * Commands which are not attached to a node extension or a mark extension can * optionally define custom `isActive` checker. * * This is used for checking if `centerAlign` is active from the * `@remirror/extension-node-formatting`. */ active?: () => boolean; (...args: Parameter): void; } export { CommandShape } export { CommandShape as CommandShape_alias_1 } declare interface CommandUiDecoratorOptions { /** * The default command icon to use if this has a UI representation. */ icon?: CommandDecoratorValue; /** * A label for the command with support for i18n. This makes use of * `babel-plugin-macros` to generate the message. */ label?: CommandDecoratorMessage; /** * An i18n compatible description which can be used to provide extra context * for the command. */ description?: CommandDecoratorMessage; /** * A keyboard shortcut which can be used to run the specified command. * * Rather than defining this here, you should create a decorated `keyBinding` * and set the `command` name option. This way the shortcut will dynamically * be added at runtime. */ shortcut?: CommandDecoratorShortcut; } export { CommandUiDecoratorOptions } export { CommandUiDecoratorOptions as CommandUiDecoratorOptions_alias_1 } export { CommandUiDecoratorOptions as CommandUiDecoratorOptions_alias_2 } declare interface CommandUiIcon { /** * The icon name. */ name: CoreIcon; /** * Text placed in a superscript position. For `ltr` this is in the top right * hand corner of the icon. */ sup?: string; /** * Text placed in a subscript position. For `ltr` this is in the bottom right * hand corner. */ sub?: string; } export { CommandUiIcon } export { CommandUiIcon as CommandUiIcon_alias_1 } export { CommandUiIcon as CommandUiIcon_alias_2 } export { composeTransactionSteps } export { ConditionalExcept } export { ConditionalKeys } export { ConditionalPick } export { ConditionalReturnKeys } export { ConditionalReturnPick } export { constantCase } /** * Auto infers the parameter for the constructor. If there is a required static * option then the TypeScript compiler will error if nothing is passed in. */ export declare type ConstructorProps = IfNoRequiredProperties, [ options?: GetConstructorProps & DefaultStaticOptions ], [ options: GetConstructorProps & DefaultStaticOptions ]>; export { containsAttributes } export { containsNodesOfType } export { convertCommand } export { convertPixelsToDomUnit } export { Coords } export { CoreIcon } export { createDocumentNode } export { CreateDocumentNodeProps } declare interface CreateEditorStateProps extends Omit { /** * This is where content can be supplied to the Editor. * * @remarks * * Content can either be * - a string (which will be parsed by the stringHandler) * - JSON object matching Prosemirror expected shape * - A top level ProsemirrorNode * * If this is left undefined then the editor will use the default empty `doc`. */ content?: RemirrorContentType; /** * The selection that the user should have in the created node. * * @defaultValue 'end' */ selection?: PrimitiveSelection; /** * A function which transforms a string into a prosemirror node. * * @remarks * * Can be used to transform markdown / html or any other string format into a * prosemirror node. * * See [[`fromHTML`]] for an example of how this could work. */ stringHandler?: keyof Remirror.StringHandlers | StringHandler; } export { CreateEditorStateProps } export { CreateEditorStateProps as CreateEditorStateProps_alias_1 } export { CreateEditorStateProps as CreateEditorStateProps_alias_2 } /** * An interface for creating custom plugins in your `remirror` editor. */ declare interface CreateExtensionPlugin extends Pick, 'props' | 'state' | 'key' | 'view' | 'filterTransaction' | 'appendTransaction'> { /** Additional properties are allowed on plugin specs, which can be read via [`Plugin.spec`](https://prosemirror.net/docs/ref/#state.Plugin.spec). */ [key: string]: any; } export { CreateExtensionPlugin } export { CreateExtensionPlugin as CreateExtensionPlugin_alias_1 } declare type CreateStateFromContent = (content: RemirrorContentType, selection?: PrimitiveSelection) => EditorState; export { CreateStateFromContent } export { CreateStateFromContent as CreateStateFromContent_alias_1 } export { CreateStateFromContent as CreateStateFromContent_alias_2 } export declare function createUploadContext(): UploadContext; export declare function createUploadPlaceholderPlugin(): Plugin_2; export { CustomDocumentProps } export { CustomHandler } export { CustomHandlerKey } export { CustomHandlerKeyList } declare interface CustomHandlerKeysProps { customHandlerKeys: CustomHandlerKeyList; } /** * @internal */ declare type CustomHandlerMethod = >(key: Key, value: Required>[Key]) => Dispose; export { CustomHandlerMethod } export { CustomHandlerMethod as CustomHandlerMethod_alias_1 } export { CustomHandlerShape } export { cx } declare interface DataProps { /** * The data to store for this placeholder. */ data?: Data; } export { debounce } export { DebouncedFunction } export { Decoration } declare type DecorationPlaceholder = WidgetPlaceholder | NodePlaceholder | InlinePlaceholder; export { DecorationPlaceholder } export { DecorationPlaceholder as DecorationPlaceholder_alias_1 } export { DecorationPlaceholder as DecorationPlaceholder_alias_2 } declare interface DecorationPlaceholderMeta { /** * The trackers to add. */ added?: Array>; /** * The trackers to update with new data. Data is an object and is used to * include properties like `progress` for progress indicators. Only `widget` * decorations can be updated in this way. */ updated?: Array<{ id: unknown; data: any; }>; /** * The trackers to remove. */ removed?: unknown[]; /** * When set to true will delete all the active trackers. */ clearTrackers?: boolean; } export { DecorationPlaceholderMeta } export { DecorationPlaceholderMeta as DecorationPlaceholderMeta_alias_1 } export { DecorationPlaceholderMeta as DecorationPlaceholderMeta_alias_2 } export { DecorationSet } /** * Simplify the process of adding decorations to the editor. All the decorations * added to the document this way are automatically tracked which allows for * custom components to be nested inside decorations. * * @category Builtin Extension */ declare class DecorationsExtension extends PlainExtension { get name(): "decorations"; /** * The placeholder decorations. */ private placeholders; /** * A map of the html elements to their decorations. */ private readonly placeholderWidgets; onCreate(): void; /** * Create the extension plugin for inserting decorations into the editor. */ createPlugin(): CreateExtensionPlugin; updateDecorations(): CommandFunction; /** * Command to dispatch a transaction adding the placeholder decoration to * be tracked. * * @param id - the value that is used to identify this tracker. This can * be any value. A promise, a function call, a string. * @param options - the options to call the tracked position with. You can * specify the range `{ from: number; to: number }` as well as the class * name. */ addPlaceholder(id: unknown, placeholder: DecorationPlaceholder, deleteSelection?: boolean): CommandFunction; /** * A command to updated the placeholder decoration. * * To update multiple placeholders you can use chained commands. * * ```ts * let idsWithData: Array<{id: unknown, data: number}>; * * for (const { id, data } of idsWithData) { * chain.updatePlaceholder(id, data); * } * * chain.run(); * ``` */ updatePlaceholder(id: unknown, data: Data): CommandFunction; /** * A command to remove the specified placeholder decoration. */ removePlaceholder(id: unknown): CommandFunction; /** * A command to remove all active placeholder decorations. */ clearPlaceholders(): CommandFunction; /** * Find the position for the tracker with the ID specified. * * @param id - the unique position id which can be any type */ findPlaceholder(id: unknown): Helper; /** * Find the positions of all the trackers in document. */ findAllPlaceholders(): Helper>; /** * Add some decorations based on the provided settings. */ createDecorations(state: EditorState): DecorationSet_2; /** * This stores all tracked positions in the editor and maps them via the * transaction updates. */ onApplyState(): void; /** * Add a widget placeholder and track it as a widget placeholder. */ private addWidgetPlaceholder; /** * Add an inline placeholder. */ private addInlinePlaceholder; /** * Add a placeholder for nodes. */ private addNodePlaceholder; /** * Add the node and class name to the placeholder object. */ private withRequiredBase; /** * Get the command metadata. */ private getMeta; /** * Set the metadata for the command. */ private setMeta; /** * Add a placeholder decoration with the specified params to the transaction * and return the transaction. * * It is up to you to dispatch the transaction or you can just use the * commands. */ private addPlaceholderTransaction; /** * Update the data stored by a placeholder. * * This replaces the whole data value. */ private updatePlaceholderTransaction; /** * Discards a previously defined tracker once not needed. * * This should be used to cleanup once the position is no longer needed. */ private removePlaceholderTransaction; /** * This helper returns a transaction that clears all position trackers when * any exist. * * Otherwise it returns undefined. */ private clearPlaceholdersTransaction; /** * Handles delayed commands which rely on the */ private readonly createPlaceholderCommand; } export { DecorationsExtension } export { DecorationsExtension as DecorationsExtension_alias_1 } export { DecorationsExtension as DecorationsExtension_alias_2 } declare interface DecorationsOptions { /** * This setting is for adding a decoration to the selected text and can be * used to preserve the marker for the selection when the editor loses focus. * * You can set it as `'selection'` to match the default styles provided by * `@remirror/styles`. * * @defaultValue undefined */ persistentSelectionClass?: AcceptUndefined; /** * Add custom decorations to the editor via `extension.addHandler`. This can * be used via the `useDecorations` hook available from `remirror/react`. */ decorations: Handler<(state: EditorState) => DecorationSet_2>; /** * The className that is added to all placeholder positions * * '@defaultValue 'placeholder' */ placeholderClassName?: Static; /** * The default element that is used for all placeholders. * * @defaultValue 'span' */ placeholderNodeName?: Static; } export { DecorationsOptions } export { DecorationsOptions as DecorationsOptions_alias_1 } export { DecorationsOptions as DecorationsOptions_alias_2 } declare interface DecorationsOptions_2 { } export { deepMerge } export { DeepPartial } export { DeepString } /** * The default named shortcuts used within `remirror`. */ declare const DEFAULT_SHORTCUTS: ShortcutMap; export { DEFAULT_SHORTCUTS } export { DEFAULT_SHORTCUTS as DEFAULT_SHORTCUTS_alias_1 } export { DEFAULT_SHORTCUTS as DEFAULT_SHORTCUTS_alias_2 } export { DefaultDocNodeOptions } /** * Get the expected type signature for the `defaultOptions`. Requires that every * optional setting key (except for keys which are defined on the * `BaseExtensionOptions`) has a value assigned. */ declare type DefaultExtensionOptions = DefaultOptions; export { DefaultExtensionOptions } export { DefaultExtensionOptions as DefaultExtensionOptions_alias_1 } export { DefaultExtensionOptions as DefaultExtensionOptions_alias_2 } export { defaultImport } /** * Get the expected type signature for the `defaultOptions`. Requires that every * optional setting key (except for keys which are defined on the * `BaseExtensionOptions`) has a value assigned. */ export declare type DefaultOptions = MakeUndefined> & Partial & GetFixedDynamic, StringKey>>; declare interface DefaultOptionsProps { /** * The default options. * * All non required options must have a default value provided. * * Please note that as mentioned in this issue * [#624](https://github.com/remirror/remirror/issues/624), partial options * can cause trouble when setting a default. * * If you need to accept `undefined `as an acceptable default option there are * two possible ways to resolve this. * * #### Use `AcceptUndefined` * * This is the preferred solution and should be used instead of the following * `null` union. * * ```ts * import { AcceptUndefined } from 'remirror'; * * interface Options { * optional?: AcceptUndefined; * } * ``` * * Now when the options are consumed by this decorator there should be no * errors when setting the value to `undefined`. * * #### `null` union * * If you don't mind using nulls in your code then this might appeal to you. * * ```ts * interface Options { * optional?: string | null; * } * ``` * * @defaultValue {} */ defaultOptions: DefaultExtensionOptions; } declare interface DefaultPriorityProps { /** * The default priority for this extension. * * @defaultValue {} */ defaultPriority?: ExtensionPriority; } declare class DelayedCommand { private readonly promiseCreator; private readonly failureHandlers; private readonly successHandlers; private readonly validateHandlers; constructor(promiseCreator: DelayedPromiseCreator); /** * The commands that will immediately be run and used to evaluate whether to * proceed. */ validate(handler: CommandFunction, method?: 'push' | 'unshift'): this; /** * Add a success callback to the handler. */ success(handler: CommandFunction<{ value: Value; }>, method?: 'push' | 'unshift'): this; /** * Add a failure callback to the handler. */ failure(handler: CommandFunction<{ error: any; }>, method?: 'push' | 'unshift'): this; private runHandlers; /** * Generate the `remirror` command. */ readonly generateCommand: () => CommandFunction; } export { DelayedCommand } export { DelayedCommand as DelayedCommand_alias_1 } /** * Add tentative support for delayed commands in the editor. * * Delayed commands are commands that run an immediate action, like adding a * tracker to a position in the document. Once the promise that is provided is * returned the `onDone` parameter is run with the document in the current * state. The tracker that was added can now be used to insert content, delete * content or replace content. * * @experimental This is still being worked on and the API is subject to changes * in structure going forward. * * @deprecated use [[`DelayedCommand`]] instead. * */ declare function delayedCommand({ immediate, promise, onDone, onFail, }: DelayedCommandProps): CommandFunction; export { delayedCommand } export { delayedCommand as delayedCommand_alias_1 } /** * The parameter that is passed into `DelayedCommand`s. */ declare interface DelayedCommandProps { /** * Runs as soon as the command is triggered. For most delayed commands within * the `remirror` codebase this is used to add a position tracker to the * document. */ immediate?: CommandFunction; /** * The promise that provides the value that the `onDone` callback uses to * complete the delayed command. */ promise: DelayedValue; /** * Called when the provided promise resolves. */ onDone: CommandFunction<{ value: Value; }>; /** * Called when the promise fails. This could be used to cleanup the active * position trackers when the delayed command fails. */ onFail?: CommandFunction; } declare interface DelayedPlaceholderCommandProps { /** * A function that returns a promise. */ promise: DelayedPromiseCreator; /** * The placeholder configuration. */ placeholder: DecorationPlaceholder; /** * Called when the promise succeeds and the placeholder still exists. If no * placeholder can be found (for example, the user has deleted the entire * document) then the failure handler is called instead. */ onSuccess: (value: Value, range: FromToProps, commandProps: CommandFunctionProps) => boolean; /** * Called when a failure is encountered. */ onFailure?: CommandFunction<{ error: any; }>; } export { DelayedPlaceholderCommandProps } export { DelayedPlaceholderCommandProps as DelayedPlaceholderCommandProps_alias_1 } export { DelayedPlaceholderCommandProps as DelayedPlaceholderCommandProps_alias_2 } declare type DelayedPromiseCreator = (props: CommandFunctionProps) => Promise; export { DelayedPromiseCreator } export { DelayedPromiseCreator as DelayedPromiseCreator_alias_1 } declare type DelayedValue = Promise | (() => Promise); export { DelayedValue } export { DelayedValue as DelayedValue_alias_1 } export { DelimiterCase } export { Diff } export { DispatchFunction } export { Dispose } declare class DocChangedExtension extends PlainExtension { get name(): "docChanged"; onStateUpdate(props: StateUpdateLifecycleProps): void; } export { DocChangedExtension } export { DocChangedExtension as DocChangedExtension_alias_1 } export { DocChangedExtension as DocChangedExtension_alias_2 } declare interface DocChangedOptions { docChanged?: Handler<(props: StateUpdateLifecycleProps) => void>; } export { DocChangedOptions } export { DocChangedOptions as DocChangedOptions_alias_1 } export { DocChangedOptions as DocChangedOptions_alias_2 } export { DOM_SIZE_UNITS } export { DOMCompatibleAttributes } export { DOMOutputSpec } export { DomSizeUnit } export { Dynamic } export { DynamicAttributeCreator } export { DynamicKey } export { DynamicKeyList } /** * Get the options from any constructor. Can be used for both presets and * extensions. */ declare type DynamicOptionsOfConstructor = GetPartialDynamic>>; export { DynamicOptionsOfConstructor } export { DynamicOptionsOfConstructor as DynamicOptionsOfConstructor_alias_1 } export { DynamicShape } export { EditorSchema } export { EditorState } export { EditorStateProps } export { EditorView } export { EditorViewProps } export { EMPTY_ARRAY } export { EMPTY_NODE } export { EMPTY_PARAGRAPH_NODE } export { EmptyShape } export { endPositionOfParent } export { Entries } export { entries } export { Entry } export { environment } export { ErrorConstant } export { Except } declare interface ExcludeOptions extends Partial { } export { ExcludeOptions } export { ExcludeOptions as ExcludeOptions_alias_1 } /** * Extensions are fundamental to the way that Remirror works by grouping * together the functionality and handling the management of similar concerns. * * @remarks * * Extension can adjust editor functionality in any way. Here are some * examples. * * - How the editor displays certain content, i.e. **bold**, _italic_, * **underline**. * - Which commands should be made available e.g. `commands.toggleBold()` to * toggle the weight of the selected text. * - Check if a command is currently enabled (i.e a successful dry run) e.g. * `commands.toggleBold.enabled()`. * - Register Prosemirror `Plugin`s, `keymap`s, `InputRule`s `PasteRule`s, * `Suggestions`, and custom `nodeViews` which affect the behavior of the * editor. * * There are three types of `Extension`. * * - `NodeExtension` - For creating Prosemirror nodes in the editor. See * {@link NodeExtension} * - `MarkExtension` - For creating Prosemirror marks in the editor. See * {@link MarkExtension} * - `PlainExtension` - For behavior which doesn't map to a `ProsemirrorNode` or * `Mark` and as a result doesn't directly affect the Prosemirror `Schema` or * content. See {@link PlainExtension}. * * This `Extension` is an abstract class that should not be used directly but * rather extended to add the intended functionality. * * ```ts * import { PlainExtension, Static } from 'remirror'; * * interface AwesomeExtensionOptions { * isAwesome?: Static; * id?: string; * } * * class AwesomeExtension extends PlainExtension { * static defaultOptions: DefaultExtensionOptions = { * isAwesome: true, * id: '', * } * * get name() { * return 'awesome' as const; * } * } * ``` */ declare abstract class Extension extends BaseClass { /** * The default priority for this family of extensions. */ static readonly defaultPriority: ExtensionPriority; /** * Allows for the `RemirrorManager` or `Preset`'s to override the priority of * an extension. */ private priorityOverride?; /** * The priority level for this instance of the extension. A higher value * corresponds to a higher priority extension */ get priority(): ExtensionPriority; /** * The name that the constructor should have, which doesn't get mangled in * production. */ get constructorName(): string; /** * The store is a shared object that's internal to each extension. It includes * often used items like the `view` and `schema` that are added by the * extension manager and also the lifecycle extension methods. * * **NOTE** - The store is not available until the manager has been created * and received the extension. As a result trying to access the store during * `init` and `constructor` will result in a runtime error. * * Some properties of the store are available at different phases. You should * check the inline documentation to know when a certain property is useable * in your extension. */ protected get store(): Remirror.ExtensionStore; /** * The list of extensions added to the editor by this `Preset`. */ get extensions(): Array; /** * Private list of extension stored within this [[`Preset`]]. */ private _extensions; /** * An extension mapping of the extensions and their constructors. */ private readonly extensionMap; /** * This store is can be modified by the extension manager with and lifecycle * extension methods. * * Different properties are added at different times so it's important to * check the documentation for each property to know what phase is being * added. */ private _store?; constructor(...args: ExtensionConstructorProps); /** * When there are duplicate extensions used within the editor the extension * manager will call this method and make sure all extension holders are using * the same instance of the `ExtensionConstructor`. * * @internal */ replaceChildExtension(constructor: AnyExtensionConstructor, extension: this['~E']): void; /** * Not for usage. This is purely for types to make it easier to infer * available sub extension types. * * @internal */ ['~E']: ReturnType[number]; /** * Create the extensions which will be consumed by the preset. Override this * if you would like to make your extension a parent to other (holder) * extensions which don't make sense existing outside of the context of this * extension. * * @remarks * * Since this method is called in the constructor it should always be created * as an instance method and not a property. Properties aren't available for * the call to the parent class. * * ```ts * class HolderExtension extends PlainExtension { * get name() { * return 'holder' * } * * // GOOD ✅ * createExtensions() { * return []; * } * * // BAD ❌ * createExtensions = () => { * return []; * } * } * ``` */ createExtensions(): AnyExtension[]; /** * Get an extension from this holder extension by providing the desired * `Constructor`. * * @param Constructor - the extension constructor to find in the editor. * * @remarks * * This method will throw an error if the constructor doesn't exist within the * extension created by this extension. * * It can be used to forward options and attach handlers to the children * extensions. It is the spiritual replacement of the `Preset` extension. * * ```ts * import { PlainExtension, OnSetOptionsProps } from 'remirror'; * * interface ParentOptions { weight?: string } * * class ParentExtension extends PlainExtension { * get name() { * return 'parent' as const; * } * * createExtensions() { * return [new BoldExtension()] * } * * onSetOptions(options: OnSetOptionsProps): void { * if (options.changes.weight.changed) { * // Update the value of the provided extension. * this.getExtension(BoldExtension).setOption({ weight: options.changes.weight.value }); * } * } * } * ``` */ getExtension(Constructor: Type): InstanceType; /** * Check if the type of this extension's constructor matches the type of the * provided constructor. */ isOfType(Constructor: Type): this is InstanceType; /** * Pass a reference to the globally shared `ExtensionStore` for this * extension. * * @remarks * * The extension store allows extensions to access important variables without * complicating their creator methods. * * ```ts * import { PlainExtension } from 'remirror'; * * class Awesome extends PlainExtension { * customMethod() { * if (this.store.view.hasFocus()) { * log('dance dance dance'); * } * } * } * ``` * * This should only be called by the `RemirrorManager`. * * @internal * @nonVirtual */ setStore(store: Remirror.ExtensionStore): void; /** * Clone an extension. */ clone(...args: ExtensionConstructorProps): Extension; /** * Set the priority override for this extension. This is used in the * `RemirrorManager` in order to override the priority of an extension. * * If you set the first parameter to `undefined` it will remove the priority * override. * * @internal */ setPriority(priority: undefined | ExtensionPriority): void; /** * This handler is called when the `RemirrorManager` is first created. * * @remarks * * Since it is called as soon as the manager is some methods may not be * available in the extension store. When accessing methods on `this.store` be * shore to check when they become available in the lifecycle. * * You can return a `Dispose` function which will automatically be called when * the extension is destroyed. * * This handler is called before the `onView` handler. * * @category Lifecycle Methods */ onCreate?(): Dispose | void; /** * This event happens when the view is first received from the view layer * (e.g. React). * * Return a dispose function which will be called when the extension is * destroyed. * * This handler is called after the `onCreate` handler. * * @category Lifecycle Methods */ onView?(view: EditorView): Dispose | void; /** * This can be used by the `Extension` to append a transaction to the latest * update. * * This is shorthand for the `ProsemirrorPlugin.spec.appendTransaction`. * * @category Lifecycle Methods */ onAppendTransaction?(props: AppendLifecycleProps): void; /** * This is called when the prosemirror editor state is first attached to the * editor. It can be useful for doing some preparation work. * * This is a shorthand for creating a plugin and adding the * [[`Plugin.spec.state.init`]]. * * @category Lifecycle Methods */ onInitState?(state: EditorState): void; /** * This is called when the state is being applied to the editor. This can be * used as a shorthand for the [[`Plugin.spec.state.apply`]] method. * * For example, when using [[`createDecorations`]] you can respond to editor * updates within this callback. * * @category Lifecycle Methods */ onApplyState?(props: ApplyStateLifecycleProps): void; /** * This handler is called after a transaction successfully updates the editor * state. It is called asynchronously after the [[`onApplyState`]] hook has * been run run. * * @category Lifecycle Methods */ onStateUpdate?(props: StateUpdateLifecycleProps): void; /** * Called when the extension is being destroyed. * * @category Lifecycle Methods */ onDestroy?(): void; } /** * Declaration merging since the constructor property can't be defined on the * actual class. */ declare interface Extension extends Remirror.BaseExtension { /** * The type of the constructor for the extension. */ constructor: ExtensionConstructor; /** * An extension can declare the extensions it requires. * * @remarks * * When creating the extension manager the extension will be checked for * required extension as well as a quick check to see if the required * extension is already included. If not present a descriptive error will be * thrown. */ requiredExtensions?: AnyExtensionConstructor[]; } export { Extension } export { Extension as Extension_alias_1 } export { Extension as Extension_alias_2 } /** * A decorator for the remirror extension. * * This adds static properties to the extension constructor. */ declare function extension(options: ExtensionDecoratorOptions): (ReadonlyConstructor: Type, context?: ClassDecoratorContext | undefined) => Type; export { extension } export { extension as extension_alias_1 } export { extension as extension_alias_2 } declare type ExtensionCommandFunction = (...args: any[]) => CommandFunction; export { ExtensionCommandFunction } export { ExtensionCommandFunction as ExtensionCommandFunction_alias_1 } /** * The return signature for an extensions command method. */ declare interface ExtensionCommandReturn { [command: string]: ExtensionCommandFunction; } export { ExtensionCommandReturn } export { ExtensionCommandReturn as ExtensionCommandReturn_alias_1 } declare interface ExtensionConstructor extends BaseClassConstructor, Partial { new (...args: ExtensionConstructorProps): Extension; /** * The default priority level for all instance of this extension. * * @defaultValue ExtensionPriority.Default */ readonly defaultPriority: ExtensionPriority; } export { ExtensionConstructor } export { ExtensionConstructor as ExtensionConstructor_alias_1 } export { ExtensionConstructor as ExtensionConstructor_alias_2 } /** * Auto infers the parameter for the constructor. If there is a required static * option then the TypeScript compiler will error if nothing is passed in. */ declare type ExtensionConstructorProps = ConstructorProps; export { ExtensionConstructorProps } export { ExtensionConstructorProps as ExtensionConstructorProps_alias_1 } export { ExtensionConstructorProps as ExtensionConstructorProps_alias_2 } declare type ExtensionDecorator = (method: AnyFunction, context: ClassMethodDecoratorContext>) => Return; declare type ExtensionDecoratorOptions = DefaultPriorityProps & IfHasRequiredProperties, DefaultOptionsProps, Partial>> & IfEmpty, Partial>, StaticKeysProps> & IfEmpty, Partial>, HandlerKeysProps> & IfEmpty, Partial>, CustomHandlerKeysProps> & Partial; export { ExtensionDecoratorOptions } export { ExtensionDecoratorOptions as ExtensionDecoratorOptions_alias_1 } export { ExtensionDecoratorOptions as ExtensionDecoratorOptions_alias_2 } /** * The return signature for an extensions helper method. */ declare interface ExtensionHelperReturn { [helper: string]: AnyFunction; } export { ExtensionHelperReturn } export { ExtensionHelperReturn as ExtensionHelperReturn_alias_1 } declare interface ExtensionListProps { /** * The extensions property. */ readonly extensions: readonly Extension[]; } export { ExtensionListProps } export { ExtensionListProps as ExtensionListProps_alias_1 } export { ExtensionListProps as ExtensionListProps_alias_2 } export { ExtensionPriority } /** * The extension store which is shared across all extensions. It provides access * to methods and data that can be used throughout the extension lifecycle. */ declare interface ExtensionStore extends Remirror.ExtensionStore { } export { ExtensionStore } export { ExtensionStore as ExtensionStore_alias_1 } export { ExtensionTag } export { ExtensionTagType } /** * A function that returns the extension to be used in the RemirrorManager. This * is similar to a preset function except that it takes no arguments. * * ```ts * import { RemirrorManager } from 'remirror'; * import { BoldExtension, ItalicExtension } from 'remirror/extensions'; * * const template = () => [new BoldExtension(), new ItalicExtension()] * const manager = RemirrorManager.create(template); * ``` * * If the template is mixed in with other manager creators it will add the * relevant extension provided. */ declare type ExtensionTemplate = () => Extension[]; export { ExtensionTemplate } export { ExtensionTemplate as ExtensionTemplate_alias_1 } /** * This is the object shape that is returned from the combined transformation. */ export declare interface ExtensionTransformation> { /** * The list of extensions sorted by priority and original extension. Every * extension passed in and those contained by presets are placed here. */ extensions: Expanded[]; /** * A map where the key is the [[`ExtensionConstructor`]] and the value is the * [[`Extension`]] instance. This is used to lookup extensions contained * within a manager. It is a weak map so that values can be garbage collected * when references to the constructor are lost. */ extensionMap: WeakMap, Expanded>; } /** * This helper function extracts all the lifecycle methods from the provided * extension and adds them to the provided `handler` container. */ export declare function extractLifecycleMethods(props: SetupExtensionProps): void; export { extractPixelSize } declare interface FileUploader { /** * Inserts the file (but doesn't start the upload operation) and returns an * object with this to be uploaded file's attributes. */ insert: (file: File) => NodeAttributes; /** * Starts the upload operation and returns a promise. The promise will be * resolved by a successful upload with uploaded file's attributes, or rejected * because of an error. * * `upload` can update the object `context` to update information during * the upload process. `context` will be passed to the render function. The * render function can add a listener to `context` by using `context.addListener` * to get the updated values. The default render function will try to find the * keys `loaded` and `total` in `context`, which are two numbers that * represent the progress of the upload. */ upload: (context: UploadContext) => Promise; /** * Aborts the upload operation. */ abort: () => void; } export { FileUploader } export { FileUploader as FileUploader_alias_1 } export { FileUploader as FileUploader_alias_2 } export { FileUploader as FileUploader_alias_3 } export { findBlockNodes } export { findChildren } export { findChildrenByAttribute } export { findChildrenByMark } export { findChildrenByNode } export { findElementAtPosition } export { findInlineNodes } export { findMatches } export { findNodeAtPosition } export { findNodeAtSelection } export { findParentNode } export { findParentNodeOfType } export { findPositionOfNodeAfter } export { findPositionOfNodeBefore } export { FindProsemirrorNodeResult } export { findSelectedNodeOfType } export { findTextNodes } declare function findUploadPlaceholderPayload(state: EditorState_2, id: string): any | undefined; export { findUploadPlaceholderPayload } export { findUploadPlaceholderPayload as findUploadPlaceholderPayload_alias_1 } export { findUploadPlaceholderPayload as findUploadPlaceholderPayload_alias_2 } export { findUploadPlaceholderPayload as findUploadPlaceholderPayload_alias_3 } /** * Try to find the position of the placeholder in the document based on the * upload placeholder id * * @remarks * * This function will first try to find the position based on the decoration set. * However, in some cases (e.g. `ReplaceStep`) the decoration will not be * available. In that case, it will then try to find every node in the document * recursively, which is much slower than the decoration set way in a large * document. */ declare function findUploadPlaceholderPos(state: EditorState_2, id: string): number | undefined; export { findUploadPlaceholderPos } export { findUploadPlaceholderPos as findUploadPlaceholderPos_alias_1 } export { findUploadPlaceholderPos as findUploadPlaceholderPos_alias_2 } export { findUploadPlaceholderPos as findUploadPlaceholderPos_alias_3 } export { FixedLengthArray } export { flattenArray } export { Flavor } export { Flavoring } export { FlipPartialAndRequired } /** * The type of arguments acceptable for the focus parameter. * * - Can be a prosemirror selection * - A range of `{ from: number; to: number }` * - A single position with a `number` * - A string of `'start' | 'end'` * - `true` which sets the focus to the current position or start. */ declare type FocusType = PrimitiveSelection | boolean; export { FocusType } export { FocusType as FocusType_alias_1 } /** * Provides the list of Prosemirror EditorView props that should be updated/ */ declare type ForcedUpdateMeta = UpdatableViewProps[]; export { ForcedUpdateMeta } export { ForcedUpdateMeta as ForcedUpdateMeta_alias_1 } export { ForcedUpdateMeta as ForcedUpdateMeta_alias_2 } export { format } export { Fragment } export { FragmentStringHandlerOptions } /** * This is the `Framework` class which is used to create an abstract class for * implementing `Remirror` into the framework of your choice. * * The best way to learn how to use it is to take a look at the [[`DomFramework`]] * and [[`ReactFramework`]] implementations. * * @remarks * * There are two methods and one getter property which must be implemented for this */ declare abstract class Framework = FrameworkProps, Output extends FrameworkOutput = FrameworkOutput> implements BaseFramework { #private; /** * A previous state that can be overridden by the framework implementation. */ protected previousStateOverride?: EditorState; /** * The event listener which allows consumers to subscribe to the different * events taking place in the editor. Events currently supported are: * * - `destroy` * - `focus` * - `blur` * - `updated` */ protected get addHandler(): AddFrameworkHandler; /** * The updatable view props. */ protected get updatableViewProps(): UpdatableViewPropsObject; /** * True when this is the first render of the editor. */ protected get firstRender(): boolean; /** * Store the name of the framework. */ abstract get name(): string; /** * The props passed in when creating or updating the `Framework` instance. */ get props(): Props; /** * Returns the previous editor state. On the first render it defaults to * returning the current state. For the first render the previous state and * current state will always be equal. */ protected get previousState(): EditorState; /** * The instance of the [[`RemirrorManager`]]. */ protected get manager(): RemirrorManager; /** * The ProseMirror [[`EditorView`]]. */ protected get view(): EditorView; /** * A unique id for the editor. Can be used to differentiate between editors. * * Please note that this ID is only locally unique, it should not be used as a * database key. */ protected get uid(): string; /** * The initial editor state from when the editor was first created. */ get initialEditorState(): EditorState; constructor(options: FrameworkOptions); /** * Setup the manager event listeners which are disposed of when the manager is * destroyed. */ private updateListener; /** * Update the constructor props passed in. Useful for frameworks like react * where props are constantly changing and when using hooks function closures * can become stale. * * You can call the update method with the new `props` to update the internal * state of this instance. */ update(options: FrameworkOptions): this; /** * Retrieve the editor state. */ protected readonly getState: () => EditorState; /** * Retrieve the previous editor state. */ protected readonly getPreviousState: () => EditorState; /** * This method must be implement by the extending framework class. It returns * an [[`EditorView`]] which is added to the [[`RemirrorManager`]]. */ protected abstract createView(state: EditorState, element?: Element): EditorView; /** * This is used to implement how the state updates are used within your * application instance. * * It must be implemented. */ protected abstract updateState(props: UpdateStateProps): void; /** * Update the view props. */ protected updateViewProps(...keys: UpdatableViewProps[]): void; /** * This sets the attributes for the ProseMirror Dom node. */ protected getAttributes(ssr?: false): Record; protected getAttributes(ssr: true): Shape; /** * Part of the Prosemirror API and is called whenever there is state change in * the editor. * * @internalremarks * How does it work when transactions are dispatched one after the other. */ protected readonly dispatchTransaction: (tr: Transaction) => void; /** * Adds `onBlur` and `onFocus` listeners. * * When extending this class make sure to call this method once * `ProsemirrorView` has been added to the dom. */ protected addFocusListeners(): void; /** * Remove `onBlur` and `onFocus` listeners. * * When extending this class in your framework, make sure to call this just * before the view is destroyed. */ protected removeFocusListeners(): void; /** * Called when the component unmounts and is responsible for cleanup. * * @remarks * * - Removes listeners for the editor `blur` and `focus` events */ destroy(): void; /** * Use this method in the `onUpdate` event to run all change handlers. */ readonly onChange: (props?: ListenerProps) => void; /** * Listener for editor 'blur' events */ private readonly onBlur; /** * Listener for editor 'focus' events */ private readonly onFocus; /** * Sets the content of the editor. This bypasses the update function. * * @param content * @param triggerChange */ private readonly setContent; /** * Clear the content of the editor (reset to the default empty node). * * @param triggerChange - whether to notify the onChange handler that the * content has been reset */ private readonly clearContent; /** * Creates the props passed into all event listener handlers. e.g. * `onChange` */ protected eventListenerProps(props?: ListenerProps): RemirrorEventListenerProps; protected readonly createStateFromContent: CreateStateFromContent; /** * Focus the editor. */ protected readonly focus: (position?: FocusType) => void; /** * Blur the editor. */ protected readonly blur: (position?: PrimitiveSelection) => void; /** * Methods and properties which are made available to all consumers of the * `Framework` class. */ protected get baseOutput(): FrameworkOutput; /** * Every framework implementation must provide it's own custom output. */ abstract get frameworkOutput(): Output; } export { Framework } export { Framework as Framework_alias_1 } export { Framework as Framework_alias_2 } declare interface FrameworkEvents extends Pick { /** * An event listener which is called whenever the editor gains focus. */ focus: (params: RemirrorEventListenerProps, event: Event) => void; /** * An event listener which is called whenever the editor is blurred. */ blur: (params: RemirrorEventListenerProps, event: Event) => void; /** * Called on every state update after the state has been applied to the editor. * * This should be used to track the current editor state and check if commands * are enabled. */ updated: RemirrorEventListener; } export { FrameworkEvents } export { FrameworkEvents as FrameworkEvents_alias_1 } declare interface FrameworkOptions> { /** * The initial editor state */ initialEditorState: EditorState; /** * A method for getting the passed in props. */ getProps: () => Props; /** * When provided the view will immediately be inserted into the dom within * this element. */ element?: Element; } export { FrameworkOptions } export { FrameworkOptions as FrameworkOptions_alias_1 } export { FrameworkOptions as FrameworkOptions_alias_2 } /** * This is the base output that is created by a framework. */ declare interface FrameworkOutput extends Remirror.ManagerStore { /** * The manager which was used to create this editor. */ manager: RemirrorManager; /** * Add event handlers to the remirror editor at runtime. */ addHandler: AddFrameworkHandler; /** * The unique id for the editor instance. */ uid: string; /** * Clears all editor content. * * @param options - includes a `triggerChange` handler which should be * triggered by the update. * * To use this in a controlled editor, you must set `triggerChange` to `true`. */ clearContent: (options?: TriggerChangeProps) => void; /** * Replace all editor content with the new content. * * @remarks * * Allows for the editor content to be overridden by force. * * @param triggerOnChange - whether the `onChange` handler should be triggered * by the update. Defaults to `false`. * * To use this in a controlled editor, you must set `triggerChange` to `true`. */ setContent: (content: RemirrorContentType, options?: TriggerChangeProps) => void; /** * A getter function for the current editor state. It's a wrapper around * `view.state`. */ getState: () => EditorState; /** * A getter function for the previous prosemirror editor state. It can be used * to check what's changed between states. */ getPreviousState: () => EditorState; /** * Get an extension by it's constructor. */ getExtension: (Constructor: ExtensionConstructor) => InstanceType; /** * Assert if an extension is present by it's constructor. */ hasExtension: (Constructor: ExtensionConstructor) => boolean; /** * Focus the editor at the `start` | `end` a specific position or at a valid * range between `{ from, to }`. * * @deprecated This method may be removed in the future and it is advisable to * use `commands.focus()`. */ focus: (position?: FocusType) => void; /** * Blur the editor. * * @deprecated This method may be removed in the future and it is advisable to * use `commands.blur()`. */ blur: (position?: PrimitiveSelection) => void; } export { FrameworkOutput } export { FrameworkOutput as FrameworkOutput_alias_1 } export { FrameworkOutput as FrameworkOutput_alias_2 } /** * The base options for an editor wrapper. This is used within the react and dom * implementations. */ declare interface FrameworkProps { /** * Pass in the extension manager. * * The manager is responsible for handling all Prosemirror related * functionality. */ manager: RemirrorManager; /** * Set the starting value for the editor. * * Without setting the value prop `onChange` remirror renders as an uncontrolled * component. Value changes are passed back out of the editor and there is now * way to set the value via props. As a result this is the only opportunity to * directly control the rendered text. * * @defaultValue `{ type: 'doc', content: [{ type: 'paragraph' }] }` */ initialContent?: RemirrorContentType | [RemirrorContentType, PrimitiveSelection]; /** * Adds attributes directly to the prosemirror element. * * @defaultValue {} */ attributes?: Record | AttributePropFunction; /** * Additional classes which can be passed into the the editor wrapper. These * are placed on root `Prosemirror` element and can be used to effect styling * within the editor. */ classNames?: ClassName[]; /** * Determines whether this editor is editable or not. * * @defaultValue true */ editable?: boolean; /** * When set to true focus will be place on the editor as soon as it first * loads. * * @defaultValue false */ autoFocus?: FocusType; /** * An event listener which is called whenever the editor gains focus. */ onFocus?: (params: RemirrorEventListenerProps, event: Event) => void; /** * An event listener which is called whenever the editor is blurred. */ onBlur?: (params: RemirrorEventListenerProps, event: Event) => void; /** * Called on every change to the Prosemirror state. */ onChange?: RemirrorEventListener; /** * A method called when the editor is dispatching the transaction. * * @remarks * Use this to update the transaction which will be used to update the editor * state. */ onDispatchTransaction?: TransactionTransformer; /** * Sets the accessibility label for the editor instance. * * @defaultValue '' */ label?: string; } export { FrameworkProps } export { FrameworkProps as FrameworkProps_alias_1 } export { FrameworkProps as FrameworkProps_alias_2 } export { freeze } export { FromToProps } declare const GENERAL_OPTIONS: "__ALL__"; export { Get } export { get } export { GetAcceptUndefined } export { getActiveNode } export { GetAttributes } export { GetAttributesProps } export { getChangedNodeRanges } export { getChangedNodes } /** * Get the property changes and the next value from an update. */ export declare function getChangedOptions(props: GetChangedOptionsProps): GetChangeOptionsReturn; export declare interface GetChangedOptionsProps { /** * The previous readonly properties object. */ previousOptions: GetFixedDynamic; /** * The partial update object that was passed through. */ update: GetPartialDynamic; /** * A method to check whether two values are equal. */ equals?: (valueA: unknown, valueB: unknown) => boolean; } export { getChangedRanges } declare interface GetChangeOptionsReturn { /** * The next value of the properties after the update.This also includes values * which have not been changed. */ options: GetFixedDynamic; /** * An object with all the keys showing what's been changed. This should be * used to determine the children extensions which should be updated. * * @remarks * * Using this can prevent unnecessary updates. It's possible for new * properties to be passed that are identical to the previous, by checking if * the object was changed this can be avoided. * * This uses a discriminated union. When the `changed` property is true then * the object has a value as well. * * ```ts * if (changes.myProperty.changed) { * doSomething(changes.myProperty.value); * } * ``` */ changes: Readonly>>; /** * Pick the changed values by their key. An object populated with only the * changed items will be returned to you. */ pickChanged: PickChanged; } export { GetChangeOptionsReturn } export { GetChangeOptionsReturn as GetChangeOptionsReturn_alias_1 } /** * Get the commands from a `RemirrorManager`, `Extension` or `Preset`. */ declare type GetCommands = Type['~C']; export { GetCommands } export { GetCommands as GetCommands_alias_1 } /** * Get the constructor of an instance. */ declare type GetConstructor = Type['constructor']; export { GetConstructor } export { GetConstructor as GetConstructor_alias_1 } export { GetConstructorProps } export { getCursor } export { GetCustomHandler } /** * This uses a hack available via conditional types and `Distributive * conditional types`. When a conditional is used on a union it distributes the * types so that the union can avoid the case where: * * > access is restricted to members that are common to all types in the union * * A better explanation is available here * https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types */ declare type GetDecoratedCommands = Type extends AnyExtension ? ConditionalPick> : never; declare type GetDecoratedHelpers = Type extends object ? RemoveHelpers> : never; declare type GetDecoratedUiCommands = Type extends AnyExtension ? ConditionalPick> : never; export { getDefaultBlockNode } export { getDefaultDocNode } export { getDocRange } export { getDocument } export { GetDynamic } /** * Get the extension type and the extension type of all sub extensions. * * This uses recursive conditional types which are only available in * `typescript@4.1` https://github.com/microsoft/TypeScript/pull/40002 * * @typeParam Extension - The union of extensions. */ declare type GetExtensions = AnyExtension extends Extension ? AnyExtension : Extension extends AnyExtension ? // Now create the union of the provided extension and it's recursively Extension | GetExtensions : AnyExtension; export { GetExtensions } export { GetExtensions as GetExtensions_alias_1 } export { GetExtensions as GetExtensions_alias_2 } export { GetFixed } export { GetFixedCustomHandler } export { GetFixedDynamic } export { GetFixedProps } export { GetFixedStatic } export { GetFlippedStatic } export { getFontSize } export { GetHandler } /** * Get the helpers provided by an from a `RemirrorManager`, `Extension` or * `Preset`. */ declare type GetHelpers = Type['~H']; export { GetHelpers } export { GetHelpers as GetHelpers_alias_1 } export { getInvalidContent } export { getLazyArray } export { GetMappedCustomHandler } export { GetMappedHandler } export { getMarkAttributes } /** * A utility type for retrieving the name of an extension only when it's a mark * extension. * * @typeParam Extension - the extensions being used within the editor * @typeParam Expanded - auto generated from `Extension`. These are the * fully expanded extensions with all sub extensions automatically provided. You * never need to provide this type as it is automatically calculated. */ declare type GetMarkNameUnion> = Expanded extends AnyMarkExtension ? Expanded['name'] : never; export { GetMarkNameUnion } export { GetMarkNameUnion as GetMarkNameUnion_alias_1 } export { GetMarkNameUnion as GetMarkNameUnion_alias_2 } export { GetMarkRange } export { getMarkRange } export { getMarkRanges } export { getMarkType } export { getMatchString } /** * Get the names of all available extensions. */ declare type GetNameUnion = GetExtensions['name']; export { GetNameUnion } export { GetNameUnion as GetNameUnion_alias_1 } export { GetNameUnion as GetNameUnion_alias_2 } /** * A utility type for retrieving the name of an extension only when it's a node * extension. * * @typeParam Extension - the extensions being used within the editor * @typeParam Expanded - auto generated from `Extension`. These are the * fully expanded extensions with all sub extensions automatically provided. You * never need to provide this type as it is automatically calculated. */ declare type GetNodeNameUnion> = Expanded extends AnyNodeExtension ? Expanded['name'] : never; export { GetNodeNameUnion } export { GetNodeNameUnion as GetNodeNameUnion_alias_1 } export { GetNodeNameUnion as GetNodeNameUnion_alias_2 } export { getNodeType } /** * Get the static extension settings. */ declare type GetOptions = Type['~O']; export { GetOptions } export { GetOptions as GetOptions_alias_1 } export { GetPartialDynamic } /** * A utility type for retrieving the name of an extension only when it's a plain * extension. * * @typeParam Extension - the extensions being used within the editor * @typeParam Expanded - auto generated from `Extension`. These are the * fully expanded extensions with all sub extensions automatically provided. You * never need to provide this type as it is automatically calculated. */ declare type GetPlainNameUnion> = Expanded extends AnyPlainExtension ? Expanded['name'] : never; export { GetPlainNameUnion } export { GetPlainNameUnion as GetPlainNameUnion_alias_1 } export { GetPlainNameUnion as GetPlainNameUnion_alias_2 } export { getRemirrorJSON } export { GetRequiredKeys } export { getSelectedGroup } export { getSelectedWord } export { getShortcutSymbols } export { GetStatic } export { GetStaticAndDynamic } export { getStyle } export { getTextContentFromSlice } declare interface GetTextHelperOptions extends Partial { /** * The divider used to separate text blocks. * * @defaultValue '\n\n' */ lineBreakDivider?: string; } export { getTextSelection } /** * Shortcuts used within google docs. */ declare const GOOGLE_DOC_SHORTCUTS: ShortcutMap; export { GOOGLE_DOC_SHORTCUTS } export { GOOGLE_DOC_SHORTCUTS as GOOGLE_DOC_SHORTCUTS_alias_1 } export { GOOGLE_DOC_SHORTCUTS as GOOGLE_DOC_SHORTCUTS_alias_2 } export { Handler } export { HandlerKey } export { HandlerKeyList } declare interface HandlerKeyOptions { /** * When this value is encountered the handler will exit early. * * Set the value to `'__IGNORE__'` to ignore the early return value. */ earlyReturnValue?: LiteralUnion | ((value: unknown) => boolean); /** * Allows combining the values from the handlers together to produce a single * reduced output value. */ reducer?: { /** * Combine the value with the the previous value */ accumulator: (accumulated: ReturnType, latestValue: ReturnType, ...args: Args) => ReturnType; /** * The a function that returns the default value for combined handler * values. This is required for setting up a default value. */ getDefault: (...args: Args) => ReturnType; }; } export { HandlerKeyOptions } export { HandlerKeyOptions as HandlerKeyOptions_alias_1 } /** * This notifies the extension which options are handlers. Handlers typically * represent event handlers that are called in response to something happening. * * An `onChange` option could be a handler. When designing the API I had to * consider that often times, you might want to listen to a handler in several * places. * * A limitation of the static and dynamic options is that there is only one * value per extension. So if there is a `minValue` option and that min value * option is set in the extension then it becomes the value for all consumers of * the extension. Handlers don't have the same expected behaviour. It is * generally expected that you should be able to subscribe to an event in * multiple places. * * In order to make this possible with `remirror` the handlers are automatically * created based on the handler keys you provide. Each handler is an array and * when the handler is called with `this.options.onChange`, each item in the * array is called based on the rules provided. */ declare interface HandlerKeysProps { /** * The list of the option names which are event handlers. */ handlerKeys: HandlerKeyList; /** * Customize how the handler should work. * * This allows you to decide how the handlers will be composed together. * Currently it only support function handlers, but you can tell the extension * to exit early when a certain return value is received. * * ```ts * const handlerOptions = { onChange: { earlyReturnValue: true }}; * ``` * * The above setting means that onChange will exit early as soon as one of the * methods returns true. */ handlerKeyOptions?: MappedHandlerKeyOptions; } export { HandlerShape } export { hasOwnProperty } export { hasTransactionChanged } /** * Determine if there are active file uploads in the given state * * @remarks * This utility is useful to warn users there are still active uploads before * exiting or saving a document. * * @see https://remirror.vercel.app/?path=/story/extensions-file--with-upload-incomplete-warning * * @param state - the editor state */ declare function hasUploadingFile(state: EditorState_2): boolean; export { hasUploadingFile } export { hasUploadingFile as hasUploadingFile_alias_1 } export { hasUploadingFile as hasUploadingFile_alias_2 } export { hasUploadingFile as hasUploadingFile_alias_3 } /** * An annotation which marks decorated helper methods for an extension. */ declare type Helper = Type extends null | undefined ? Type : Type & HelperAnnotation; export { Helper } export { Helper as Helper_alias_1 } export { Helper as Helper_alias_2 } /** * A decorator which can be applied to top level methods on an extension to * identify them as helpers. This can be used as a replacement for the * `createHelpers` method. * * To allow the TypeScript compiler to automatically infer types, please create * your methods with the following type signature. * * ```ts * import { Helper } from '@remirror/core'; * * type Signature = (...args: any[]) => Helper; * ``` * * The following is an example of how this can be used within your extension. * * ```ts * import { helper, Helper } from '@remirror/core'; * * class MyExtension { * get name() { * return 'my'; * } * * @helper() * alwaysTrue(): Helper { * return true; * } * } * ``` * * The above helper can now be used within your editor instance. * * ```tsx * import { useRemirrorContext } from '@remirror/react'; * * const MyEditorButton = () => { * const { helpers } = useRemirrorContext(); * * return helpers.alwaysTrue() ? : null * } * ``` * * @category Method Decorator */ declare function helper(options?: HelperDecoratorOptions): (method: AnyFunction extends HelperAnnotation ? Type : never>, context: ClassMethodDecoratorContext any>) => AnyFunction extends HelperAnnotation ? Type : never>; export { helper } export { helper as helper_alias_1 } export { helper as helper_alias_2 } declare type HelperAnnotation = Flavoring<'HelperAnnotation'>; export { HelperAnnotation } export { HelperAnnotation as HelperAnnotation_alias_1 } export { HelperAnnotation as HelperAnnotation_alias_2 } declare interface HelperDecoratorOptions { } export { HelperDecoratorOptions } export { HelperDecoratorOptions as HelperDecoratorOptions_alias_1 } export { HelperDecoratorOptions as HelperDecoratorOptions_alias_2 } /** * A function with a return signature annotated as a helper. */ declare type HelperFunction = AnyFunction; export { HelperFunction } export { HelperFunction as HelperFunction_alias_1 } export { HelperFunction as HelperFunction_alias_2 } /** * Utility type for pulling all the action names from a list */ declare type HelperNames = StringKey>; export { HelperNames } export { HelperNames as HelperNames_alias_1 } export { HelperNames as HelperNames_alias_2 } /** * Helpers are custom methods that can provide extra functionality to the * editor. * * @remarks * * They can be used for pulling information from the editor or performing custom * async commands. * * Also provides the default helpers used within the extension. * * @category Builtin Extension */ declare class HelpersExtension extends PlainExtension { get name(): "helpers"; /** * Add the `html` and `text` string handlers to the editor. */ onCreate(): void; /** * Check whether the selection is empty. */ isSelectionEmpty(state?: EditorState): Helper; isViewEditable(state?: EditorState): Helper; /** * Get the full JSON output for the ProseMirror editor state object. */ getStateJSON(state?: EditorState): Helper; /** * Get the JSON output for the main ProseMirror `doc` node. * * This can be used to persist data between sessions and can be passed as * content to the `initialContent` prop. */ getJSON(state?: EditorState): Helper; /** * Insert a html string as a ProseMirror Node. * * @category Builtin Command */ insertHtml(html: string, options?: InsertNodeOptions): CommandFunction; /** * A method to get all the content in the editor as text. Depending on the * content in your editor, it is not guaranteed to preserve it 100%, so it's * best to test that it meets your needs before consuming. */ getText({ lineBreakDivider, state, }?: GetTextHelperOptions): Helper; getTextBetween(from: number, to: number, doc?: ProsemirrorNode): Helper; /** * Get the html from the current state, or provide a custom state. */ getHTML(state?: EditorState): Helper; /** * Wrap the content in a pre tag to preserve whitespace and see what the * editor does with it. */ private textToProsemirrorNode; } export { HelpersExtension } export { HelpersExtension as HelpersExtension_alias_1 } export { HelpersExtension as HelpersExtension_alias_2 } /** * Utility type which receives an extension and provides the type of helpers it * makes available. * * @typeParam Extension - the extensions being used within the editor * @typeParam Expanded - auto generated from `Extension`. These are the * fully expanded extensions with all sub extensions automatically provided. You * never need to provide this type as it is automatically calculated. */ declare type HelpersFromExtensions> = UnionToIntersection | GetDecoratedHelpers>>; export { HelpersFromExtensions } export { HelpersFromExtensions as HelpersFromExtensions_alias_1 } export { HelpersFromExtensions as HelpersFromExtensions_alias_2 } export { htmlToProsemirrorNode } export { I18nFormatter } /** * The extra identifiers that can be used. * * - `nodes` - match all nodes * - `marks` - match all marks * - `all` - match everything in the editor * - `string[]` - match the selected node and mark names * - [[`IdentifiersObject`]] - match by `ExtensionTag` and type name. */ declare type Identifiers = 'nodes' | 'marks' | 'all' | readonly string[] | IdentifiersObject; export { Identifiers } export { Identifiers as Identifiers_alias_1 } export { Identifiers as Identifiers_alias_2 } /** * The interface for adding extra attributes to multiple node and mark * extensions. */ declare interface IdentifierSchemaAttributes { /** * The nodes or marks to add extra attributes to. * * This can either be an array of the strings or the following specific * identifiers: * * - 'nodes' for all nodes * - 'marks' for all marks * - 'all' for all extensions which touch the schema. */ identifiers: Identifiers; /** * The attributes to be added. */ attributes: SchemaAttributes; } export { IdentifierSchemaAttributes } export { IdentifierSchemaAttributes as IdentifierSchemaAttributes_alias_1 } export { IdentifierSchemaAttributes as IdentifierSchemaAttributes_alias_2 } /** * With tags, you can select a specific sub selection of marks and nodes. This * will be the basis for adding advanced formatting to remirror. * * ```ts * import { ExtensionTag } from 'remirror'; * import { createCoreManager, CorePreset } from 'remirror/extensions'; * import { WysiwygPreset } from 'remirror/extensions'; * * const manager = createCoreManager(() => [new WysiwygPreset(), new CorePreset()], { * extraAttributes: [ * { * identifiers: { * tags: [ExtensionTag.NodeBlock], * type: 'node', * }, * attributes: { role: 'presentation' }, * }, * ], * }); * ``` * * Each item in the tags array should be read as an `OR` so the following would * match `Tag1` OR `Tag2` OR `Tag3`. * * ```json * { tags: ["Tag1", "Tag2", "Tag3"] } * ``` * * The `type` property (`mark | node`) is exclusive and limits the type of * extension names that will be matched. When `mark` is set it only matches with * marks. */ declare interface IdentifiersObject { /** * Determines how the array of tags are combined: * * - `all` - the extension only matches when all tags are present. * - `any` - the extension will match if it includes any of the specified * tags. * * This only affects the `tags` property. * * The saddest part about this property is that, as a UK resident, I've * succumbed to using the Americanized spelling instead of the Oxford * Dictionary defined spelling of `behaviour` 😢 * * @defaultValue 'any' */ behavior?: 'all' | 'any'; /** * Will find relevant names based on the defined `behaviour`. */ tags?: ExtensionTagType[]; /** * Additional names to include. These will still be added even if the * extension name matches with `excludeTags` member. */ names?: string[]; /** * Whether to restrict by whether this is a [[`ProsemirrorNode`]] or a * [[`Mark`]]. Leave blank to accept all types. */ type?: 'node' | 'mark'; /** * Exclude these names from being matched. */ excludeNames?: string[]; /** * Exclude these tags from being matched. Will always exclude if any of the * tags */ excludeTags?: string[]; } export { IdentifiersObject } export { IdentifiersObject as IdentifiersObject_alias_1 } export { IdentifiersObject as IdentifiersObject_alias_2 } export { IfEmpty } export { IfHasRequiredProperties } export { IfMatches } export { IfNoRequiredProperties } declare const IGNORE = "__IGNORE__"; export { includes } export { IndexUnionFromTuple } declare interface InlinePlaceholder extends BasePlaceholder, Partial, DataProps { type: 'inline'; } export { InputRule } /** * This extension allows others extension to add the `createInputRules` method * for automatically transforming text when a certain regex pattern is typed. * * @remarks * * This is an example of adding custom functionality to an extension via the * `ExtensionParameterMethods`. * * @category Builtin Extension */ declare class InputRulesExtension extends PlainExtension { get name(): "inputRules"; /** * Add the extension store method for rebuilding all input rules. */ onCreate(): void; /** * Add the `inputRules` plugin to the editor. */ createExternalPlugins(): ProsemirrorPlugin[]; private generateInputRulesPlugin; /** * The method for rebuilding all the input rules. * * 1. Rebuild inputRules. * 2. Replace the old input rules plugin. * 3. Update the plugins used in the state (triggers an editor update). */ private rebuildInputRules; } export { InputRulesExtension } export { InputRulesExtension as InputRulesExtension_alias_1 } export { InputRulesExtension as InputRulesExtension_alias_2 } declare interface InputRulesOptions { /** * Handlers which can be registered to check whether an input rule should be * active at this time. * * The handlers are given a parameter with the current `state`, the `fullMatch` * and the `captureGroup` and can determine whether the input rule should * still be run. * * Return `true` to prevent any active input rules from being triggered. */ shouldSkipInputRule?: Handler; } export { InputRulesOptions } export { InputRulesOptions as InputRulesOptions_alias_1 } export { InputRulesOptions as InputRulesOptions_alias_2 } declare interface InsertNodeOptions { attrs?: ProsemirrorAttributes; marks?: Array; /** * The content to insert. */ content?: Fragment | ProsemirrorNode | ProsemirrorNode[] | string; /** * @deprecated use selection property instead. */ range?: FromToProps; /** * Set the selection where the command should occur. */ selection?: PrimitiveSelection; /** * Set this to true to replace an empty parent block with this content (if the * content is a block node). */ replaceEmptyParentBlock?: boolean; } export { InsertNodeOptions } export { InsertNodeOptions as InsertNodeOptions_alias_1 } export { InsertNodeOptions as InsertNodeOptions_alias_2 } /** * Insert text into the dom at the current location by default. If a promise is * provided then the text will be inserted at the tracked position when the * promise is resolved. */ declare function insertText(text: string, options?: InsertTextOptions): CommandFunction; export { insertText } export { insertText as insertText_alias_1 } export declare interface InsertTextOptions extends Partial { /** * Marks can be added to the inserted text. */ marks?: Record; } export { InvalidContentBlock } export { InvalidContentHandler } export { InvalidContentHandlerProps } export { invariant } export { isAllSelection } export { isAndroidOS } export { isArray } export { isBoolean } export { isChrome } export { isClass } export { isDate } export { isDefaultBlockNode } export { isDefaultDocNode } /** * Returns `true` when the provided value is a delayed value. */ declare function isDelayedValue(value: unknown): value is DelayedValue; export { isDelayedValue } export { isDelayedValue as isDelayedValue_alias_1 } export { isDirectInstanceOf } export { isDocNode } export { isDocNodeEmpty } export { isDomNode } export { isEditorSchema } export { isEditorState } export { isElementDomNode } export { isEmptyArray } export { isEmptyBlockNode } export { isEmptyObject } export { isEndOfTextBlock } export { isEqual } export { isError } /** * Determines if the passed value is an extension. * * @param value - the value to test */ declare function isExtension(value: unknown): value is Type; export { isExtension } export { isExtension as isExtension_alias_1 } export { isExtension as isExtension_alias_2 } /** * Determines if the passed value is an extension constructor. * * @param value - the value to test */ declare function isExtensionConstructor(value: unknown): value is Type; export { isExtensionConstructor } export { isExtensionConstructor as isExtensionConstructor_alias_1 } export { isExtensionConstructor as isExtensionConstructor_alias_2 } /** * Check if the provided string is an extension tag. */ declare function isExtensionTag(value: string): value is ExtensionTagType; export { isExtensionTag } export { isExtensionTag as isExtensionTag_alias_1 } export { isExtensionTag as isExtensionTag_alias_2 } export { isFunction } export { isIdentifierOfType } export { isInstanceOf } export { isInteger } export { isJSONPrimitive } export { isMap } export { isMarkActive } /** * Determines if the passed in extension is a mark extension. Useful as a type * guard where a particular type of extension is needed. * * @param value - the extension to check */ declare function isMarkExtension(value: unknown): value is Type; export { isMarkExtension } export { isMarkExtension as isMarkExtension_alias_1 } export { isMarkExtension as isMarkExtension_alias_2 } export { isMarkType } export declare interface IsNameUniqueProps { /** * The name to check against */ name: string; /** * The set to check within */ set: Set; /** * The error code to use * * @defaultValue 'extension' */ code: ErrorConstant.DUPLICATE_HELPER_NAMES | ErrorConstant.DUPLICATE_COMMAND_NAMES; } export { isNativePromise } export { isNodeActive } /** * Determines if the passed in extension is a node extension. Useful as a type * guard where a particular type of extension is needed. * * @param value - the extension to check */ declare function isNodeExtension(value: unknown): value is Type; export { isNodeExtension } export { isNodeExtension as isNodeExtension_alias_1 } export { isNodeExtension as isNodeExtension_alias_2 } export { isNodeOfType } export { isNodeSelection } export { isNodeType } export { isNonEmptyArray } export { isNull } export { isNullOrUndefined } export { isNumber } export { isObject } /** * Checks whether the provided value is a plain extension. * * @param value - the extension to check */ declare function isPlainExtension(value: unknown): value is Type; export { isPlainExtension } export { isPlainExtension as isPlainExtension_alias_1 } export { isPlainExtension as isPlainExtension_alias_2 } export { isPlainObject } export { isPrimitive } export { isPromise } export { isProsemirrorFragment } export { isProsemirrorMark } export { isProsemirrorNode } export { isRegExp } export { isRemirrorJSON } /** * Checks to see whether the provided value is a `RemirrorManager` instance. * * An optional parameter `mustIncludeList` is available if you want to check * that the manager includes all the listed extensions. * * @param value - the value to check * @param mustIncludeList - an array of presets and extension the manager must * include to pass the test. The identifier can either be the Extension / Preset * name e.g. `bold`, or the Extension / Preset constructor `BoldExtension` */ declare function isRemirrorManager(value: unknown, mustIncludeList?: Array): value is RemirrorManager; export { isRemirrorManager } export { isRemirrorManager as isRemirrorManager_alias_1 } export { isRemirrorManager as isRemirrorManager_alias_2 } export { isRemirrorType } export { isResolvedPos } export { isSafari } export { isSafeInteger } export { isSelection } export { isSelectionEmpty } export { isSet } export { isStartOfDoc } export { isStartOfTextBlock } export { isString } export { isSymbol } export { isTextDomNode } export { isTextSelection } export { isTransaction } export { isUndefined } export { IterableElement } export { joinStyles } export { JsonArray } export { JsonObject } export { JsonPrimitive } export { JsonValue } export { KebabCase } export { kebabCase } export { KeepPartialProperties } /** * A decorator which can be applied to an extension method to * identify as a key binding method. This can be used as a replacement for * the `createKeymap` method depending on your preference. * * If you prefer not to use decorators, then you can continue using * `createKeymap`. * * @category Method Decorator */ declare function keyBinding(options: KeybindingDecoratorOptions>>): (method: KeyBindingCommandFunction, context: ClassMethodDecoratorContext) => KeyBindingCommandFunction; export { keyBinding } export { keyBinding as keyBinding_alias_1 } export { keyBinding as keyBinding_alias_2 } export { KeyBindingCommandFunction } declare interface KeybindingDecoratorOptions { /** * The keypress sequence to intercept. * * - `Enter` * - `Shift-Enter` */ shortcut: KeyboardShortcut; /** * This can be used to set a keybinding as inactive based on the provided * options. */ isActive?: (options: Options, store: Remirror.ExtensionStore) => boolean; /** * The priority for this keybinding. */ priority?: ExtensionPriority | ((options: Options, store: Remirror.ExtensionStore) => ExtensionPriority); /** * The name of the command that the keybinding should be attached to. */ command?: Remirror.AllUiCommandNames; } export { KeybindingDecoratorOptions } export { KeybindingDecoratorOptions as KeybindingDecoratorOptions_alias_1 } export { KeybindingDecoratorOptions as KeybindingDecoratorOptions_alias_2 } declare interface KeyBindingMetadata { type: 'keyBinding'; /** * The name of the extension used. */ extension: string; /** * The shortcut used to invoke this keybinding. */ shortcut: string; } export { KeyBindingNames } export { KeyBindingProps } export { KeyBindings } /** * KeyBindings as a tuple with priority and the keymap. */ declare type KeyBindingsTuple = [priority: ExtensionPriority, bindings: KeyBindings]; export { KeyBindingsTuple } export { KeyBindingsTuple as KeyBindingsTuple_alias_1 } export { KeyBindingsTuple as KeyBindingsTuple_alias_2 } declare type KeyboardShortcut = KeyboardShortcutValue | KeyboardShortcutFunction; export { KeyboardShortcut } export { KeyboardShortcut as KeyboardShortcut_alias_1 } export { KeyboardShortcut as KeyboardShortcut_alias_2 } declare type KeyboardShortcutFunction = (options: Options, store: Remirror.ExtensionStore) => KeyboardShortcut; export { KeyboardShortcutFunction } export { KeyboardShortcutFunction as KeyboardShortcutFunction_alias_1 } export { KeyboardShortcutFunction as KeyboardShortcutFunction_alias_2 } declare type KeyboardShortcuts = keyof typeof keyboardShortcuts | ShortcutMap; export { KeyboardShortcuts } export { KeyboardShortcuts as KeyboardShortcuts_alias_1 } export { KeyboardShortcuts as KeyboardShortcuts_alias_2 } declare const keyboardShortcuts: { default: ShortcutMap; googleDoc: ShortcutMap; }; export { keyboardShortcuts } export { keyboardShortcuts as keyboardShortcuts_alias_1 } export { keyboardShortcuts as keyboardShortcuts_alias_2 } declare type KeyboardShortcutValue = Listable>; export { KeyboardShortcutValue } export { KeyboardShortcutValue as KeyboardShortcutValue_alias_1 } export { KeyboardShortcutValue as KeyboardShortcutValue_alias_2 } /** * This extension allows others extension to use the `createKeymaps` method. * * @remarks * * Keymaps are the way of controlling how the editor responds to a keypress and * different key combinations. * * Without this extension most of the shortcuts and behaviors we have come to * expect from text editors would not be provided. * * @category Builtin Extension */ declare class KeymapExtension extends PlainExtension { get name(): "keymap"; /** * The custom keybindings added by the handlers. In react these can be added * via `hooks`. */ private extraKeyBindings; /** * Track the backward exits from a mark to allow double tapping the left arrow * to move to the previous block node. */ private readonly backwardMarkExitTracker; /** * The underlying keydown handler. */ private keydownHandler; /** * Get the shortcut map. */ private get shortcutMap(); /** * This adds the `createKeymap` method functionality to all extensions. */ onCreate(): void; /** Add the created keymap to the available plugins. */ createExternalPlugins(): ProsemirrorPlugin[]; private setupKeydownHandler; /** * Updates the stored keymap bindings on this extension. */ private generateKeymapBindings; /** * Handle exiting the mark forwards. */ arrowRightShortcut(props: KeyBindingProps): boolean; /** * Handle the arrow left key to exit the mark. */ arrowLeftShortcut(props: KeyBindingProps): boolean; /** * Handle exiting the mark forwards. */ backspace(props: KeyBindingProps): boolean; /** * Create the base keymap and give it a low priority so that all other keymaps * override it. */ createKeymap(): PrioritizedKeyBindings; /** * Get the real shortcut name from the named shortcut. */ getNamedShortcut(shortcut: string, options?: Shape): Helper; /** * @internalremarks * * Think about the case where bindings are disposed of and then added in a * different position in the `extraKeyBindings` array. This is especially * pertinent when using hooks. */ protected onAddCustomHandler: AddCustomHandler; /** * Handle changes in the dynamic properties. */ protected onSetOptions(props: OnSetOptionsProps): void; private sortKeymaps; /** * The method for rebuilding all the extension keymaps. * * 1. Rebuild keymaps. * 2. Replace `this.keydownHandler` with the new keydown handler. */ private readonly rebuildKeymap; /** * Exits the mark forwards when at the end of a block node. */ private exitMarkForwards; private exitNodeBackwards; /** * Exit a mark when at the beginning of a block node. */ private exitMarkBackwards; } export { KeymapExtension } export { KeymapExtension as KeymapExtension_alias_1 } export { KeymapExtension as KeymapExtension_alias_2 } declare interface KeymapOptions { /** * The shortcuts to use for named keybindings in the editor. * * @defaultValue 'default' */ shortcuts?: KeyboardShortcuts; /** * Determines whether a backspace after an input rule has been applied should * reverse the effect of the input rule. * * @defaultValue true */ undoInputRuleOnBackspace?: boolean; /** * Determines whether the escape key selects the current node. * * @defaultValue false */ selectParentNodeOnEscape?: boolean; /** * When true will exclude the default prosemirror keymap. * * @remarks * * You might want to set this to true if you want to fully customise the * keyboard mappings for your editor. Otherwise it is advisable to leave it * unchanged. * * @defaultValue false */ excludeBaseKeymap?: boolean; /** * Whether to support exiting marks when the left and right array keys are * pressed. * * Can be set to * * - `true` - enables exits from both the entrance and the end of the mark */ exitMarksOnArrowPress?: boolean; /** * The implementation for the extra keybindings added to the settings. * * @remarks * * This allows for you to add extra key mappings which will be checked before * the default keymaps, if they return false then the default keymaps are * still checked. * * No key mappings are removed in this process. * * ```ts * const extension = BaseKeymapExtension.create({ keymap: { * Enter({ state, dispatch }) { * //... Logic * return true; * }, * }}); * ``` */ keymap?: CustomHandler; } export { KeymapOptions } export { KeymapOptions as KeymapOptions_alias_1 } export { KeymapOptions as KeymapOptions_alias_2 } export { keys } export { last } export { LEAF_NODE_REPLACING_CHARACTER } /** * A legacy decorator (pre Stage 3) which can be applied to top level methods * on an extension to identify them as commands. This can be used as a * replacement for the `createCommands` method. * * If you prefer not to use decorators, then you can continue using * `createCommands`. Internally the decorators are being used as they are better * for documentation purposes. * * For automated type inference methods that use this decorator must implement * the following type signature. * * ```ts * import { CommandFunction } from '@remirror/core'; * * type Signature = (...args: any[]) => CommandFunction; * ``` * * The following is an example of how this can be used within your extension. * * ```ts * import { legacyCommand, CommandFunction } from '@remirror/core'; * * class MyExtension { * get name() { * return 'my'; * } * * @legacyCommand() * myCommand(text: string): CommandFunction { * return ({ tr, dispatch }) => { * dispatch?.(tr.insertText('my command ' + text)); * return true; * } * } * } * ``` * * The above command can now be used within your editor instance. * * ```tsx * import { useRemirrorContext } from '@remirror/react'; * * const MyEditorButton = () => { * const { commands } = useRemirrorContext(); * * return * } * ``` * * @category Method Decorator * @deprecated legacy - please use the ES2023 decorator `@command` */ declare function legacyCommand(options?: ChainableCommandDecoratorOptions>>): ExtensionDecorator; declare function legacyCommand(options: NonChainableCommandDecoratorOptions>>): ExtensionDecorator; export { legacyCommand } export { legacyCommand as legacyCommand_alias_1 } export { legacyCommand as legacyCommand_alias_2 } /** * A legacy decorator (pre Stage 3) which can be applied to top level methods * on an extension to identify them as helpers. This can be used as a * replacement for the `createHelpers` method. * * To allow the TypeScript compiler to automatically infer types, please create * your methods with the following type signature. * * ```ts * import { Helper } from '@remirror/core'; * * type Signature = (...args: any[]) => Helper; * ``` * * The following is an example of how this can be used within your extension. * * ```ts * import { legacyHelper, Helper } from '@remirror/core'; * * class MyExtension { * get name() { * return 'my'; * } * * @legacyHelper() * alwaysTrue(): Helper { * return true; * } * } * ``` * * The above helper can now be used within your editor instance. * * ```tsx * import { useRemirrorContext } from '@remirror/react'; * * const MyEditorButton = () => { * const { helpers } = useRemirrorContext(); * * return helpers.alwaysTrue() ? : null * } * ``` * * @category Method Decorator * @deprecated legacy - please use the ES2023 decorator `@helper` */ declare function legacyHelper(options?: HelperDecoratorOptions): (target: Extension, propertyKey: string, _descriptor: TypedPropertyDescriptor extends HelperAnnotation ? Type : never>>) => void; export { legacyHelper } export { legacyHelper as legacyHelper_alias_1 } export { legacyHelper as legacyHelper_alias_2 } /** * A legacy decorator (pre Stage 3) which can be applied to an extension * method to identify as a key binding method. This can be used as a * replacement for the `createKeymap` method depending on your * preference. * * If you prefer not to use decorators, then you can continue using * `createKeymap`. * * @category Method Decorator * @deprecated legacy - please use the ES2023 decorator `@keyBinding` */ declare function legacyKeyBinding(options: KeybindingDecoratorOptions>>): (target: Extension, propertyKey: string, _descriptor: TypedPropertyDescriptor) => void; export { legacyKeyBinding } export { legacyKeyBinding as legacyKeyBinding_alias_1 } export { legacyKeyBinding as legacyKeyBinding_alias_2 } export { lift } export { Listable } declare interface ListenerProps extends Partial, Partial { /** * When the state updates are not controlled and it was a transaction that * caused the state to be updated this value captures all the transaction * updates caused by prosemirror plugins hook state methods like * `filterTransactions` and `appendTransactions`. * * This is for advanced users only. */ transactions?: readonly Transaction[]; } export { ListenerProps } export { ListenerProps as ListenerProps_alias_1 } export { ListenerProps as ListenerProps_alias_2 } export { Literal } export { LiteralUnion } export { MakeNullable } export { MakeOptional } export { MakeReadonly } export { MakeRequired } export { MakeUndefined } declare interface ManagerEvents { /** * Called when the state is updated. */ stateUpdate: (props: StateUpdateLifecycleProps) => void; /** * Called whenever the manager is cloned with the newly created manager * instance. * * This is mainly used for testing so that the RemirrorTester can always * reference the latest manager. */ clone: (manager: AnyRemirrorManager) => void; /** * Called whenever the manager is recreated with the newly created manager * instance. * * This is mainly used for testing so that the RemirrorTester can always * reference the latest manager. */ recreate: (manager: AnyRemirrorManager) => void; /** * An event listener which is called whenever the manager is destroyed. */ destroy: () => void; } export { ManagerEvents } export { ManagerEvents as ManagerEvents_alias_1 } export { ManagerEvents as ManagerEvents_alias_2 } export declare interface ManagerLifecycleHandlers { /** * Contains the methods run when the manager is first created. */ create: Array<() => Dispose | void>; /** * Holds the methods to run once the Editor has received the view from the * attached. */ view: Array<(view: EditorView) => Dispose | void>; /** * The update method is called every time the state updates. This allows * extensions to listen to updates. */ update: Array<(props: StateUpdateLifecycleProps) => void>; /** * Called when the manager is being destroyed. */ destroy: Array<() => void>; } export { ManagerPhase } declare type ManagerStoreKeys = keyof Remirror.ManagerStore; export { ManagerStoreKeys } export { ManagerStoreKeys as ManagerStoreKeys_alias_1 } export { ManagerStoreKeys as ManagerStoreKeys_alias_2 } /** * A utility type which maps the passed in extension helpers to a method called * with `manager.data.helpers.helperName()`. */ declare type MapHelpers> = { [Helper in keyof RawHelpers]: RawHelpers[Helper]; }; export { MapHelpers } export { MapHelpers as MapHelpers_alias_1 } export { MapHelpers as MapHelpers_alias_2 } declare type MappedHandlerKeyOptions = { [Key in keyof GetHandler]?: HandlerKeyOptions[Key]>, Parameters[Key]>>; } & { __ALL__?: HandlerKeyOptions; }; export { Mapping } /** * A utility type which maps the chained commands. */ declare type MapToChainedCommand> = { [Command in keyof RawCommands]: ReturnType extends NonChainableCommandFunction ? void : (...args: Parameters) => any; }; export { MapToChainedCommand } export { MapToChainedCommand as MapToChainedCommand_alias_1 } export { MapToChainedCommand as MapToChainedCommand_alias_2 } /** * A utility type which maps the passed in extension command in an action that * is store in the `manager.store.actions.commandName()`. */ declare type MapToUnchainedCommand> = { [Command in keyof RawCommands]: CommandShape>; }; export { MapToUnchainedCommand } export { MapToUnchainedCommand as MapToUnchainedCommand_alias_1 } export { MapToUnchainedCommand as MapToUnchainedCommand_alias_2 } export { Mark } export { markEqualsType } /** * A mark extension is based on the `Mark` concept from from within prosemirror * {@link https://prosemirror.net/docs/guide/#schema.marks} * * @remarks * * Marks are used to add extra styling or other information to inline content. * Mark types are objects much like node types, used to tag mark objects and * provide additional information about them. */ declare abstract class MarkExtension extends Extension { /** @internal */ static get [__INTERNAL_REMIRROR_IDENTIFIER_KEY__](): RemirrorIdentifier.MarkExtensionConstructor; /** * Whether to disable extra attributes for this extension. */ static readonly disableExtraAttributes: boolean; /** @internal */ get [__INTERNAL_REMIRROR_IDENTIFIER_KEY__](): RemirrorIdentifier.MarkExtension; /** * Provides access to the mark type from the schema. * * @remarks * * The type is available as soon as the schema is created by the * `SchemaExtension` which has the priority `Highest`. It should be safe to * access in any of the lifecycle methods. */ get type(): MarkType; constructor(...args: ExtensionConstructorProps); /** * Provide a method for creating the schema. This is required in order to * create a `MarkExtension`. * * @remarks * * The main difference between the return value of this method and Prosemirror * `MarkSpec` is that that the `toDOM` method doesn't allow dom manipulation. * You can only return an array or string. * * For more advanced requirements, it may be possible to create a `nodeView` * to manage the dom interactions. */ abstract createMarkSpec(extra: ApplySchemaAttributes, override: MarkSpecOverride): MarkExtensionSpec; } declare interface MarkExtension extends Extension, Remirror.MarkExtension { } export { MarkExtension } export { MarkExtension as MarkExtension_alias_1 } export { MarkExtension as MarkExtension_alias_2 } export { MarkExtensionSpec } export { markInputRule } export { MarkSpecOverride } export { MarkType } export { MarkTypeProps } export { MarkTypesProps } export { MarkWithAttributes } export { MarkWithAttributesProps } export { Merge } export { mergeDOMRects } export { MergeExclusive } export { mergeKeyBindings } export { mergeProsemirrorKeyBindings } declare type Metadata = CommandMetadata | KeyBindingMetadata; export { Metadata } export { Metadata as Metadata_alias_1 } export { Metadata as Metadata_alias_2 } /** * Support meta data for commands and key bindings. * * Metadata is dded to all commands and keybindings and that information is * provided to the `onChange` handle whenever the state is updated. * * @internalremarks * * TODO capture keybindings as well. This will be more difficult since * keybindings can dynamically be added to the editor. */ declare class MetaExtension extends PlainExtension { get name(): "meta"; onCreate(): void; /** * This is here to provide a */ createPlugin(): CreateExtensionPlugin; /** * Intercept command names and attributes. */ private captureCommands; /** * Intercept command name and attributes. */ private captureKeybindings; /** * Get the command metadata. */ private getCommandMeta; private setCommandMeta; } export { MetaExtension } export { MetaExtension as MetaExtension_alias_1 } export { MetaExtension as MetaExtension_alias_2 } declare interface MetaOptions { /** * Set to true to capture meta data on commands and keybindings. This creates * a wrapper around every command and keybinding and as a result it may lead * to a performance penalty. */ capture?: Static; } export { MetaOptions } export { MetaOptions as MetaOptions_alias_1 } export { MetaOptions as MetaOptions_alias_2 } export { MinArray } /** * Mutate the default extension options. * * @remarks * * This is a dangerous method since it allows you to mutate the received object. * Don't use it unless you absolutely have to. * * A potential use case is for adding a new default option to all extensions. It * shows an example of how to accomplish this in a typesafe way. * * ```ts * import { mutateDefaultExtensionOptions } from 'remirror'; * * mutateDefaultExtensionOptions((settings) => { * // Set the default value of all extensions to have a property `customSetting` with value `false`. * settings.customSetting = false; * }) * * declare global { * namespace Remirror { * interface BaseExtensionOptions { * customSetting?: boolean; * } * } * } *``` * * The mutation must happen before any extension have been instantiated. */ declare function mutateDefaultExtensionOptions(mutatorMethod: (defaultOptions: BaseExtensionOptions) => void): void; export { mutateDefaultExtensionOptions } export { mutateDefaultExtensionOptions as mutateDefaultExtensionOptions_alias_1 } export { mutateDefaultExtensionOptions as mutateDefaultExtensionOptions_alias_2 } export { mutateTag } export { NamedShortcut } export { NamedStringHandlers } declare interface NewChainedCommandProps = ChainedIntersection> { /** * Returns a new chain, with an empty command set. * * ```ts * chain.toggleBold(); * chain.new().toggleItalic().run(); // Only toggleItalic would be run * ``` */ new: (tr?: Transaction) => ChainedFromExtensions; } export { NewChainedCommandProps } export { NewChainedCommandProps as NewChainedCommandProps_alias_1 } export { NewChainedCommandProps as NewChainedCommandProps_alias_2 } /** * Defines the abstract class for extensions which can place nodes into the * prosemirror state. * * @remarks * * For more information see {@link https://prosemirror.net/docs/ref/#model.Node} */ declare abstract class NodeExtension extends Extension { static get [__INTERNAL_REMIRROR_IDENTIFIER_KEY__](): RemirrorIdentifier.NodeExtensionConstructor; /** * Whether to disable extra attributes for this extension. */ static readonly disableExtraAttributes: boolean; /** @internal */ get [__INTERNAL_REMIRROR_IDENTIFIER_KEY__](): RemirrorIdentifier.NodeExtension; /** * Provides access to the node type from the schema. */ get type(): NodeType; constructor(...args: ExtensionConstructorProps); /** * Provide a method for creating the schema. This is required in order to * create a `NodeExtension`. * * @remarks * * A node schema defines the behavior of the content within the editor. This * is very tied to the prosemirror implementation and the best place to learn * more about it is in the * {@link https://prosemirror.net/docs/guide/#schema docs}. * * @params hole - a method that is meant to indicate where extra attributes * should be placed (if they exist). * * The `hole` is a function that augments the passed object adding a special * `secret` key which is used to insert the extra attributes setter. * * ```ts * import { NodeExtension, SpecHole } from 'remirror'; * * class AwesomeExtension extends NodeExtension { * get name() { return 'awesome' as const'; } * * createNodeSpec() { * return { * toDOM: (node) => { * return ['p', hole(), 0] * } * } * } * } * ``` * * The above example will have the `hole()` method call replaced with the * extra attributes. */ abstract createNodeSpec(extra: ApplySchemaAttributes, override: NodeSpecOverride): NodeExtensionSpec; } declare interface NodeExtension extends Extension, Remirror.NodeExtension { } export { NodeExtension } export { NodeExtension as NodeExtension_alias_1 } export { NodeExtension as NodeExtension_alias_2 } export { NodeExtensionSpec } export { nodeInputRule } export { NodeMarkOptions } declare interface NodePlaceholder extends BasePlaceholder, DataProps { /** * Set this as a node tracker. */ type: 'node'; /** * If provided the The `pos` must be directly before the node in order to be * valid. If not provided it will select the parent node of the current * selection. */ pos: number | null; } export { NodeSpecOverride } export { NodeStringHandlerOptions } export { NodeType } export { NodeTypeProps } export { NodeTypesProps } export { NodeView } export { NodeViewMethod } /** * This extension allows others extension to add the `createNodeView` method * for creating nodeViews which alter how the dom is rendered for the node. * * @remarks * * This is an example of adding custom functionality to an extension via the * `ExtensionParameterMethods`. * * @category Builtin Extension */ declare class NodeViewsExtension extends PlainExtension { get name(): "nodeViews"; createPlugin(): CreateExtensionPlugin; } export { NodeViewsExtension } export { NodeViewsExtension as NodeViewsExtension_alias_1 } export { NodeViewsExtension as NodeViewsExtension_alias_2 } export { NodeWithAttributes } export { NodeWithAttributesProps } export { NodeWithPosition } export { NON_BREAKING_SPACE_CHAR } export { nonChainable } declare interface NonChainableCommandDecoratorOptions extends Remirror.CommandDecoratorOptions { /** * Set this to `true` to disable chaining of this command. This means it will * no longer be available when running ` * * @defaultValue false */ disableChaining: true; } export { NonChainableCommandFunction } export { NonNullableShape } export { noop } export { NULL_CHARACTER } export { Nullable } export { object } export { ObjectMark } export { ObservableLike } export { omit } export { omitExtraAttributes } export { omitUndefined } declare interface OnSetOptionsProps extends Pick, 'changes' | 'pickChanged'>, UpdateReasonProps { /** * The initial options for the extension. Falls back to default options. */ initialOptions: RemoveAnnotations>; /** * The next value of the properties after the update.This also includes values * which have not been changed. */ options: RemoveAnnotations>; } export { OnSetOptionsProps } export { OnSetOptionsProps as OnSetOptionsProps_alias_1 } export { Opaque } export { OptionalMarkProps } export { OptionalProsemirrorNodeProps } /** * Get the options from any constructor. Can be used for both presets and * extensions. */ declare type OptionsOfConstructor = GetOptions>; export { OptionsOfConstructor } export { OptionsOfConstructor as OptionsOfConstructor_alias_1 } export { PackageJson } export { ParsedDomSize } export { parseSizeUnit } export { PartialDeep } export { PartialWithRequiredKeys } export { PascalCase } export { pascalCase } /** * This extension allows others extension to add the `createPasteRules` method * for automatically transforming pasted text which matches a certain regex * pattern in the dom. * * @category Builtin Extension */ declare class PasteRulesExtension extends PlainExtension { get name(): "pasteRules"; createExternalPlugins(): ProsemirrorPlugin[]; private generatePasteRulesPlugin; } export { PasteRulesExtension } export { PasteRulesExtension as PasteRulesExtension_alias_1 } export { PasteRulesExtension as PasteRulesExtension_alias_2 } declare interface PasteRulesOptions { } export { PasteRulesOptions } export { PasteRulesOptions as PasteRulesOptions_alias_1 } export { PasteRulesOptions as PasteRulesOptions_alias_2 } export { pathCase } export { pick } declare type PickChanged = >(keys: Key[]) => Partial, Key>>; export { PickChanged } export { PickChanged as PickChanged_alias_1 } export { PickPartial } export { PickRequired } declare interface PlaceholderConfig extends TextProps { className: string; } export { PlaceholderConfig } export { PlaceholderConfig as PlaceholderConfig_alias_1 } export { PlaceholderConfig as PlaceholderConfig_alias_2 } export declare type PlaceholderPluginAction = AddPlaceholderAction | RemovePlaceholderAction; /** * Create a plain extension which doesn't directly map to Prosemirror nodes or * marks. * * Plain extensions are a great way to add custom behavior to your editor. */ declare abstract class PlainExtension extends Extension { /** @internal */ static get [__INTERNAL_REMIRROR_IDENTIFIER_KEY__](): RemirrorIdentifier.PlainExtensionConstructor; /** @internal */ get [__INTERNAL_REMIRROR_IDENTIFIER_KEY__](): RemirrorIdentifier.PlainExtension; } export { PlainExtension } export { PlainExtension as PlainExtension_alias_1 } export { PlainExtension as PlainExtension_alias_2 } export { plainInputRule } export { PluginKey } /** * This extension allows others extension to add the `createPlugin` method using * Prosemirror Plugins. * * @remarks * * This is an example of adding custom functionality to an extension via the * `ExtensionParameterMethods`. * * @category Builtin Extension */ declare class PluginsExtension extends PlainExtension { get name(): "plugins"; /** * All plugins created by other extension as well. */ private plugins; /** * The plugins added via the manager (for reference only). */ private managerPlugins; /** * Called when the state is is being applied after an update. */ private readonly applyStateHandlers; /** * Called when the state is first initialized. */ private readonly initStateHandlers; /** * Handlers for the `onAppendTransaction` lifecycle method. */ private readonly appendTransactionHandlers; /** * Store the plugin keys. */ private readonly pluginKeys; /** * Store state getters for the extension. */ private readonly stateGetters; /** * This extension is responsible for adding state to the editor. */ onCreate(): void; /** * Create a plugin which adds the [[`onInitState`]] and [[`onApplyState`]] * lifecycle methods. */ createPlugin(): CreateExtensionPlugin; /** * Get all the plugins from the extension. */ private extractExtensionPlugins; private readonly getPluginStateCreator; /** * Add or replace a plugin. */ private updatePlugins; private readonly getStateByName; /** * Add the plugin specific properties and methods to the manager and extension * store. */ private updateExtensionStore; /** * Reruns the `createPlugin` and `createExternalPlugins` methods of the * provided extension. * * ```ts * // From within an extension * this.store.updateExtensionPlugins(this); * ``` */ private updateExtensionPlugins; /** * Applies the store plugins to the state. If any have changed then it will be * updated. */ private dispatchPluginUpdate; } export { PluginsExtension } export { PluginsExtension as PluginsExtension_alias_1 } export { PluginsExtension as PluginsExtension_alias_2 } declare interface PluginsOptions { /** * The event handler which can be used by hooks to listen to state updates * when they are being applied to the editor. */ applyState?: Handler<(props: ApplyStateLifecycleProps) => void>; /** * The event handler which can be used by hooks to listen to intercept updates * to the transaction. */ appendTransaction?: Handler<(props: AppendLifecycleProps) => void>; } export { PluginsOptions } export { PluginsOptions as PluginsOptions_alias_1 } export { PluginsOptions as PluginsOptions_alias_2 } export { PosProps } export { Predicate } export { PredicateProps } export { preserveSelection } export { Primitive } export { PrimitiveSelection } /** * `KeyBindings` as an object or prioritized tuple. */ declare type PrioritizedKeyBindings = KeyBindings | KeyBindingsTuple; export { PrioritizedKeyBindings } export { PrioritizedKeyBindings as PrioritizedKeyBindings_alias_1 } export { PrioritizedKeyBindings as PrioritizedKeyBindings_alias_2 } export { Promisable } export { ProsemirrorAttributes } export { ProsemirrorCommandFunction } export { ProsemirrorKeyBindings } export { ProsemirrorNode } export { ProsemirrorNodeProps } export { prosemirrorNodeToDom } export { prosemirrorNodeToHtml } export { ProsemirrorPlugin } export { randomFloat } export { randomInt } export { range } export { rangeHasMark } export { RangeProps } export { ReadonlyDeep } export { RegExpProps } export { REMIRROR_WEBVIEW_NAME } export { RemirrorContentType } export { RemirrorError } export { RemirrorErrorOptions } declare type RemirrorEventListener = (params: RemirrorEventListenerProps) => void; export { RemirrorEventListener } export { RemirrorEventListener as RemirrorEventListener_alias_1 } export { RemirrorEventListener as RemirrorEventListener_alias_2 } declare interface RemirrorEventListenerProps extends EditorStateProps, Remirror.ListenerProperties, EditorViewProps { /** * The original transaction which caused this state update. * * This allows for inspecting the reason behind the state change. When * undefined this means that the state was updated externally. * * If available: * - Metadata on the transaction can be inspected. `tr.getMeta` * - Was the change caused by added / removed content? `tr.docChanged` * - Was ths change caused by an updated selection? `tr.selectionSet` * - `tr.steps` can be inspected for further granularity. */ tr?: Transaction; /** * When the state updates are not controlled and it was a transaction that * caused the state to be updated this value captures all the transaction * updates caused by prosemirror plugins hook state methods like * `filterTransactions` and `appendTransactions`. * * This is for advanced users only. */ transactions?: readonly Transaction[]; /** * A shorthand way of checking whether the update was triggered by editor * usage (internal) or overwriting the state. * * - `true` The update was triggered by a change in the prosemirror doc or an * update to the selection. In these cases `tr` will have a value. * - `false` The update was caused by a call to `setContent` or `resetContent` */ internalUpdate: boolean; /** * True when this is the first render of the editor. This applies when the * editor is first attached to the DOM. */ firstRender: boolean; /** * The previous state. */ previousState: EditorState; /** * Manually create a new state object with the desired content. */ createStateFromContent: CreateStateFromContent; } export { RemirrorEventListenerProps } export { RemirrorEventListenerProps as RemirrorEventListenerProps_alias_1 } export { RemirrorEventListenerProps as RemirrorEventListenerProps_alias_2 } export { RemirrorIdentifier } export { RemirrorIdentifierShape } export { RemirrorJSON } /** * The `Manager` has multiple hook phases which are able to hook into the * extension manager flow and add new functionality to the editor. * * The `ExtensionEventMethod`s * * - onCreate - when the extension manager is created and after the schema is * made available. * - onView - when the view has been received from the dom ref. */ /** * A class to manage the extensions and prosemirror interactions within the * editor. * * @remarks * * The RemirrorManager enables the lifecycle methods of the extensions by * calling each method in the distinct phases of the lifecycle. * * - `onCreate` - This happens when the manager is constructed. It calls on the * extension which have an `onCreate` method and allows them to do their work. * * For the built in methods, this is when the `SchemaExtension` creates the * Schema and when the `TagsExtension` combines the tags for the editor * instance. * * ```ts * const manager = Manager.create(() => [ * new DocExtension(), * new TextExtension(), * new ParagraphExtension(), * ]) * ``` * * At this point all the `onCreate` methods have been called. Including the * `onCreate` for the `Schema`. * * - `onView` - This is called the framework instance connects the * `RemirrorManager` to the ProseMirror EditorView. * * ```ts * manager.addView(new EditorView(...)) * manager.store.commands.insertText('Hello world');. * ``` * * - [[`onStateUpdate`]] - This is the method called every time the ProseMirror * state changes. Both the extensions and the `Framework` listen to this event * and can provide updates in response. */ declare class RemirrorManager { #private; /** * Create the manager for your `Remirror` editor. */ static create(extensions: Extension[] | ExtensionTemplate, settings?: Remirror.ManagerSettings): RemirrorManager; /** * Identifies this as a `Manager`. * * @internal */ get [__INTERNAL_REMIRROR_IDENTIFIER_KEY__](): RemirrorIdentifier.Manager; /** * Returns `true` if the manager has been destroyed. */ get destroyed(): boolean; /** * `true` when the view has been added to the UI layer and the editor is * running. */ get mounted(): boolean; /** * Retrieve the framework output. * * This be undefined if the manager hasn't been provided to a framework yet * the manager. * * With synchronous frameworks this means that it should only be accessed * after the manager has been applied to the editor creation function. * * For frameworks like React it is only available when the manager is provided * to the `Remirror` component and after the very first render. This means it * is available within the `onRef` callback. * * ```tsx * import React, { useEffect } from 'react'; * import { useRemirror, Remirror } from '@remirror/react'; * * const Editor = () => { * const { manager } = useRemirror(); * * const callback = () => { * return manager.output; // ✅ This is fine. * } * * useEffect(() => { * log(manager.output); // ✅ This is also fine. * }, []); * * log(manager.output); // ❌ This will be undefined on the first render. * * return * } * ``` */ get output(): FrameworkOutput | undefined; /** * Returns true when a framework is attached to the manager. * * This can be used to check if it is safe to call `manager.output`. */ get frameworkAttached(): boolean; /** * The extensions stored by this manager */ get extensions(): ReadonlyArray>; /** * The registered string handlers provided by the extensions. * * By default this includes `html` and `plainText` */ get stringHandlers(): NamedStringHandlers; /** * Get the extension manager store which is accessible at initialization. */ get store(): Remirror.ManagerStore; /** * Provides access to the extension store. */ get extensionStore(): Remirror.ExtensionStore; /** * Shorthand access to the active transaction from the manager. This is the * shared transaction available to all commands and should be used when you * need to make your commands chainable. * * If working with react and setting up your editor as a controlled component * then this is the preferred way to run custom commands, otherwise your * commands will end up being non-chainable and be overwritten by anything * that comes after. */ get tr(): Transaction; /** * Returns the stored nodes */ get nodes(): Record; /** * Returns the store marks. */ get marks(): Record; /** * A shorthand method for retrieving the schema for this extension manager * from the data. */ get schema(): EditorSchema; /** * A shorthand getter for retrieving the tags from the extension manager. */ get extensionTags(): Readonly>>; /** * A shorthand way of retrieving the editor view. */ get view(): EditorView; /** * Retrieve the settings used when creating the manager. */ get settings(): Remirror.ManagerSettings; /** * The document to use for rendering and outputting HTML. */ get document(): Document; /** * Creates the extension manager which is used to simplify the management of * the prosemirror editor. * * This is set to private to encourage using `RemirrorManager.create` * instead of the `new` keyword. */ private constructor(); /** * Loops through all extensions to set up the lifecycle handlers. */ private setupLifecycleHandlers; /** * Set the string handler to use for a given name. * * This allows users to set the string handler */ private setStringHandler; /** * Set the manager value for the provided key. This is used by extensions to * add data to the manager. */ private setStoreKey; /** * Get the manager value for the provided key. This is used by extensions to * get data from the manager. */ private getStoreKey; /** * A method to set values in the extension store which is made available to * extension. * * **NOTE** This method should only be used in the `onCreate` extension method * or it will throw an error. */ private setExtensionStore; /** * Create the initial store. */ private createExtensionStore; /** * A state getter method which is passed into the params. */ private readonly getState; /** * Stores the editor view on the manager * * @param view - the editor view */ addView(view: EditorView): this; /** * Attach a framework to the manager. */ attachFramework(framework: BaseFramework, updateHandler: (props: StateUpdateLifecycleProps) => void): void; /** * Create an empty document for the editor based on the current schema. * * This automatically looks at the supported content for the doc and the * available nodes which fulfil that content in order to create a document * with only the minimal required content. * * This can be used in conjunction with the create state to reset the current * value of the editor. */ createEmptyDoc(): ProsemirrorNode; /** * Create the editor state from content passed to this extension manager. */ createState(props?: CreateEditorStateProps): EditorState_2; /** * Add a handler to the manager. * * Currently the only event that can be listened to is the `destroy` event. */ addHandler(event: Key, cb: ManagerEvents[Key]): Unsubscribe; /** * Update the state of the view and trigger the `onStateUpdate` lifecycle * method as well. */ private readonly updateState; /** * This method should be called by the view layer every time the state is * updated. * * An example usage of this is within the collaboration extension. */ onStateUpdate(props: Omit): void; /** * Get the extension instance matching the provided constructor from the * manager. * * This will throw an error if non existent. */ getExtension(Constructor: ExtensionConstructor): InstanceType; /** * Determines in an extension is present by providing the desired * `Constructor`. * * This method can be used as a safer alternative to getExtension which * will throw an error if the constructor doesn't exist within the * extension created by this extension. */ hasExtension(Constructor: ExtensionConstructor): boolean; /** * Make a clone of the manager. * * @internalremarks What about the state stored in the extensions and presets, * does this need to be recreated as well? */ clone(): RemirrorManager; /** * Recreate the manager with new settings and extensions */ recreate(extensions?: ExtraExtension[], settings?: Remirror.ManagerSettings): RemirrorManager; /** * This method should be called to destroy the manager and remove the view. */ destroy(): void; /** * Check whether the manager includes the names or constructors provided for * the preset and extensions. * * Returns true if all are included, returns false otherwise. */ includes(mustIncludeList: Array): boolean; } declare interface RemirrorManager { /** * The constructor for the [[`RemirrorManager`]]. */ constructor: RemirrorManagerConstructor; /** * Pseudo type property which contains the recursively extracted `Extension` * stored by this manager. * * @internal */ ['~E']: Extension; /** * `AllNames` * * Get all the names of the extensions within this editor. * * @internal */ ['~AN']: GetNameUnion extends never ? string : GetNameUnion; /** * `NodeNames` * * Type inference hack for node extension names. This is the only way I know * to store types on a class. * * @internal */ ['~N']: GetNodeNameUnion extends never ? string : GetNodeNameUnion; /** * `MarkNames` * * Type inference hack for mark extension names. This is the only way I know * to store types on a class. * * @internal */ ['~M']: GetMarkNameUnion extends never ? string : GetMarkNameUnion; /** * `PlainNames` * * Type inference hack for all the plain extension names. This is the only way * I know to store types on a class. * * @internal */ ['~P']: GetPlainNameUnion extends never ? string : GetPlainNameUnion; } export { RemirrorManager } export { RemirrorManager as RemirrorManager_alias_1 } export { RemirrorManager as RemirrorManager_alias_2 } declare interface RemirrorManagerConstructor extends Function { create(extension: Extension[], settings?: Remirror.ManagerSettings): RemirrorManager; } export { RemirrorMessage } export { RemoveAnnotation } export { RemoveAnnotations } /** * Removes [[`AnyExtension`]] from an extension union. This can be used to make * typechecking stricter. * * @typeParam Extension - The union of extensions to remove [[`AnyExtension`]] from. */ declare type RemoveAny = Extension extends Extension ? AnyExtension extends Extension ? never : Extension : never; export { RemoveAny } export { RemoveAny as RemoveAny_alias_1 } export { RemoveAny as RemoveAny_alias_2 } export { RemoveFlavoring } /** * Remove the helper annotation. */ declare type RemoveHelper = Type extends Helper ? T : Type; declare type RemoveHelpers> = { [Key in keyof Type]: (...args: Parameters) => RemoveHelper>; }; export { removeMark } export { RemoveMarkProps } export { removeNodeAfter } export { removeNodeAtPosition } export { removeNodeBefore } declare interface RemovePlaceholderAction { type: ActionType.REMOVE_PLACEHOLDER; id: string; } export { Replace } export { replaceNodeAtPosition } export { replaceText } export { ReplaceTextProps } export { RequireAtLeastOne } export { RequireExactlyOne } export { ResolvedPos } export { ResolvedPosProps } export { SchemaAttributes } export { SchemaAttributesObject } /** * This is the schema extension which creates the schema and provides extra * attributes as defined in the manager or the extension settings. * * @remarks * * The schema is the most important part of the remirror editor. This is the * extension responsible for creating it, injecting extra attributes and * managing the plugin which is responsible for making sure dynamically created * attributes are updated. * * In order to add extra attributes the following would work. * * ```ts * import { RemirrorManager } from 'remirror'; * import uuid from 'uuid'; * import hash from 'made-up-hasher'; * * const manager = RemirrorManager.create([], { * extraAttributes: [ * { * identifiers: 'nodes', * attributes: { * awesome: { * default: 'awesome', * parseDOM: (domNode) => domNode.getAttribute('data-awesome'), * toDOM: (attrs) => ([ 'data-awesome', attrs.awesome ]) * }, * }, * }, * { identifiers: ['paragraph'], attributes: { id: { default: () => uuid() } } }, * { identifiers: ['bold'], attributes: { hash: (mark) => hash(JSON.stringify(mark.attrs)) } }, * ], * }) * ``` * * It is an array of identifiers and attributes. Setting the default to a * function allows you to set up a dynamic attribute which is updated with the * synchronous function that you provide to it. * * @category Builtin Extension */ declare class SchemaExtension extends PlainExtension { get name(): "schema"; /** * The dynamic attributes for each node and mark extension. * * The structure will look like the following. * * ```ts * { * paragraph: { id: () => uid(), hash: (node) => hash(node) }, * bold: { random: () => Math.random(), created: () => Date.now() }, * }; * ``` * * This object is used by the created plugin to listen for changes to the doc, * and check for new nodes and marks which haven't yet applied the dynamic * attribute and add the attribute. */ private readonly dynamicAttributes; /** * This method is responsible for creating, configuring and adding the * `schema` to the editor. `Schema` is a special type in ProseMirror editors * and with `remirror` it's all just handled for you. */ onCreate(): void; /** * This creates the plugin that is used to automatically create the dynamic * attributes defined in the extra attributes object. */ createPlugin(): CreateExtensionPlugin; /** * Add the schema and nodes to the manager and extension store. */ private addSchema; /** * Check the dynamic nodes to see if the provided node: * * - a) is dynamic and therefore can be updated. * - b) has just been created and does not yet have a value for the dynamic * node. * * @param node - the node * @param pos - the node's position * @param tr - the mutable ProseMirror transaction which is applied to create * the next editor state */ private checkAndUpdateDynamicNodes; /** * Loop through the dynamic marks to see if the provided node: * * - a) is wrapped by a matching mark. * - b) has just been added and doesn't yet have the dynamic attribute * applied. * * @param node - the node * @param pos - the node's position * @param tr - the mutable ProseMirror transaction which is applied to create * the next editor state. */ private checkAndUpdateDynamicMarks; /** * Gather all the extra attributes that have been added by extensions. */ private gatherExtraAttributes; } export { SchemaExtension } export { SchemaExtension as SchemaExtension_alias_1 } export { SchemaExtension as SchemaExtension_alias_2 } export { SchemaJSON } export { SchemaProps } export { schemaToJSON } export { SELECTED_NODE_CLASS_NAME } export { SELECTED_NODE_CLASS_SELECTOR } export { Selection_2 as Selection } export { SelectionProps } export { set } export { setBlockType } export { SetOptional } export { SetRequired } export { SetReturnType } export { setStyle } declare interface SetupExtensionProps { extension: AnyExtension; nodeNames: string[]; markNames: string[]; plainNames: string[]; store: Remirror.ExtensionStore; handlers: ManagerLifecycleHandlers; } declare function setUploadPlaceholderAction(tr: Transaction_2, action: PlaceholderPluginAction): Transaction_2; export { setUploadPlaceholderAction } export { setUploadPlaceholderAction as setUploadPlaceholderAction_alias_1 } export { setUploadPlaceholderAction as setUploadPlaceholderAction_alias_2 } export { setUploadPlaceholderAction as setUploadPlaceholderAction_alias_3 } export { shallowClone } export { Shape } /** * A shortcut map which is used by the `KeymapExtension`. */ declare type ShortcutMap = Record; export { ShortcutMap } export { ShortcutMap as ShortcutMap_alias_1 } export { ShortcutMap as ShortcutMap_alias_2 } export { ShouldSkipFunction } export { ShouldSkipProps } export { shouldUseDomEnvironment } export { Simplify } export { SkippableInputRule } export { Slice } export { SnakeCase } export { snakeCase } export { sort } export { spaceCase } export { startCase } export { startPositionOfParent } export { STATE_OVERRIDE } export { StateJSON } declare interface StateUpdateLifecycleProps extends EditorStateProps { /** * The previous state. */ previousState: EditorState; /** * When true, this lets you know that it is the first state update to happen. * This can be used to run an action that should only be run when the state is * first available. */ firstUpdate: boolean; /** * The original transaction which caused this state update. * * This allows for inspecting the reason behind the state change. * When undefined this means that the state was updated externally. * * If available: * - Metadata on the transaction can be inspected. `tr.getMeta` * - Was the change caused by added / removed content? `tr.docChanged` * - Was ths change caused by an updated selection? `tr.selectionSet` * - `tr.steps` can be inspected for further granularity. */ tr?: Transaction; /** * When the state updates are not controlled and it was a transaction that * caused the state to be updated this value captures all the transaction * updates caused by prosemirror plugins hook state methods like * `filterTransactions` and `appendTransactions`. * * This is for advanced users only, and I personally have never needed it. */ transactions?: readonly Transaction[]; } export { StateUpdateLifecycleProps } export { StateUpdateLifecycleProps as StateUpdateLifecycleProps_alias_1 } export { Static } export { StaticKey } export { StaticKeyList } declare interface StaticKeysProps { /** * The list of all keys which are static and can only be set at the start. */ staticKeys: StaticKeyList; } export { StaticShape } export { StrictReplace } export { StringHandler } export { StringHandlerOptions } export { StringHandlerProps } export { Stringified } export { StringKey } /** * This extension allows others extension to add the `createSuggesters` method * for adding the prosemirror-suggest functionality to your editor. * * @remarks * * This is an example of adding custom functionality to an extension via the * `ExtensionParameterMethods`. * * @category Builtin Extension */ declare class SuggestExtension extends PlainExtension { get name(): "suggest"; /** * Create the `addSuggester` method and `removeSuggester` methods to the * extension store. * * This can be used by extensions to conditionally add suggestion support. */ onCreate(): void; /** * Add the `prosemirror-suggest` plugin to the editor. */ createExternalPlugins(): ProsemirrorPlugin[]; /** * Allow additional `Suggesters` to be added to the editor. This can be used * by `React` to create hooks. */ onAddCustomHandler: AddCustomHandler; /** * Get the suggest plugin state. * * This may be removed at a later time. * * @experimental */ getSuggestState(state?: EditorState): Helper; /** * Get some helpful methods from the SuggestPluginState. */ getSuggestMethods(): Helper>; /** * Check to see whether the provided name is the currently active * suggester. * * @param name - the name of the suggester to include */ isSuggesterActive(name: string | string[]): Helper; } export { SuggestExtension } export { SuggestExtension as SuggestExtension_alias_1 } export { SuggestExtension as SuggestExtension_alias_2 } declare interface SuggestOptions { /** * The custom handler which enables adding `suggesters`. */ suggester: CustomHandler; } export { SuggestOptions } export { SuggestOptions as SuggestOptions_alias_1 } export { SuggestOptions as SuggestOptions_alias_2 } /** * Create the extension tags which are passed into each extensions method to * enable dynamically generated rules and commands. * * Tags on nodes and marks are automatically added to the schema as groups. * * @category Builtin Extension */ declare class TagsExtension extends PlainExtension { get name(): "tags"; /** * Track the tags which have been applied to the extensions in this editor. */ private allTags; /** * The tags for plain extensions. */ private plainTags; /** * The tags for mark extensions. */ private markTags; /** * The tags for node extensions. */ private nodeTags; /** * Create the tags which are used to identify extension with particular * behavioral traits. */ onCreate(): void; /** * Reset the tags to the empty object with empty arrays. */ private resetTags; /** * Update the tags object for each extension. */ private updateTagForExtension; } export { TagsExtension } export { TagsExtension as TagsExtension_alias_1 } export { TagsExtension as TagsExtension_alias_2 } export { take } export { textBetween } export { TextProps } export { throttle } export { ThrottledFunction } /** * Checks whether a given string is unique to the set. Add the name if it * doesn't already exist, or throw an error when `shouldThrow` is true. * * @param props - destructured params */ export declare function throwIfNameNotUnique(props: IsNameUniqueProps): void; export { toggleBlockItem } export { ToggleBlockItemProps } /** * A custom `toggleMark` function that works for the `remirror` codebase. * * Create a command function that toggles the given mark with the given * attributes. Will return `false` when the current selection doesn't support * that mark. This will remove the mark if any marks of that type exist in the * selection, or add it otherwise. If the selection is empty, this applies to * the [stored marks](#state.EditorState.storedMarks) instead of a range of the * document. * * The differences from the `prosemirror-commands` version. * - Acts on the transaction rather than the state to allow for commands to be * chained together. * - Uses the ONE parameter function signature for compatibility with remirror. * - Supports passing a custom range. */ declare function toggleMark(props: ToggleMarkProps): CommandFunction; export { toggleMark } export { toggleMark as toggleMark_alias_1 } export declare interface ToggleMarkProps extends MarkTypeProps, Partial { /** * @deprecated use `selection` property instead. */ range?: FromToProps; /** * The selection point for toggling the chosen mark. */ selection?: PrimitiveSelection; } export { toggleWrap } export { toString_2 as toString } export { Transaction } export { TransactionProps } export { TransactionTransformer } /** * Transforms the unsorted array of presets and extension into presets and * sorted extensions. Handles uniqueness of extensions and automatically throws * an error when required extensions are missing. * * @internalremarks Currently matching by constructor - what if different * versions exist in the same app * * @param initialExtensions - the extensions to be transformed. This includes * the extension that are parents to other extensions. * * @returns the list of extension instances sorted by priority */ export declare function transformExtensions(initialExtensions: readonly RawExtensions[], settings: Remirror.ManagerSettings): ExtensionTransformation; declare interface TriggerChangeProps { /** * Whether or not to trigger this as a change and call any handlers. * * @defaultValue true */ triggerChange?: boolean; } export { TriggerChangeProps } export { TriggerChangeProps as TriggerChangeProps_alias_1 } export { TriggerChangeProps as TriggerChangeProps_alias_2 } export { TrStateProps } export { TsConfigJson } export { TupleOf } export { TupleUnion } export { TupleValue } export { TypedArray } declare interface UiAnnotation { __uiAnnotation?: never; } declare type UiCommandFunction = CommandFunction & UiAnnotation; export { UiCommandFunction } export { UiCommandFunction as UiCommandFunction_alias_1 } export { UiCommandFunction as UiCommandFunction_alias_2 } /** * Utility type for pulling all the command names from a list. * * TODO - why doesn't this work. */ declare type UiCommandNames = StringKey>]: keyof UnionToIntersection>[P] extends '__uiAnnotation' ? true : false; }, true>>; export { UiCommandNames } export { UiCommandNames as UiCommandNames_alias_1 } export { UiCommandNames as UiCommandNames_alias_2 } export { UndefinedFlipPartialAndRequired } export { UndefinedPickPartial } export { UnionToIntersection } export { uniqueArray } export { uniqueBy } export { uniqueId } export { UnknownShape } /** * Get the union extension type from an array of extensions or from a function that returns an array of extension. * * @example * * ```ts * const extensions = [new BoldExtension(), new ItalicExtension()]; * type Extension = UnpackedExtension * // Extension = BoldExtension | ItalicExtension * ``` * * @example * * ```ts * const extensions = () => [new BoldExtension(), new ItalicExtension()]; * type Extension = UnpackedExtension * // Extension = BoldExtension | ItalicExtension * ``` */ declare type UnpackedExtension AnyExtension[])> = UnpackedReturnType[number]; export { UnpackedExtension } export { UnpackedExtension as UnpackedExtension_alias_1 } export { UnpackedExtension as UnpackedExtension_alias_2 } /** * Extract the function return type if the generic type is a function, otherwise * * @internal * * @example * * ```ts * type A = () => string * type B = UnpackedReturnType * // B = string * * type C = string * type D = UnpackedReturnType * // D = string * ``` */ declare type UnpackedReturnType = MaybeFunction extends (...args: any[]) => infer Returned ? Returned : MaybeFunction; export { unset } declare type UpdatableViewProps = 'attributes' | 'editable'; export { UpdatableViewProps } export { UpdatableViewProps as UpdatableViewProps_alias_1 } export { UpdatableViewProps as UpdatableViewProps_alias_2 } declare type UpdatableViewPropsObject = { [Key in UpdatableViewProps]: DirectEditorProps[Key]; }; export { UpdatableViewPropsObject } export { UpdatableViewPropsObject as UpdatableViewPropsObject_alias_1 } export { updateMark } export { UpdateMarkProps } /** * @internal */ declare type UpdateReason = 'set' | 'reset'; export { UpdateReason } export { UpdateReason as UpdateReason_alias_1 } declare interface UpdateReasonProps { /** * Describes what triggered an update. * * - `set` - the change was triggered by an update in some properties * - `reset` - the user has specifically requested to reset all properties to * their initial defaults * - `init` - the update is happening when the preset is being It will receive * all the items as changes. */ reason: UpdateReason; } export { UpdateReasonProps } export { UpdateReasonProps as UpdateReasonProps_alias_1 } declare interface UpdateStateProps extends Partial, EditorStateProps, TriggerChangeProps { /** * When the state updates are not controlled and it was a transaction that * caused the state to be updated this value captures all the transaction * updates caused by prosemirror plugins hook state methods like * `filterTransactions` and `appendTransactions`. * * This is for advanced users only. */ transactions?: readonly Transaction[]; } export { UpdateStateProps } export { UpdateStateProps as UpdateStateProps_alias_1 } export { UpdateStateProps as UpdateStateProps_alias_2 } declare interface UploadContext { set: (key: string, value: unknown) => void; get: (key: string) => unknown; addListener: (listener: UploadContextListener) => () => void; } export { UploadContext } export { UploadContext as UploadContext_alias_1 } export { UploadContext as UploadContext_alias_2 } export { UploadContext as UploadContext_alias_3 } declare type UploadContextListener = (values: Record) => void; /** * `UploadExtension` handle the file upload process. */ declare class UploadExtension extends PlainExtension { get name(): "upload"; /** * Create the extension plugin for inserting decorations into the editor. */ createExternalPlugins(): ProsemirrorPlugin_2[]; } export { UploadExtension } export { UploadExtension as UploadExtension_alias_1 } export { UploadExtension as UploadExtension_alias_2 } export { UploadExtension as UploadExtension_alias_3 } /** * Insert a file into the editor and upload it. */ declare function uploadFile({ file, pos, view, fileType, uploadHandler, }: UploadFileProps): void; export { uploadFile } export { uploadFile as uploadFile_alias_1 } export { uploadFile as uploadFile_alias_2 } export { uploadFile as uploadFile_alias_3 } declare type UploadFileHandler = () => FileUploader; export { UploadFileHandler } export { UploadFileHandler as UploadFileHandler_alias_1 } export { UploadFileHandler as UploadFileHandler_alias_2 } export { UploadFileHandler as UploadFileHandler_alias_3 } export declare interface UploadFileProps { file: File; pos: number | undefined; view: EditorView_2; fileType: NodeType_2; uploadHandler: UploadFileHandler; } declare interface UploadPlaceholderPayload { context: UploadContext; fileUploader: FileUploader; } export { UploadPlaceholderPayload } export { UploadPlaceholderPayload as UploadPlaceholderPayload_alias_1 } export { UploadPlaceholderPayload as UploadPlaceholderPayload_alias_2 } export { UploadPlaceholderPayload as UploadPlaceholderPayload_alias_3 } declare interface UploadPlaceholderPluginData { set: DecorationSet_2; payloads: Map; } export { UseDefault } export { ValidOptions } export { Value } export { ValueOf } export { values } declare interface WidgetPlaceholder extends BasePlaceholder, DataProps { /** * Declare this as a widget tracker. * * Widget trackers support adding custom components to the created dom * element. */ type: 'widget'; /** * Widget trackers only support fixed positions. */ pos: number; /** * Called the first time this widget decoration is added to the dom. */ createElement?(view: EditorView, pos: number): HTMLElement; /** * Called whenever the position tracker updates with the new position. */ onUpdate?(view: EditorView, pos: number, element: HTMLElement, data: any): void; /** * Called when the widget decoration is removed from the dom. */ onDestroy?(view: EditorView, element: HTMLElement): void; } export { WidgetPlaceholder } export { WidgetPlaceholder as WidgetPlaceholder_alias_1 } export { WidgetPlaceholder as WidgetPlaceholder_alias_2 } declare type WithBase = MakeRequired & { id: unknown; }; export { within } /** * A type with a name property. */ declare type WithName = Type & { name: string; }; export { wrapIn } export { Writable } export { Writeable } export { ZERO_WIDTH_SPACE_CHAR } export { } declare global { namespace Remirror { /** * A global type which allows setting additional options on the exclude. */ interface ExcludeOptions {} /** * A global type which allows additional default settings to be added to the * editor. */ interface BaseExtensionOptions {} } } /** * An interface for creating custom plugins in your `remirror` editor. */ export interface CreateExtensionPlugin extends Pick< PluginSpec, 'props' | 'state' | 'key' | 'view' | 'filterTransaction' | 'appendTransaction' > { /** Additional properties are allowed on plugin specs, which can be read via [`Plugin.spec`](https://prosemirror.net/docs/ref/#state.Plugin.spec). */ [key: string]: any; } /** * The type of arguments acceptable for the focus parameter. * * - Can be a prosemirror selection * - A range of `{ from: number; to: number }` * - A single position with a `number` * - A string of `'start' | 'end'` * - `true` which sets the focus to the current position or start. */ export type FocusType = PrimitiveSelection | boolean; declare global { namespace Remirror { interface ManagerStore { /** * The attributes to be added to the prosemirror editor. */ attributes: ProsemirrorAttributes; } interface ExtensionStore { /** * Triggers a recalculation of the `view.dom` attributes for each * extension and notifies the parent UI once done. * * This will also dispatch an update to the state automatically. However * you can disable this by setting `triggerUpdate` to `false`. * * By not triggering an update the new value may not be capture by the view layer, e.g. `React`. * * @param triggerUpdate - defaults to true */ updateAttributes: (triggerUpdate?: boolean) => void; } interface ExcludeOptions { /** * Whether to use the attributes provided by this extension * * @defaultValue undefined */ attributes?: boolean; } interface BaseExtension { /** * A list of class names to add to the main editor element. */ classNames?: ClassName[]; /** * Allows the extension to modify the attributes for the Prosemirror editor * dom element. * * @remarks * * Sometimes an extension will need to make a change to the attributes of the * editor itself. For example a placeholder may need to do some work to make * the editor more accessible by setting the `aria-placeholder` value to match * the value of the placeholder. * * @alpha */ createAttributes?(): ProsemirrorAttributes; } interface AllExtensions { attributes: AttributesExtension; } } } declare global { namespace Remirror { /** * UX options for the command which can be extended. */ interface CommandDecoratorOptions extends CommandUiDecoratorOptions { /** * A function which can be used to override whether a command is already * active for the current selection. */ active?: (options: Options, store: ExtensionStore) => boolean; } } } declare global { namespace Remirror { interface ManagerSettings { /** * The options that can be passed into the built in options. */ builtin?: GetStaticAndDynamic; } /** * The builtin preset. */ type Builtin = BuiltinPreset; /** * The union of every extension available via the remirror codebase. */ type Extensions = ValueOf; } } declare global { namespace Remirror { interface ManagerStore { /** * Get the forced updates from the provided transaction. */ getForcedUpdates: (tr: Transaction) => ForcedUpdateMeta; /** * Enables the use of custom commands created by extensions which extend * the functionality of your editor in an expressive way. * * @remarks * * Commands are synchronous and immediately dispatched. This means that * they can be used to create menu items when the functionality you need * is already available by the commands. * * ```ts * if (commands.toggleBold.enabled()) { * commands.toggleBold(); * } * ``` */ commands: CommandsFromExtensions; /** * Chainable commands for composing functionality together in quaint and * beautiful ways * * @remarks * * You can use this property to create expressive and complex commands * that build up the transaction until it can be run. * * The way chainable commands work is by adding multiple steps to a shared * transaction which is then dispatched when the `run` command is called. * This requires making sure that commands within your code use the `tr` * that is provided rather than the `state.tr` property. `state.tr` * creates a new transaction which is not shared by the other steps in a * chainable command. * * The aim is to make as many commands as possible chainable as explained * [here](https://github.com/remirror/remirror/issues/418#issuecomment-666922209). * * There are certain commands that can't be made chainable. * * - undo * - redo * * ```ts * chain * .toggleBold() * .insertText('Hi') * .setSelection('all') * .run(); * ``` * * The `run()` method ends the chain and dispatches the command. */ chain: ChainedFromExtensions; } interface BaseExtension { /** * `ExtensionCommands` * * This pseudo property makes it easier to infer Generic types of this * class. * * @internal */ ['~C']: this['createCommands'] extends AnyFunction ? ReturnType : EmptyShape; /** * @experimental * * Stores all the command names for this decoration that have been added * as decorators to the extension instance. This is used by the * `CommandsExtension` to pick the commands and store meta data attached * to each command. * * @internal */ decoratedCommands?: Record; /** * Create and register commands for that can be called within the editor. * * These are typically used to create menu's actions and as a direct * response to user actions. * * @remarks * * The `createCommands` method should return an object with each key being * unique within the editor. To ensure that this is the case it is * recommended that the keys of the command are namespaced with the name * of the extension. * * ```ts * import { ExtensionFactory } from '@remirror/core'; * * const MyExtension = ExtensionFactory.plain({ * name: 'myExtension', * version: '1.0.0', * createCommands() { * return { * haveFun() { * return ({ state, dispatch }) => { * if (dispatch) { * dispatch(tr.insertText('Have fun!')); * } * * return true; // True return signifies that this command is enabled. * } * }, * } * } * }) * ``` * * The actions available in this case would be `undoHistory` and * `redoHistory`. It is unlikely that any other extension would override * these commands. * * Another benefit of commands is that they are picked up by typescript * and can provide code completion for consumers of the extension. */ createCommands?(): ExtensionCommandReturn; } interface ExtensionStore { /** * A property containing all the available commands in the editor. * * This should only be accessed after the `onView` lifecycle method * otherwise it will throw an error. If you want to use it in the * `createCommands` function then make sure it is used within the returned * function scope and not in the outer scope. */ commands: CommandsFromExtensions; /** * A method that returns an object with all the chainable commands * available to be run. * * @remarks * * Each chainable command mutates the states transaction so after running * all your commands. you should dispatch the desired transaction. * * This should only be called when the view has been initialized (i.e.) * within the `createCommands` method calls. * * ```ts * import { ExtensionFactory } from '@remirror/core'; * * const MyExtension = ExtensionFactory.plain({ * name: 'myExtension', * version: '1.0.0', * createCommands: () => { * // This will throw since it can only be called within the returned * methods. * const chain = this.store.chain; // ❌ * * return { * // This is good 😋 * haveFun() { * return ({ state, dispatch }) => * this.store.chain.insertText('fun!').run(); ✅ * }, * } * } * }) * ``` * * This should only be accessed after the `EditorView` has been fully * attached to the `RemirrorManager`. * * The chain can also be called as a function with a custom `tr` * parameter. This allows you to provide a custom transaction to use * within the chainable commands. * * Use the command at the beginning of the command chain to override the * shared transaction. * * There are times when you want to be sure of the transaction which is * being updated. * * To restore the previous transaction call the `restore` chained method. * * @param tr - the transaction to set */ chain: ChainedFromExtensions; } interface AllExtensions { commands: CommandsExtension; } /** * The command names for all core extensions. */ type AllCommandNames = LiteralUnion, string>; /** * The command names for all core extensions. */ type AllUiCommandNames = LiteralUnion, string>; } } declare global { namespace Remirror { interface ExtensionStore { /** * Create delayed command which automatically adds a placeholder to the * document while the delayed command is being run and also automatically * removes it once it has completed. */ createPlaceholderCommand( props: DelayedPlaceholderCommandProps, ): DelayedCommand; } interface BaseExtension { /** * Create a decoration set which adds decorations to your editor. The * first parameter is the `EditorState`. * * This can be used in combination with the `onApplyState` handler which * can map the decoration. * * @param state - the editor state which was passed in. */ createDecorations?(state: EditorState): DecorationSet; } interface AllExtensions { decorations: DecorationsExtension; } } } declare global { namespace Remirror { interface ManagerStore { /** * The helpers provided by the extensions used. */ helpers: HelpersFromExtensions; /** * Check which nodes and marks are active under the current user * selection. * * ```ts * const { active } = manager.store; * * return active.bold() ? 'bold' : 'regular'; * ``` */ active: ActiveFromExtensions; /** * Get the attributes for the named node or mark from the current user * selection. * * ```ts * const { attrs } = manager.store; * * attrs.heading(); // => { id: 'i1238ha', level: 1 } * ``` */ attrs: AttrsFromExtensions; } interface BaseExtension { /** * `ExtensionHelpers` * * This pseudo property makes it easier to infer Generic types of this * class. * * @internal */ ['~H']: this['createHelpers'] extends AnyFunction ? ReturnType : EmptyShape; /** * @experimental * * Stores all the helpers that have been added via decorators to the * extension instance. This is used by the `HelpersExtension` to pick the * helpers. * * @internal */ decoratedHelpers?: Record; /** * A helper method is a function that takes in arguments and returns a * value depicting the state of the editor specific to this extension. * * @remarks * * Unlike commands they can return anything and may not effect the * behavior of the editor. * * Below is an example which should provide some idea on how to add * helpers to the app. * * ```tsx * // extension.ts * import { ExtensionFactory } from '@remirror/core'; * * const MyBeautifulExtension = ExtensionFactory.plain({ * name: 'beautiful', * createHelpers: () => ({ * checkBeautyLevel: () => 100 * }), * }) * ``` * * ``` * // app.tsx * import { useRemirrorContext } from '@remirror/react'; * * const MyEditor = () => { * const { helpers } = useRemirrorContext({ autoUpdate: true }); * * return helpers.beautiful.checkBeautyLevel() > 50 * ? (😍) * : (😢); * }; * ``` */ createHelpers?(): ExtensionHelperReturn; } interface StringHandlers { /** * Register the plain `text` string handler which renders a text string * inside a `
`.
       */
      text: HelpersExtension;

      /**
       * Register the html string handler, which converts a html string to a
       * prosemirror node.
       */
      html: HelpersExtension;
    }

    interface ExtensionStore {
      /**
       * Helper method to provide information about the content of the editor.
       * Each extension can register its own helpers.
       *
       * This should only be accessed after the `onView` lifecycle method
       * otherwise it will throw an error.
       */
      helpers: HelpersFromExtensions;

      /**
       * Check which nodes and marks are active under the current user
       * selection.
       *
       * ```ts
       * const { active } = manager.store;
       *
       * return active.bold() ? 'bold' : 'regular';
       * ```
       */
      active: ActiveFromExtensions;

      /**
       * Get the attributes for the named node or mark from the current user
       * selection.
       *
       * ```ts
       * const { attrs } = manager.store;
       *
       * attrs.heading(); // => { id: 'i1238ha', level: 1 }
       * ```
       */
      attrs: AttrsFromExtensions;
    }

    interface ListenerProperties {
      helpers: HelpersFromExtensions;
    }

    interface AllExtensions {
      helpers: HelpersExtension;
    }
  }

  /**
   * The helpers name for all extension defined in the current project.
   */
  type AllHelperNames = LiteralUnion, string>;
}


declare global {
  namespace Remirror {
    interface ExcludeOptions {
      /**
       * Whether to use the inputRules for this particular extension.
       *
       * @defaultValue undefined
       */
      inputRules?: boolean;
    }

    interface ExtensionStore {
      /**
       * When called this will run through every `createInputRules` method on every
       * extension to recreate input rules.
       *
       * @remarks
       *
       * Under the hood it updates the plugin which is used to insert the
       * input rules into the editor. This causes the state to be updated and
       * will cause a rerender in your ui framework.
       */
      rebuildInputRules: () => void;
    }

    interface BaseExtension {
      /**
       * Register input rules which are activated if the regex matches as a user is
       * typing.
       *
       * @param parameter - schema parameter with type included
       */
      createInputRules?(): InputRule[];
    }

    interface AllExtensions {
      inputRules: InputRulesExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface ExcludeOptions {
      /**
       * Whether to exclude keybindings support. This is not a recommended
       * action and can break functionality.
       *
       * @defaultValue undefined
       */
      keymap?: boolean;
    }

    interface ExtensionStore {
      /**
       * When called this will run through every `createKeymap` method on every
       * extension to recreate the keyboard bindings.
       *
       * @remarks
       *
       * **NOTE** - This will not update keybinding for extensions that
       * implement their own keybinding functionality (e.g. any plugin using
       * Suggestions)
       */
      rebuildKeymap: () => void;
    }

    interface BaseExtension {
      /**
       * Stores all the keybinding names and options for this decoration that
       * have been added as decorators to the extension instance. This is used
       * by the `KeymapExtension` to pick the commands and store metadata
       * attached to each command.
       *
       * @internal
       */
      decoratedKeybindings?: Record;

      /**
       * Add keymap bindings for this extension.
       *
       * @param parameter - schema parameter with type included
       */
      createKeymap?(extractShortcutNames: (shortcut: string) => string[]): PrioritizedKeyBindings;
    }

    interface AllExtensions {
      keymap: KeymapExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface ManagerStore {
      /**
       * Get the command metadata for the transaction.
       * @internal
       */
      getCommandMeta(tr: Transaction): Metadata[];
    }
    interface AllExtensions {
      meta: MetaExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface ManagerSettings {
      /**
       * Add custom node views to the manager which will take priority over the
       * nodeViews provided by the extensions and plugins.
       */
      nodeViews?: Record;
    }

    interface BaseExtension {
      /**
       * Registers one or multiple nodeViews for the extension.
       *
       * This is a shorthand way of registering a nodeView without the need to
       * create a prosemirror plugin. It allows for the registration of one nodeView
       * which has the same name as the extension.
       *
       * To register more than one you would need to use a custom plugin returned
       * from the `plugin` method.
       *
       * @param parameter - schema parameter with type included
       */
      createNodeViews?(): NodeViewMethod | Record;
    }

    interface AllExtensions {
      nodeViews: NodeViewsExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface ExcludeOptions {
      /**
       * Whether to exclude the extension's pasteRules
       *
       * @defaultValue undefined
       */
      pasteRules?: boolean;
    }

    interface BaseExtension {
      /**
       * Register paste rules for this extension.
       *
       * Paste rules are activated when text, images, or html is pasted into the
       * editor.
       */
      createPasteRules?(): PasteRule[] | PasteRule;
    }

    interface AllExtensions {
      pasteRules: PasteRulesExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface ManagerSettings {
      /**
       * Add custom plugins to the manager while creating it.
       *
       * Plugins created via the manager are given priority over all extension
       * based plugins. There's scope for adding a priority based model for
       * inserting plugins, but it seems like a sane default until that's
       * available.
       */
      plugins?: ProsemirrorPlugin[];
    }

    interface ExtensionStore {
      /**
       * Retrieve the state for any given extension name. This will throw an
       * error if the extension identified by that name doesn't implement the
       * `createPlugin` method.
       *
       * @param name - the name of the extension
       *
       * @remarks
       *
       * ```ts
       * const pluginState = getPluginState(extension.name);
       * ```
       */
      getPluginState(name: string): State;

      /**
       * Add the new plugins. If previous plugins are provided then also remove
       * the previous plugins.
       *
       * ```ts
       * this.store.updatePlugins(this.createExternalPlugins(), this.externalPlugins);
       * ```
       *
       * @param plugins - the plugins to add
       * @param previousPlugins - the plugins to remove
       */
      updatePlugins(plugins: ProsemirrorPlugin[], previousPlugins?: ProsemirrorPlugin[]): void;

      /**
       * Reruns the `createPlugin` and `createExternalPlugins` methods of the
       * provided extension.
       *
       * This will also automatically update the state with the newly generated
       * plugins by dispatching an update.
       *
       * ```ts
       * // From within an extension
       * this.store.updateExtensionPlugins(this);
       * this.store.dispatchPluginUpdate();
       * ```
       *
       * @param extension - the extension instance, constructor or name.
       */
      updateExtensionPlugins(extension: AnyExtension | AnyExtensionConstructor | string): void;

      /**
       * Applies the store plugins to the state. If any have changed then it
       * will be updated.
       */
      dispatchPluginUpdate(): void;
    }

    interface ManagerStore {
      /**
       * All of the plugins combined together from all sources
       */
      plugins: ProsemirrorPlugin[];

      /**
       * Retrieve the state for a given extension name. This will throw an error
       * if the extension doesn't exist.
       *
       * @param name - the name of the extension
       */
      getPluginState: (name: GetNameUnion) => State;

      /**
       * All the plugin keys available to be used by plugins.
       */
      pluginKeys: Record;
    }

    interface ExcludeOptions {
      /**
       * Whether to exclude the extension's plugin
       *
       * @defaultValue undefined
       */
      plugins?: boolean;
    }

    interface BaseExtension {
      /**
       * The plugin key for custom plugin created by this extension. This only
       * exists when there is a valid `createPlugin` method on the extension.
       *
       * This can be used to set and retrieve metadata.
       *
       * ```ts
       * const meta = tr.getMeta(this.pluginKey);
       * ```
       */
      pluginKey: PluginKey;

      /**
       * The plugin that was created by the `createPlugin` method. This only
       * exists for extension which implement that method.
       */
      plugin: Plugin;

      /**
       * The external plugins created by the `createExternalPlugins` method.
       */
      externalPlugins: Plugin[];

      /**
       * Retrieve the state of the custom plugin for this extension. This will
       * throw an error if the extension doesn't have a valid `createPlugin`
       * method.
       *
       * @remarks
       *
       * ```ts
       * const pluginState = this.getPluginState();
       * ```
       *
       * This is only available after the initialize stage of the editor manager
       * lifecycle.
       *
       * If you would like to use it before that e.g. in the decorations prop of
       * the `createPlugin` method, you can call it with a current state which
       * will be used to retrieve the plugin state.
       *
       * Please note that when using this in the decorations callback it is
       * advisable to pass in the `state` argument in case the callback is
       * called before the framework, or the view have been initialized.
       */
      getPluginState: (state?: EditorState) => State;

      /**
       * Create a custom plugin directly in the editor.
       *
       * @remarks
       *
       * A unique `key` is automatically applied to enable easier retrieval of
       * the plugin state.
       *
       * ```ts
       * import { CreateExtensionPlugin } from 'remirror';
       *
       * class MyExtension extends PlainExtension {
       *   get name() {
       *     return 'me' as const;
       *   }
       *
       *   createPlugin(): CreateExtensionPlugin {
       *     return {
       *       props: {
       *         handleKeyDown: keydownHandler({
       *           Backspace: handler,
       *           'Mod-Backspace': handler,
       *           Delete: handler,
       *           'Mod-Delete': handler,
       *           'Ctrl-h': handler,
       *           'Alt-Backspace': handler,
       *           'Ctrl-d': handler,
       *           'Ctrl-Alt-Backspace': handler,
       *           'Alt-Delete': handler,
       *           'Alt-d': handler,
       *         }),
       *         decorations: state => {
       *           const pluginState = this.getPluginState(state);
       *           pluginState.setDeleted(false);
       *           return pluginState.decorationSet;
       *         },
       *       },
       *     }
       *   }
       * }
       * ```
       */
      createPlugin?(): CreateExtensionPlugin;

      /**
       * Register third party plugins when this extension is placed into the
       * editor.
       *
       * @remarks
       *
       * Some plugins (like the table plugin) consume several different plugins,
       * creator method allows you to return a list of plugins you'd like to
       * support.
       */
      createExternalPlugins?(): ProsemirrorPlugin[];
    }

    interface AllExtensions {
      plugins: PluginsExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface BaseExtension {
      /**
       * Allows the extension to create an extra attributes array that will be
       * added to the extra attributes.
       *
       * For example the `@remirror/extension-bidi` adds a `dir` attribute to
       * all node extensions which allows them to automatically infer whether
       * the text direction should be right-to-left, or left-to-right.
       */
      createSchemaAttributes?(): IdentifierSchemaAttributes[];
    }
    interface BaseExtensionOptions {
      /**
       * Inject additional attributes into the defined mark / node schema. This
       * can only be used for `NodeExtensions` and `MarkExtensions`.
       *
       * @remarks
       *
       * Sometimes you need to add additional attributes to a node or mark. This
       * property enables this without needing to create a new extension.
       *
       * This is only applied to the `MarkExtension` and `NodeExtension`.
       *
       * @defaultValue {}
       */
      extraAttributes?: Static;

      /**
       * When true will disable extra attributes for this instance of the
       * extension.
       *
       * @remarks
       *
       * This is only applied to the `MarkExtension` and `NodeExtension`.
       *
       * @defaultValue undefined
       */
      disableExtraAttributes?: Static;

      /**
       * An override for the mark spec object. This only applies for
       * `MarkExtension`.
       */
      markOverride?: Static;

      /**
       * An override object for a node spec object. This only applies to the
       * `NodeExtension`.
       */
      nodeOverride?: Static;
    }

    interface ManagerSettings {
      /**
       * Allows for setting extra attributes on multiple nodes and marks by
       * their name or constructor. These attributes are automatically added and
       * retrieved from from the dom by prosemirror.
       *
       * @remarks
       *
       * An example is shown below.
       *
       * ```ts
       * import { RemirrorManager } from 'remirror';
       *
       * const managerSettings = {
       *   extraAttributes: [
       *     {
       *       identifiers: ['blockquote', 'heading'],
       *       attributes: { id: 'id', alignment: '0', },
       *     }, {
       *       identifiers: ['mention', 'codeBlock'],
       *       attributes: { 'userId': { default: null } },
       *     },
       *   ]
       * };
       *
       * const manager = RemirrorManager.create([], { extraAttributes })
       * ```
       */
      extraAttributes?: IdentifierSchemaAttributes[];

      /**
       * Overrides for the mark.
       */
      markOverride?: Record;

      /**
       * Overrides for the nodes.
       */
      nodeOverride?: Record;

      /**
       * Perhaps you don't need extra attributes at all in the editor. This
       * allows you to disable extra attributes when set to true.
       *
       * @defaultValue undefined
       */
      disableExtraAttributes?: boolean;

      /**
       * Setting this to a value will override the default behaviour of the
       * `RemirrorManager`. It overrides the created schema and ignores the
       * specs created by all extensions within your editor.
       *
       * @remarks
       *
       * This is an advanced option and should only be used in cases where there
       * is a deeper understanding of `Prosemirror`. By setting this, please
       * note that a lot of functionality just won't work which is powered by
       * the `extraAttributes`.
       */
      schema?: EditorSchema;

      /**
       * The name of the default block node. This node will be given a higher
       * priority when being added to the schema.
       *
       * By default this is undefined and the default block node is assigned
       * based on the extension priorities.
       *
       * @defaultValue undefined
       */
      defaultBlockNode?: string;
    }

    interface ManagerStore {
      /**
       * The nodes to place on the schema.
       */
      nodes: Record<
        GetNodeNameUnion extends never ? string : GetNodeNameUnion,
        NodeExtensionSpec
      >;

      /**
       * The marks to be added to the schema.
       */
      marks: Record<
        GetMarkNameUnion extends never ? string : GetMarkNameUnion,
        MarkExtensionSpec
      >;

      /**
       * The schema created by this extension manager.
       */
      schema: EditorSchema;

      /**
       * The name of the default block node. This is used by all internal
       * extension when toggling block nodes. It can also be used in other
       * cases.
       *
       * This can be updated via the manager settings when first creating the
       * editor.
       *
       * @defaultValue 'paragraph'
       */
      defaultBlockNode: string;
    }

    interface MarkExtension {
      /**
       * Provides access to the `MarkExtensionSpec`.
       */
      spec: MarkExtensionSpec;
    }

    interface NodeExtension {
      /**
       * Provides access to the `NodeExtensionSpec`.
       */
      spec: NodeExtensionSpec;
    }

    interface ExtensionStore {
      /**
       * The Prosemirror schema being used for the current editor.
       *
       * @remarks
       *
       * The value is created when the manager initializes. So it can be used in
       * `createCommands`, `createHelpers`, `createKeymap` and most of the
       * creator methods.
       */
      schema: EditorSchema;
    }

    interface StaticExtensionOptions {
      /**
       * When true will disable extra attributes for all instances of this
       * extension.
       *
       * @defaultValue false
       */
      readonly disableExtraAttributes?: boolean;
    }

    interface AllExtensions {
      schema: SchemaExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface ExcludeOptions {
      /**
       * Whether to exclude the suggesters plugin configuration for the
       * extension.
       *
       * @defaultValue undefined
       */
      suggesters?: boolean;
    }

    interface BaseExtension {
      /**
       * Create suggesters which respond to an activation `char` or regex
       * pattern within the editor instance. The onChange handler provided is
       * called with the data around the matching text.
       *
       * @remarks
       *
       * Suggesters are a  powerful way of building up the editors
       * functionality. They can support `@` mentions, `#` tagging, `/` special
       * command keys which trigger action menus and much more.
       */
      createSuggesters?(): Suggester[] | Suggester;
    }

    interface AllExtensions {
      suggest: SuggestExtension;
    }

    interface ExtensionStore {
      /**
       * Add a suggester.
       */
      addSuggester(suggester: Suggester): void;

      /**
       * Remove a suggester.
       */
      removeSuggester(suggester: Suggester | string): void;
    }

    interface AllExtensions {
      suggest: SuggestExtension;
    }
  }
}


declare global {
  namespace Remirror {
    interface ManagerSettings {
      /**
       * Add extra tags to the extensions by name. This can be used to add
       * behavior traits to certain extensions.
       *
       * Please note this will change the schema since the tags are added to the
       * node and mark groups.
       *
       * ```ts
       * RemirrorManager.create(
       *   [],
       *   { extraTags: { bold: [ExtensionTag.Awesome] } }
       * );
       * ```
       */
      extraTags?: Record;
    }

    interface BaseExtension {
      /**
       * The generated tags for this extension are added here. Do not add this
       * property to your extensions as it will be overridden.
       */
      tags: ExtensionTagType[];

      /**
       * Dynamically create tags for the extension.
       *
       * Tags are a helpful tool for categorizing the behavior of an extension.
       * This behavior is later grouped in the `Manager` and passed to the
       * `extensionStore`. Tags can be used by commands that need to remove all
       * formatting and use the tag to identify which registered extensions are
       * formatters.
       *
       * @remarks
       *
       * Tags are also automatically added to the node and mark extensions as a
       * group when they are found there.
       *
       * There are internally defined tags but it's also possible to define any
       * custom string as a tag. See [[`ExtensionTag`]].
       */
      createTags?(): ExtensionTagType[];
    }
    type A = UseDefault;

    interface ManagerStore {
      /**
       * All the tags provided by the configured extensions.
       */
      tags: Readonly<
        CombinedTags extends never ? string : GetNameUnion>
      >;

      /**
       * All the plain extension tags provided for the editor.
       */
      plainTags: Readonly<
        CombinedTags<
          GetPlainNameUnion extends never ? string : GetPlainNameUnion
        >
      >;

      /**
       * All the node extension tags provided for the editor.
       */
      nodeTags: Readonly<
        CombinedTags<
          GetNodeNameUnion extends never ? string : GetNodeNameUnion
        >
      >;

      /**
       * All the mark extension tags provided for the editor.
       */
      markTags: Readonly<
        CombinedTags<
          GetMarkNameUnion extends never ? string : GetMarkNameUnion
        >
      >;
    }

    interface ExtensionStore {
      /**
       * All the tags provided by the configured extensions.
       */
      tags: CombinedTags;

      /**
       * All the plain extension tags provided for the editor.
       */
      plainTags: CombinedTags;

      /**
       * All the node extension tags provided for the editor.
       */
      nodeTags: CombinedTags;

      /**
       * All the mark extension tags provided for the editor.
       */
      markTags: CombinedTags;
    }

    interface BaseExtensionOptions {
      /**
       * Add extra tags to the extension.
       *
       * Tags can be used to unlock certain behavioural traits for nodes and
       * marks.
       *
       * Please note this will change the schema since the tags are added to the
       * node and mark groups.
       */
      extraTags?: ExtensionTagType[];
    }

    interface AllExtensions {
      tags: TagsExtension;
    }
  }
}


declare global {
  namespace Remirror {
    /**
     * A utility type for all the globally available extension names. This is
     * mainly used to provide autocompletion.
     */
    type NameUnion = LiteralUnion, string>;

    /**
     * A utility type for all the globally available plain extension names. This
     * is mainly used to provide autocompletion.
     */
    type PlainNameUnion = LiteralUnion, string>;

    /**
     * A utility type for all the globally available node extension names. This
     * is mainly used to provide autocompletion.
     */
    type NodeNameUnion = LiteralUnion, string>;

    /**
     * A utility type for all the globally available mark extension names. This
     * is mainly used to provide autocompletion.
     */
    type MarkNameUnion = LiteralUnion, string>;
  }
}


declare global {
  /**
   * This namespace is global and you can use declaration merging to extend and
   * create new types used by the `remirror` project.
   *
   * @remarks
   *
   * The following would add `MyCustomType` to the `Remirror` namespace. Please
   * note that this can only be used for types and interfaces.
   *
   * ```ts
   * declare global {
   *   namespace Remirror {
   *     type MyCustomType = 'look-at-me';
   *   }
   * }
   * ```
   */
  namespace Remirror {
    /**
     * This interface stores all the currently installed extensions. As a result
     * it can be used to set the default loaded extensions to include all
     * available within `node_modules`. By extending this extension in the
     * global `Remirror` namespace the key is ignored but the value is used to
     * form the union type in the `chain`, `commands`, `helpers` properties on
     * the `Remirror.ExtensionStore` interface.
     *
     * This is useful for extensions being able to reuse the work of other
     * extension.
     */
    interface AllExtensions {}

    /**
     * This is the global interface for adding extra methods and properties to
     * all [[`Extension`]]s using declaration merging.
     *
     * @remarks
     *
     * The following will add `newOption` to the expected options. This is the
     * way that extensions which add new functionality to the editor can request
     * configuration options.
     *
     * ```ts
     * declare global {
     *   namespace Remirror {
     *     interface ExtensionFactoryProps {
     *       newOption?: string;
     *     }
     *   }
     * }
     * ```
     */
    interface BaseExtension {}

    interface NodeExtension {}
    interface MarkExtension {}

    /**
     * An override to for the `AnyExtension` type. If you're extension adds a
     * new property to the `Extension` that is deeply nested or very complex it
     * can break the `AnyExtension` implementation from being compatible with
     * all valid extensions.
     *
     * The keys you provide on this override replace the default `AnyExtension`
     * types include unsafe properties that need to be simplified.
     *
     * An example is the `constructor` property which makes it impossible to
     * find a common interface between extensions with different settings and
     * properties. By setting the `constructor` to a much simpler override all
     * `Extension`'s are now assignable to the `AnyExtension type again.`
     */
    interface AnyExtensionOverrides extends AnyBaseClassOverrides {
      constructor: AnyExtensionConstructor;
      ['~C']: ExtensionCommandReturn;
      ['~H']: ExtensionHelperReturn;
      ['~E']: AnyExtension;
    }
  }
}

/* eslint-enable @typescript-eslint/member-ordering */

// Make the abstract extension available but only as a type.
export type { Extension };


declare global {
  namespace Remirror {
    interface ListenerProperties {}
  }
}


declare global {
  namespace Remirror {
    /**
     * Settings which can be passed into the manager.
     */
    interface ManagerSettings extends Partial {
      /**
       * Set the extension priority for extension's by their name.
       */
      priority?: Record;

      /**
       * An object which excludes certain functionality from all extensions
       * within the manager.
       */
      exclude?: ExcludeOptions;

      /**
       * The error handler which is called when the JSON passed is invalid.
       *
       * @remarks
       *
       * The following can be used to setup the `onError` handler on the the
       * manager.
       *
       * ```tsx
       * import React from 'react';
       * import { Remirror, InvalidContentHandler } from 'remirror';
       * import { Remirror, useManager } from '@remirror/react';
       * import { WysiwygPreset } from 'remirror/extensions';
       *
       * const Editor = () => {
       *   const onError: InvalidContentHandler = useCallback(({ json, invalidContent, transformers }) => {
       *     // Automatically remove all invalid nodes and marks.
       *     return transformers.remove(json, invalidContent);
       *   }, []);
       *
       *   const manager = useManager(() => [new WysiwygPreset()], { onError });
       *
       *   return (
       *     
       *       

       *     
       *   );
       * };
       * ```
       */
      onError?: InvalidContentHandler;

      /**
       * A function which transforms a string into a prosemirror node.
       *
       * @remarks
       *
       * Can be used to transform markdown / html or any other string format into a
       * prosemirror node.
       *
       * See [[`fromHTML`]] for an example of how this could work.
       */
      stringHandler?: keyof Remirror.StringHandlers | StringHandler;

      /**
       * The default named selection. This is used when `manager.createState` is
       * called without providing a selection.
       *
       * @defaultValue 'end'
       */
      defaultSelection?: 'start' | 'end' | 'all';
    }

    /**
     * Describes the object where the extension manager stores it's data.
     *
     * @remarks
     *
     * Since this is a global namespace, you can extend the store if your
     * extension is modifying the shape of the `Manager.store` property.
     */
    interface ManagerStore {
      /**
       * The editor view stored by this instance.
       */
      view: EditorView;
    }

    interface ExtensionStore {
      /**
       * Make the remirror manager available to the editor.
       */
      manager: AnyRemirrorManager;

      /**
       * The list of all extensions included in the editor.
       */
      readonly extensions: AnyExtension[];

      /**
       * The stage the manager is currently at.
       */
      readonly phase: ManagerPhase;

      /**
       * The view available to extensions once `addView` has been called on the
       * `RemirrorManager` instance.
       */
      readonly view: EditorView;

      /**
       * The latest state.
       */
      currentState: EditorState;

      /**
       * The previous state. Will be undefined when the view is first created.
       */
      previousState?: EditorState;

      /**
       * The root document to be used for the editor. This is mainly used for
       * non-browser environment.
       */
      readonly document: Document;

      /**
       * The settings passed to the manager.
       */
      readonly managerSettings: ManagerSettings;

      /**
       * The names of every node extension.
       */
      nodeNames: readonly string[];

      /**
       * The names of every mark extension.
       */
      markNames: readonly string[];

      /**
       * The names of every plain extension.
       */
      plainNames: readonly string[];

      /**
       * The named string handlers which are supported by the current editor
       * implementation.
       */
      readonly stringHandlers: NamedStringHandlers;

      /**
       * Return true when the editor view has been created.
       */
      readonly isMounted: () => boolean;

      /**
       * A helper method for retrieving the state of the editor
       */
      readonly getState: () => EditorState;

      /**
       * Allow extensions to trigger an update in the prosemirror state. This
       * should not be used often. It's here in case you need it in an
       * emergency.
       *
       * Internally it's used by the [[`PluginsExtension`]] to create a new
       * state when the plugins are updated at runtime.
       */
      readonly updateState: (state: EditorState) => void;

      /**
       * Get the extension instance matching the provided constructor from the
       * manager.
       *
       * This will throw an error if not defined.
       */
      readonly getExtension: (
        Constructor: ExtensionConstructor,
      ) => InstanceType;

      /**
       * Get the value of a key from the manager store.
       */
      getStoreKey: (key: Key) => AnyManagerStore[Key];

      /**
       * Update the store with a specific key.
       */
      setStoreKey: (key: Key, value: AnyManagerStore[Key]) => void;

      /**
       * Set a value on the extension store. One of the design decisions in this `1.0.0`
       * version of `remirror` was to move away from passing elaborate arguments to each extension
       * method and allow extensions to interact with a store shared by all
       * extensions.
       *
       * The extension store object is immutable and will throw an error if updated directly.
       *
       * ```ts
       * class MyExtension extends PlainExtension {
       *   get name() {}
       * }
       * ```
       */
      setExtensionStore: (
        key: Key,
        value: ExtensionStore[Key],
      ) => void;

      /**
       * Set the string handler to use for a given name.
       *
       * This allows users to set the string handler
       */
      setStringHandler: (name: keyof StringHandlers, handler: StringHandler) => void;
    }
  }
}


declare global {
  namespace Remirror {
    interface AllExtensions {
      upload: UploadExtension;
    }
  }
}