xt-plugin-editor 1.0.0 → 1.3.1

package/projects/editor/src/lib/prose-mirror/basic-setup.ts

@@ -1,655 +0,0 @@
-
-
-
-/// Given a blockquote node type, returns an input rule that turns `"> "`
-/// at the start of a textblock into a blockquote.
-
-import {
-  wrapItem, blockTypeItem, Dropdown, DropdownSubmenu, joinUpItem, liftItem,
-  selectParentNodeItem, undoItem, redoItem, icons, MenuItem, MenuElement, MenuItemSpec, menuBar
-} from 'prosemirror-menu';
-import {NodeSelection, EditorState, Command} from "prosemirror-state"
-import {Schema, NodeType, MarkType} from "prosemirror-model"
-
-import {Attrs} from "prosemirror-model"
-
-const prefix = "ProseMirror-prompt"
-
-import {
-  wrapIn, setBlockType, chainCommands, toggleMark, exitCode,
-  joinUp, joinDown, lift, selectParentNode, baseKeymap
-} from 'prosemirror-commands';
-import {wrapInList, splitListItem, liftListItem, sinkListItem} from "prosemirror-schema-list"
-import { undo, redo, history } from 'prosemirror-history';
-import {
-  ellipsis, emDash,
-  inputRules,
-  smartQuotes,
-  textblockTypeInputRule,
-  undoInputRule,
-  wrappingInputRule
-} from 'prosemirror-inputrules';
-import { keymap } from 'prosemirror-keymap';
-import { dropCursor } from 'prosemirror-dropcursor';
-import { gapCursor } from 'prosemirror-gapcursor';
-
-const mac = typeof navigator != "undefined" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform) : false
-
-/// Inspect the given schema looking for marks and nodes from the
-/// basic schema, and if found, add key bindings related to them.
-/// This will add:
-///
-/// * **Mod-b** for toggling [strong](#schema-basic.StrongMark)
-/// * **Mod-i** for toggling [emphasis](#schema-basic.EmMark)
-/// * **Mod-`** for toggling [code font](#schema-basic.CodeMark)
-/// * **Ctrl-Shift-0** for making the current textblock a paragraph
-/// * **Ctrl-Shift-1** to **Ctrl-Shift-Digit6** for making the current
-///   textblock a heading of the corresponding level
-/// * **Ctrl-Shift-Backslash** to make the current textblock a code block
-/// * **Ctrl-Shift-8** to wrap the selection in an ordered list
-/// * **Ctrl-Shift-9** to wrap the selection in a bullet list
-/// * **Ctrl->** to wrap the selection in a block quote
-/// * **Enter** to split a non-empty textblock in a list item while at
-///   the same time splitting the list item
-/// * **Mod-Enter** to insert a hard break
-/// * **Mod-_** to insert a horizontal rule
-/// * **Backspace** to undo an input rule
-/// * **Alt-ArrowUp** to `joinUp`
-/// * **Alt-ArrowDown** to `joinDown`
-/// * **Mod-BracketLeft** to `lift`
-/// * **Escape** to `selectParentNode`
-///
-/// You can suppress or map these bindings by passing a `mapKeys`
-/// argument, which maps key names (say `"Mod-B"` to either `false`, to
-/// remove the binding, or a new key name string.
-export function buildKeymap(schema: Schema, mapKeys?: {[key: string]: false | string}) {
-  let keys: {[key: string]: Command} = {}, type
-  function bind(key: string, cmd: Command) {
-    if (mapKeys) {
-      let mapped = mapKeys[key]
-      if (mapped === false) return
-      if (mapped) key = mapped
-    }
-    keys[key] = cmd
-  }
-
-  bind("Mod-z", undo)
-  bind("Shift-Mod-z", redo)
-  bind("Backspace", undoInputRule)
-  if (!mac) bind("Mod-y", redo)
-
-  bind("Alt-ArrowUp", joinUp)
-  bind("Alt-ArrowDown", joinDown)
-  bind("Mod-BracketLeft", lift)
-  bind("Escape", selectParentNode)
-
-  if (type = schema.marks["strong"]) {
-    bind("Mod-b", toggleMark(type))
-    bind("Mod-B", toggleMark(type))
-  }
-  if (type = schema.marks["em"]) {
-    bind("Mod-i", toggleMark(type))
-    bind("Mod-I", toggleMark(type))
-  }
-  if (type = schema.marks["code"])
-    bind("Mod-`", toggleMark(type))
-
-  if (type = schema.nodes["bullet_list"])
-    bind("Shift-Ctrl-8", wrapInList(type))
-  if (type = schema.nodes["ordered_list"])
-    bind("Shift-Ctrl-9", wrapInList(type))
-  if (type = schema.nodes["blockquote"])
-    bind("Ctrl->", wrapIn(type))
-  if (type = schema.nodes["hard_break"]) {
-    let br = type as any, cmd = chainCommands(exitCode, (state, dispatch) => {
-      if (dispatch) dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView())
-      return true
-    })
-    bind("Mod-Enter", cmd)
-    bind("Shift-Enter", cmd)
-    if (mac) bind("Ctrl-Enter", cmd)
-  }
-  if (type = schema.nodes["list_item"]) {
-    bind("Enter", splitListItem(type))
-    bind("Mod-[", liftListItem(type))
-    bind("Mod-]", sinkListItem(type))
-  }
-  if (type = schema.nodes["paragraph"])
-    bind("Shift-Ctrl-0", setBlockType(type))
-  if (type = schema.nodes["code_block"])
-    bind("Shift-Ctrl-\\", setBlockType(type))
-  if (type = schema.nodes["heading"])
-    for (let i = 1; i <= 6; i++) bind("Shift-Ctrl-" + i, setBlockType(type, {level: i}))
-  if (type = schema.nodes["horizontal_rule"]) {
-    let hr = type as any
-    bind("Mod-_", (state, dispatch) => {
-      if (dispatch) dispatch(state.tr.replaceSelectionWith(hr.create()).scrollIntoView())
-      return true
-    })
-  }
-
-  return keys
-}
-
-
-export function openPrompt(options: {
-  title: string,
-  fields: {[name: string]: Field},
-  callback: (attrs: Attrs) => void
-}) {
-  let wrapper = document.body.appendChild(document.createElement("div"))
-  wrapper.className = prefix
-
-  let mouseOutside = (e: MouseEvent) => { if (!wrapper.contains(e.target as HTMLElement)) close() }
-  setTimeout(() => window.addEventListener("mousedown", mouseOutside), 50)
-  let close = () => {
-    window.removeEventListener("mousedown", mouseOutside)
-    if (wrapper.parentNode) wrapper.parentNode.removeChild(wrapper)
-  }
-
-  let domFields: HTMLElement[] = []
-  for (let name in options.fields) domFields.push(options.fields[name].render())
-
-  let submitButton = document.createElement("button")
-  submitButton.type = "submit"
-  submitButton.className = prefix + "-submit"
-  submitButton.textContent = "OK"
-  let cancelButton = document.createElement("button")
-  cancelButton.type = "button"
-  cancelButton.className = prefix + "-cancel"
-  cancelButton.textContent = "Cancel"
-  cancelButton.addEventListener("click", close)
-
-  let form = wrapper.appendChild(document.createElement("form"))
-  if (options.title) form.appendChild(document.createElement("h5")).textContent = options.title
-  domFields.forEach(field => {
-    form.appendChild(document.createElement("div")).appendChild(field)
-  })
-  let buttons = form.appendChild(document.createElement("div"))
-  buttons.className = prefix + "-buttons"
-  buttons.appendChild(submitButton)
-  buttons.appendChild(document.createTextNode(" "))
-  buttons.appendChild(cancelButton)
-
-  let box = wrapper.getBoundingClientRect()
-  wrapper.style.top = ((window.innerHeight - box.height) / 2) + "px"
-  wrapper.style.left = ((window.innerWidth - box.width) / 2) + "px"
-
-  let submit = () => {
-    let params = getValues(options.fields, domFields)
-    if (params) {
-      close()
-      options.callback(params)
-    }
-  }
-
-  form.addEventListener("submit", e => {
-    e.preventDefault()
-    submit()
-  })
-
-  form.addEventListener("keydown", e => {
-    if (e.keyCode == 27) {
-      e.preventDefault()
-      close()
-    } else if (e.keyCode == 13 && !(e.ctrlKey || e.metaKey || e.shiftKey)) {
-      e.preventDefault()
-      submit()
-    } else if (e.keyCode == 9) {
-      window.setTimeout(() => {
-        if (!wrapper.contains(document.activeElement)) close()
-      }, 500)
-    }
-  })
-
-  let input = form.elements[0] as HTMLElement
-  if (input) input.focus()
-}
-
-function getValues(fields: {[name: string]: Field}, domFields: readonly HTMLElement[]) {
-  let result = Object.create(null), i = 0
-  for (let name in fields) {
-    let field = fields[name], dom = domFields[i++]
-    let value = field.read(dom), bad = field.validate(value)
-    if (bad) {
-      reportInvalid(dom, bad)
-      return null
-    }
-    result[name] = field.clean(value)
-  }
-  return result
-}
-
-function reportInvalid(dom: HTMLElement, message: string) {
-  // FIXME this is awful and needs a lot more work
-  let parent = dom.parentNode!
-  let msg = parent.appendChild(document.createElement("div"))
-  msg.style.left = (dom.offsetLeft + dom.offsetWidth + 2) + "px"
-  msg.style.top = (dom.offsetTop - 5) + "px"
-  msg.className = "ProseMirror-invalid"
-  msg.textContent = message
-  setTimeout(() => parent.removeChild(msg), 1500)
-}
-
-/// The type of field that `openPrompt` expects to be passed to it.
-export abstract class Field {
-  /// Create a field with the given options. Options support by all
-  /// field types are:
-  constructor(
-    /// @internal
-    readonly options: {
-      /// The starting value for the field.
-      value?: any
-
-      /// The label for the field.
-      label: string
-
-      /// Whether the field is required.
-      required?: boolean
-
-      /// A function to validate the given value. Should return an
-      /// error message if it is not valid.
-      validate?: (value: any) => string | null
-
-      /// A cleanup function for field values.
-      clean?: (value: any) => any
-    }
-  ) {}
-
-  /// Render the field to the DOM. Should be implemented by all subclasses.
-  abstract render(): HTMLElement
-
-  /// Read the field's value from its DOM node.
-  read(dom: HTMLElement) { return (dom as any).value }
-
-  /// A field-type-specific validation function.
-  validateType(value: any): string | null { return null }
-
-  /// @internal
-  validate(value: any): string | null {
-    if (!value && this.options.required)
-      return "Required field"
-    return this.validateType(value) || (this.options.validate ? this.options.validate(value) : null)
-  }
-
-  clean(value: any): any {
-    return this.options.clean ? this.options.clean(value) : value
-  }
-}
-
-/// A field class for single-line text fields.
-export class TextField extends Field {
-  render() {
-    let input = document.createElement("input")
-    input.type = "text"
-    input.placeholder = this.options.label
-    input.value = this.options.value || ""
-    input.autocomplete = "off"
-    return input
-  }
-}
-
-
-/// A field class for dropdown fields based on a plain `<select>`
-/// tag. Expects an option `options`, which should be an array of
-/// `{value: string, label: string}` objects, or a function taking a
-/// `ProseMirror` instance and returning such an array.
-export class SelectField extends Field {
-  render() {
-    let select = document.createElement("select")
-    ;((this.options as any).options as {value: string, label: string}[]).forEach(o => {
-      let opt = select.appendChild(document.createElement("option"))
-      opt.value = o.value
-      opt.selected = o.value == this.options.value
-      opt.label = o.label
-    })
-    return select
-  }
-}
-
-// Helpers to create specific types of items
-
-export function canInsert(state: EditorState, nodeType: NodeType) {
-  let $from = state.selection.$from
-  for (let d = $from.depth; d >= 0; d--) {
-    let index = $from.index(d)
-    if ($from.node(d).canReplaceWith(index, index, nodeType)) return true
-  }
-  return false
-}
-
-function insertImageItem(nodeType: NodeType) {
-  return new MenuItem({
-    title: "Insert image",
-    label: "Image",
-    enable(state) { return canInsert(state, nodeType) },
-    run(state, _, view) {
-      let {from, to} = state.selection, attrs = null
-      if (state.selection instanceof NodeSelection && state.selection.node.type == nodeType)
-        attrs = state.selection.node.attrs
-      openPrompt({
-        title: "Insert image",
-        fields: {
-          src: new TextField({label: "Location", required: true, value: attrs && attrs["src"]}),
-          title: new TextField({label: "Title", value: attrs && attrs["title"]}),
-          alt: new TextField({label: "Description",
-            value: attrs ? attrs["alt"] : state.doc.textBetween(from, to, " ")})
-        },
-        callback(attrs) {
-          view.dispatch(view.state.tr.replaceSelectionWith(nodeType.createAndFill(attrs)!))
-          view.focus()
-        }
-      })
-    }
-  })
-}
-
-function cmdItem(cmd: Command, options: Partial<MenuItemSpec>) {
-  let passedOptions: MenuItemSpec = {
-    label: options.title as string | undefined,
-    run: cmd
-  }
-  for (let prop in options) (passedOptions as any)[prop] = (options as any)[prop]
-  if (!options.enable && !options.select)
-    passedOptions[options.enable ? "enable" : "select"] = state => cmd(state)
-
-  return new MenuItem(passedOptions)
-}
-
-export function markActive(state: EditorState, type: MarkType) {
-  let {from, $from, to, empty} = state.selection
-  if (empty) return !!type.isInSet(state.storedMarks || $from.marks())
-  else return state.doc.rangeHasMark(from, to, type)
-}
-
-function markItem(markType: MarkType, options: Partial<MenuItemSpec>) {
-  let passedOptions: Partial<MenuItemSpec> = {
-    active(state) { return markActive(state, markType) }
-  }
-  for (let prop in options) (passedOptions as any)[prop] = (options as any)[prop]
-  return cmdItem(toggleMark(markType), passedOptions)
-}
-
-function linkItem(markType: MarkType) {
-  return new MenuItem({
-    title: "Add or remove link",
-    icon: icons["link"],
-    active(state) { return markActive(state, markType) },
-    enable(state) { return !state.selection.empty },
-    run(state, dispatch, view) {
-      if (markActive(state, markType)) {
-        toggleMark(markType)(state, dispatch)
-        return true
-      }
-      openPrompt({
-        title: "Create a link",
-        fields: {
-          href: new TextField({
-            label: "Link target",
-            required: true
-          }),
-          title: new TextField({label: "Title"})
-        },
-        callback(attrs) {
-          toggleMark(markType, attrs)(view.state, view.dispatch)
-          view.focus()
-        }
-      })
-      return true
-    }
-  })
-}
-
-function wrapListItem(nodeType: NodeType, options: Partial<MenuItemSpec>) {
-  return cmdItem(wrapInList(nodeType, (options as any).attrs), options)
-}
-
-type MenuItemResult = {
-  /// A menu item to toggle the [strong mark](#schema-basic.StrongMark).
-  toggleStrong?: MenuElement
-
-  /// A menu item to toggle the [emphasis mark](#schema-basic.EmMark).
-  toggleEm?: MenuElement
-
-  /// A menu item to toggle the [code font mark](#schema-basic.CodeMark).
-  toggleCode?: MenuElement
-
-  /// A menu item to toggle the [link mark](#schema-basic.LinkMark).
-  toggleLink?: MenuElement
-
-  /// A menu item to insert an [image](#schema-basic.Image).
-  insertImage?: MenuElement
-
-  /// A menu item to wrap the selection in a [bullet list](#schema-list.BulletList).
-  wrapBulletList?: MenuElement
-
-  /// A menu item to wrap the selection in an [ordered list](#schema-list.OrderedList).
-  wrapOrderedList?: MenuElement
-
-  /// A menu item to wrap the selection in a [block quote](#schema-basic.BlockQuote).
-  wrapBlockQuote?: MenuElement
-
-  /// A menu item to set the current textblock to be a normal
-  /// [paragraph](#schema-basic.Paragraph).
-  makeParagraph?: MenuElement
-
-  /// A menu item to set the current textblock to be a
-  /// [code block](#schema-basic.CodeBlock).
-  makeCodeBlock?: MenuElement
-
-  /// Menu items to set the current textblock to be a
-  /// [heading](#schema-basic.Heading) of level _N_.
-  makeHead1?: MenuElement
-  makeHead2?: MenuElement
-  makeHead3?: MenuElement
-  makeHead4?: MenuElement
-  makeHead5?: MenuElement
-  makeHead6?: MenuElement
-
-  /// A menu item to insert a horizontal rule.
-  insertHorizontalRule?: MenuElement
-
-  /// A dropdown containing the `insertImage` and
-  /// `insertHorizontalRule` items.
-  insertMenu: Dropdown
-
-  /// A dropdown containing the items for making the current
-  /// textblock a paragraph, code block, or heading.
-  typeMenu: Dropdown
-
-  /// Array of block-related menu items.
-  blockMenu: MenuElement[][]
-
-  /// Inline-markup related menu items.
-  inlineMenu: MenuElement[][]
-
-  /// An array of arrays of menu elements for use as the full menu
-  /// for, for example the [menu
-  /// bar](https://code.haverbeke.berlin/prosemirror/prosemirror-menu).
-  fullMenu: MenuElement[][]
-}
-
-/// Given a schema, look for default mark and node types in it and
-/// return an object with relevant menu items relating to those marks.
-export function buildMenuItems(schema: Schema, override?:{[itemName:string]:MenuElement}): MenuItemResult {
-  let r: MenuItemResult = {} as any
-  let mark: MarkType | undefined;
-  override=override||{};
- if (mark = schema.marks["strong"])
-    r.toggleStrong = override["strong"]||markItem(mark, {title: "Toggle strong style", icon: icons["strong"]})
-  if (mark = schema.marks["em"])
-    r.toggleEm = override["em"]|| markItem(mark, {title: "Toggle emphasis", icon: icons["em"]})
-  if (mark = schema.marks["code"])
-    r.toggleCode = override["code"]||markItem(mark, {title: "Toggle code font", icon: icons["code"]})
-  if (mark = schema.marks["link"])
-    r.toggleLink = override["link"]||linkItem(mark)
-
-  let node: NodeType | undefined
-  if (node = schema.nodes["image"])
-    r.insertImage = override["image"]||insertImageItem(node)
-  if (node = schema.nodes["bullet_list"])
-    r.wrapBulletList = override["bullet_list"]||wrapListItem(node, {
-      title: "Wrap in bullet list",
-      icon: icons["bulletList"]
-    })
-  if (node = schema.nodes["ordered_list"])
-    r.wrapOrderedList = override["ordered_list"]||wrapListItem(node, {
-      title: "Wrap in ordered list",
-      icon: icons["orderedList"]
-    })
-  if (node = schema.nodes["blockquote"])
-    r.wrapBlockQuote = override["blockquote"]||wrapItem(node, {
-      title: "Wrap in block quote",
-      icon: icons["blockquote"]
-    })
-  if (node = schema.nodes["paragraph"])
-    r.makeParagraph = override["paragraph"]||blockTypeItem(node, {
-      title: "Change to paragraph",
-      label: "Plain"
-    })
-  if (node = schema.nodes["code_block"])
-    r.makeCodeBlock = override["code_block"]||blockTypeItem(node, {
-      title: "Change to code block",
-      label: "Code"
-    })
-  if (node = schema.nodes["heading"])
-    for (let i = 1; i <= 10; i++)
-      (r as any)["makeHead" + i] = override["makeHead"+i]||blockTypeItem(node, {
-        title: "Change to heading " + i,
-        label: "Level " + i,
-        attrs: {level: i}
-      })
-  if (node = schema.nodes["horizontal_rule"]) {
-    let hr = node
-    r.insertHorizontalRule = override["horizontal_rule"]||new MenuItem({
-      title: "Insert horizontal rule",
-      label: "Horizontal rule",
-      enable(state) { return canInsert(state, hr) },
-      run(state, dispatch) { dispatch(state.tr.replaceSelectionWith(hr.create())) }
-    })
-  }
-
-  let cut = <T>(arr: T[]) => arr.filter(x => x) as NonNullable<T>[]
-  r.insertMenu = new Dropdown(cut([r.insertImage, r.insertHorizontalRule]), {label: "Insert"})
-  r.typeMenu = new Dropdown(cut([r.makeParagraph, r.makeCodeBlock, r.makeHead1 && new DropdownSubmenu(cut([
-    r.makeHead1, r.makeHead2, r.makeHead3, r.makeHead4, r.makeHead5, r.makeHead6
-  ]), {label: "Heading"})]), {label: "Type..."})
-
-  r.inlineMenu = [cut([r.toggleStrong, r.toggleEm, r.toggleCode, r.toggleLink])]
-  r.blockMenu = [cut([r.wrapBulletList, r.wrapOrderedList, r.wrapBlockQuote, joinUpItem,
-    liftItem, selectParentNodeItem])]
-  r.fullMenu = r.inlineMenu.concat([[r.insertMenu, r.typeMenu]], [[undoItem, redoItem]], r.blockMenu)
-
-  return r
-}
-
-export function blockQuoteRule(nodeType: NodeType) {
-  return wrappingInputRule(/^\s*>\s$/, nodeType)
-}
-
-/// Given a list node type, returns an input rule that turns a number
-/// followed by a dot at the start of a textblock into an ordered list.
-export function orderedListRule(nodeType: NodeType) {
-  return wrappingInputRule(/^(\d+)\.\s$/, nodeType, match => ({order: +match[1]}),
-    (match, node) => node.childCount + node.attrs["order"] == +match[1])
-}
-
-/// Given a list node type, returns an input rule that turns a bullet
-/// (dash, plush, or asterisk) at the start of a textblock into a
-/// bullet list.
-export function bulletListRule(nodeType: NodeType) {
-  return wrappingInputRule(/^\s*([-+*])\s$/, nodeType)
-}
-
-/// Given a code block node type, returns an input rule that turns a
-/// textblock starting with three backticks into a code block.
-export function codeBlockRule(nodeType: NodeType) {
-  return textblockTypeInputRule(/^```$/, nodeType)
-}
-
-/// Given a node type and a maximum level, creates an input rule that
-/// turns up to that number of `#` characters followed by a space at
-/// the start of a textblock into a heading whose level corresponds to
-/// the number of `#` signs.
-export function headingRule(nodeType: NodeType, maxLevel: number) {
-  return textblockTypeInputRule(new RegExp("^(#{1," + maxLevel + "})\\s$"),
-    nodeType, match => ({level: match[1].length}))
-}
-
-/// A set of input rules for creating the basic block quotes, lists,
-/// code blocks, and heading.
-export function buildInputRules(schema: Schema) {
-  let rules = smartQuotes.concat(ellipsis, emDash), type
-  if (type = schema.nodes["blockquote"]) rules.push(blockQuoteRule(type))
-  if (type = schema.nodes["ordered_list"]) rules.push(orderedListRule(type))
-  if (type = schema.nodes["bullet_list"]) rules.push(bulletListRule(type))
-  if (type = schema.nodes["code_block"]) rules.push(codeBlockRule(type))
-  if (type = schema.nodes["heading"]) rules.push(headingRule(type, 6))
-  return inputRules({rules})
-}
-
-/// Create an array of plugins pre-configured for the given schema.
-/// The resulting array will include the following plugins:
-///
-///  * Input rules for smart quotes and creating the block types in the
-///    schema using markdown conventions (say `"> "` to create a
-///    blockquote)
-///
-///  * A keymap that defines keys to create and manipulate the nodes in the
-///    schema
-///
-///  * A keymap binding the default keys provided by the
-///    prosemirror-commands module
-///
-///  * The undo history plugin
-///
-///  * The drop cursor plugin
-///
-///  * The gap cursor plugin
-///
-///  * A custom plugin that adds a `menuContent` prop for the
-///    prosemirror-menu wrapper, and a CSS class that enables the
-///    additional styling defined in `style/style.css` in this package
-///
-/// Probably only useful for quickly setting up a passable
-/// editor—you'll need more control over your settings in most
-/// real-world situations.
-export function basicSetup(options: {
-  /// The schema to generate key bindings and menu items for.
-  schema: Schema
-
-  /// Can be used to [adjust](#example-setup.buildKeymap) the key bindings created.
-  mapKeys?: {[key: string]: string | false}
-
-  /// Set to false to disable the menu bar.
-  menuBar?: boolean
-
-  /// Set to false to disable the history plugin.
-  history?: boolean
-
-  /// Set to false to make the menu bar non-floating.
-  floatingMenu?: boolean
-
-  /// Can be used to override any menu content.
-  menuContent?: { [itemName:string]:MenuElement }
-}) {
-  let plugins = [
-    buildInputRules(options.schema),
-    keymap(buildKeymap(options.schema, options.mapKeys)),
-    keymap(baseKeymap),
-    dropCursor(),
-    gapCursor()
-  ]
-  if (options.menuBar !== false)
-    plugins.push(menuBar({floating: options.floatingMenu !== false,
-      content: buildMenuItems(options.schema, options.menuContent).fullMenu}))
-  if (options.history !== false)
-    plugins.push(history())
-
-  return plugins;/*.concat(new Plugin({
-    props: {
-      attributes: {class: "ProseMirror-example-setup-style"}
-    }
-  }))*/
-}
-

package/projects/editor/src/lib/register.ts

@@ -1,33 +0,0 @@
-import { XtResolverService } from 'xt-components';
-import { EditorComponent } from './editor/editor.component';
-
-export function registerEditorPlugin (resolverService:XtResolverService):string {
-  const pluginName = "Plugin Editor";
-    console.info ('Registering ' +pluginName);
-    resolverService.registerPlugin ({
-        name:pluginName,
-        uriLogo:'pluginicon.png',
-        cssUrls: [
-          'prosemirror-view/style/prosemirror.css',
-          'prosemirror-menu/style/menu.css',
-          'prosemirror-gapcursor/style/gapcursor.css'
-        ],
-        components: [
-            {
-              componentName:'Editor',
-              componentClass:EditorComponent,
-              typesHandled: ['markdown','rich-text','description'],
-            }
-        ],
-      types: {
-        'markdown':'string',
-        'rich-text':'string',
-        'description':'string'
-      }
-    });
-    return pluginName;
-}
-
-export function registerPlugin (resolverService:XtResolverService):string {
-  return registerEditorPlugin(resolverService);
-}

package/projects/editor/src/public-api.ts

@@ -1,7 +0,0 @@
-/*
- * Public API Surface of web plugin
- */
-
-export * from './lib/editor/editor.component';
-export * from './lib/register';
-export * from './lib/markdown/markdown-pipe'