hello
")) it("can represent a line break", test(doc(p("hi", br, "there")), "hi
there
hi
there
onetwothreefourfive
")) it("can represent links", test(doc(p("a ", a({href: "foo"}, "big ", a({href: "bar"}, "nested"), " link"))), "")) it("can represent and unordered list", test(doc(ul(li(p("one")), li(p("two")), li(p("three", strong("!")))), p("after")), "one
two
three!
after
")) it("can represent an ordered list", test(doc(ol(li(p("one")), li(p("two")), li(p("three", strong("!")))), p("after")), "one
two
three!
after
")) it("can represent a blockquote", test(doc(blockquote(p("hello"), p("bye"))), "")) it("can represent a nested blockquote", test(doc(blockquote(blockquote(blockquote(p("he said"))), p("i said"))), "hello
bye
")) it("can represent headings", test(doc(h1("one"), h2("two"), p("text")), "he said
i said
one
two
text
")) it("can represent inline code", test(doc(p("text and ", code("code that is ", em("emphasized"), "..."))), "text and code that is emphasized...
some code
and
")) it("supports leaf nodes in marks", test(doc(p(em("hi", br, "x"))), "hi
x
\u00a0 \u00a0hello\u00a0
")) it("can parse marks on block nodes", () => { let commentSchema = new Schema({ nodes: schema.spec.nodes.update("doc", Object.assign({marks: "comment"}, schema.spec.nodes.get("doc"))), marks: schema.spec.marks.update("comment", { parseDOM: [{tag: "div.comment"}], toDOM() { return ["div", {class: "comment"}, 0] } }) }) let b = builders(commentSchema) test(b.doc(b.paragraph("one"), b.comment(b.paragraph("two"), b.paragraph(b.strong("three"))), b.paragraph("four")), "one
four
")() }) it("parses unique, non-exclusive, same-typed marks", () => { let commentSchema = new Schema({ nodes: schema.spec.nodes, marks: schema.spec.marks.update("comment", { attrs: { id: { default: null }}, parseDOM: [{ tag: "span.comment", getAttrs(dom) { return { id: parseInt(dom.getAttribute('data-id'), 10) } } }], excludes: '', toDOM(mark) { return ["span", {class: "comment", "data-id": mark.attrs.id }, 0] } }) }) let b = builders(commentSchema) test(b.schema.nodes.doc.createAndFill(undefined, [ b.schema.nodes.paragraph.createAndFill(undefined, [ b.schema.text('double comment', [ b.schema.marks.comment.create({ id: 1 }), b.schema.marks.comment.create({ id: 2 }) ]) ]) ]), "double comment
")() }) it("serializes non-spanning marks correctly", () => { let markSchema = new Schema({ nodes: schema.spec.nodes, marks: schema.spec.marks.update("test", { parseDOM: [{tag: "test"}], toDOM() { return ["test", 0] }, spanning: false }) }) let b = builders(markSchema) test(b.doc(b.paragraph(b.test("a", b.image({src: "x"}), "b"))), "Oh no
hi
bye
",
doc(p("hi"), p("bye"))))
it("interprets and as emphasis and strong",
recover("hello there
", doc(p(em("hello ", strong("there")))))) it("wraps stray text in a paragraph", recover("hi", doc(p("hi")))) it("ignores an extra wrapping",
recover("",
doc(p("one"), p("two"))))
it("ignores meaningless whitespace",
recover(" T hi",
doc(p("hi"))))
it("only applies a mark once",
recover("wow such ", {topNode: schema.nodes.bullet_list.createAndFill()},
ul(li(p("wow")), li(p("such")))))
let item = schema.nodes.list_item.createAndFill()
it("accepts the topMatch option",
parse("
![]()
", {from: 1, to: 3},
doc(p("foo"), p("bar"))))
it("accepts the preserveWhitespace option",
parse("foo bar", {preserveWhitespace: true},
doc(p("foo bar"))))
function open(html, nodes, openStart, openEnd, options) {
return () => {
let dom = document.createElement("div")
dom.innerHTML = html
let result = parser.parseSlice(dom, options)
ist(result, new Slice(Fragment.from(nodes.map(n => typeof n == "string" ? schema.text(n) : n)), openStart, openEnd), eq)
}
}
it("can parse an open slice",
open("foo", ["foo"], 0, 0))
it("will accept weird siblings",
open("foofoo ", [li(p("foo")), li()], 2, 1))
it("will create textblocks for block nodes",
open("", [p("foo"), p("bar")], 1, 1))
it("can parse marks at the start of defaulted textblocks",
open(" ", [], 0, 0, {preserveWhitespace: true}))
it("keeps whitespace in inline elements",
open(" ", [p(strong(" ")).child(0)], 0, 0, {preserveWhitespace: true}))
it("can parse nested mark with same type but different attrs", () => {
let markSchema = new Schema({
nodes: schema.spec.nodes,
marks: schema.spec.marks.update("s", {
attrs: {
'data-s': { default: 'tag' }
},
excludes: '',
parseDOM: [{
tag: "s",
}, {
style: "text-decoration",
getAttrs() {
return {
'data-s': 'style'
}
}
}]
})
})
let b = builders(markSchema)
let dom = document.createElement("div")
dom.innerHTML = "'
}
if (node.type.name === 'hard_break') {
return ''
}
}), 'foo')
})
})
describe("textContent", () => {
it("works on a whole doc", () => {
ist(doc(p("foo")).textContent, "foo")
})
it("works on a text node", () => {
ist(schema.text("foo").textContent, "foo")
})
it("works on a nested element", () => {
ist(doc(ul(li(p("hi")), li(p(em("a"), "b")))).textContent,
"hiab")
})
})
describe("from", () => {
function from(arg, expect) {
ist(expect.copy(Fragment.from(arg)), expect, eq)
}
it("wraps a single node", () =>
from(schema.node("paragraph"), doc(p())))
it("wraps an array", () =>
from([schema.node("hard_break"), schema.text("foo")], p(br, "foo")))
it("preserves a fragment", () =>
from(doc(p("foo")).content, doc(p("foo"))))
it("accepts null", () =>
from(null, p()))
it("joins adjacent text", () =>
from([schema.text("a"), schema.text("b")], p("ab")))
})
describe("toJSON", () => {
function roundTrip(doc) {
ist(schema.nodeFromJSON(doc.toJSON()), doc, eq)
}
it("can serialize a simple node", () => roundTrip(doc(p("foo"))))
it("can serialize marks", () => roundTrip(doc(p("foo", em("bar", strong("baz")), " ", a("x")))))
it("can serialize inline leaf nodes", () => roundTrip(doc(p("foo", em(img, "bar")))))
it("can serialize block leaf nodes", () => roundTrip(doc(p("a"), hr, p("b"), p())))
it("can serialize nested nodes", () => roundTrip(doc(blockquote(ul(li(p("a"), p("b")), li(p(img))), p("c")), p("d"))))
})
describe("toString", () => {
it("should have the default toString method [text]", () => ist(schema.text("hello").toString(), "\"hello\""))
it("should have the default toString method [br]", () => ist(br().toString(), "hard_break"))
it("should be able to redefine it from NodeSpec by specifying toDebugString method",
() => ist(customSchema.text("hello").toString(), "custom_text"))
it("should be respected by Fragment", () =>
ist(
Fragment.fromArray(
[customSchema.text("hello"), customSchema.nodes.hard_break.createChecked(), customSchema.text("world")]
),
""
)
)
})
})
node-prosemirror-model-1.16.1+~cs1.1.5/test/test-replace.js 0000664 0000000 0000000 00000010631 14207620105 0023271 0 ustar 00root root 0000000 0000000 const {Slice} = require("..")
const {eq, doc, blockquote, h1, p, ul, li} = require("prosemirror-test-builder")
const ist = require("ist")
describe("Node", () => {
describe("replace", () => {
function rpl(doc, insert, expected) {
let slice = insert ? insert.slice(insert.tag.a, insert.tag.b) : Slice.empty
ist(doc.replace(doc.tag.a, doc.tag.b, slice), expected, eq)
}
it("joins on delete", () =>
rpl(doc(p("one"), p("two")), null, doc(p("onwo"))))
it("merges matching blocks", () =>
rpl(doc(p("one"), p("two")), doc(p("xxxx"), p("yyyy")), doc(p("onxx"), p("yywo"))))
it("merges when adding text", () =>
rpl(doc(p("one"), p("two")),
doc(p("H")),
doc(p("onHwo"))))
it("can insert text", () =>
rpl(doc(p("before"), p("one"), p("after")),
doc(p("H")),
doc(p("before"), p("onHe"), p("after"))))
it("doesn't merge non-matching blocks", () =>
rpl(doc(p("one"), p("two")),
doc(h1("H")),
doc(p("onHwo"))))
it("can merge a nested node", () =>
rpl(doc(blockquote(blockquote(p("one"), p("two")))),
doc(p("H")),
doc(blockquote(blockquote(p("onHwo"))))))
it("can replace within a block", () =>
rpl(doc(blockquote(p("abcd"))),
doc(p("xyz")),
doc(blockquote(p("ayd")))))
it("can insert a lopsided slice", () =>
rpl(doc(blockquote(blockquote(p("one"), p("two"), "", p("three")))),
doc(blockquote(p("aaaa"), p("bb"), p("cc"), "", p("dd"))),
doc(blockquote(blockquote(p("onaa"), p("bb"), p("cc"), p("three"))))))
it("can insert a deep, lopsided slice", () =>
rpl(doc(blockquote(blockquote(p("one"), p("two"), p("three")), "", p("x"))),
doc(blockquote(p("aaaa"), p("bb"), p("cc")), "", p("dd")),
doc(blockquote(blockquote(p("onaa"), p("bb"), p("cc")), p("x")))))
it("can merge multiple levels", () =>
rpl(doc(blockquote(blockquote(p("hello"))), blockquote(blockquote(p("a")))),
null,
doc(blockquote(blockquote(p("hella"))))))
it("can merge multiple levels while inserting", () =>
rpl(doc(blockquote(blockquote(p("hello"))), blockquote(blockquote(p("a")))),
doc(p("i")),
doc(blockquote(blockquote(p("hellia"))))))
it("can insert a split", () =>
rpl(doc(p("foobar")),
doc(p("x"), p("y")),
doc(p("foox"), p("ybar"))))
it("can insert a deep split", () =>
rpl(doc(blockquote(p("fooxbar"))),
doc(blockquote(p("x")), blockquote(p("y"))),
doc(blockquote(p("foox")), blockquote(p("ybar")))))
it("can add a split one level up", () =>
rpl(doc(blockquote(p("foou"), p("vbar"))),
doc(blockquote(p("x")), blockquote(p("y"))),
doc(blockquote(p("foox")), blockquote(p("ybar")))))
it("keeps the node type of the left node", () =>
rpl(doc(h1("foobar"), ""),
doc(p("foobaz"), ""),
doc(h1("foobaz"))))
it("keeps the node type even when empty", () =>
rpl(doc(h1("bar"), ""),
doc(p("foobaz"), ""),
doc(h1("baz"))))
function bad(doc, insert, pattern) {
let slice = insert ? insert.slice(insert.tag.a, insert.tag.b) : Slice.empty
ist.throws(() => doc.replace(doc.tag.a, doc.tag.b, slice), new RegExp(pattern, "i"))
}
it("doesn't allow the left side to be too deep", () =>
bad(doc(p("")),
doc(blockquote(p("")), ""),
"deeper"))
it("doesn't allow a depth mismatch", () =>
bad(doc(p("")),
doc("", p("")),
"inconsistent"))
it("rejects a bad fit", () =>
bad(doc(""),
doc(p("foo")),
"invalid content"))
it("rejects unjoinable content", () =>
bad(doc(ul(li(p("a")), ""), ""),
doc(p("foo", ""), ""),
"cannot join"))
it("rejects an unjoinable delete", () =>
bad(doc(blockquote(p("a"), ""), ul("", li(p("b")))),
null,
"cannot join"))
it("check content validity", () =>
bad(doc(blockquote("", p("hi")), ""),
doc(blockquote("hi", ""), ""),
"invalid content"))
})
})
node-prosemirror-model-1.16.1+~cs1.1.5/test/test-resolve.js 0000664 0000000 0000000 00000004733 14207620105 0023343 0 ustar 00root root 0000000 0000000 const {doc, p, em, blockquote} = require("prosemirror-test-builder")
const ist = require("ist")
const testDoc = doc(p("ab"), blockquote(p(em("cd"), "ef")))
const _doc = {node: testDoc, start: 0, end: 12}
const _p1 = {node: testDoc.child(0), start: 1, end: 3}
const _blk = {node: testDoc.child(1), start: 5, end: 11}
const _p2 = {node: _blk.node.child(0), start: 6, end: 10}
describe("Node", () => {
describe("resolve", () => {
it("should reflect the document structure", () => {
let expected = {
0: [_doc, 0, null, _p1.node],
1: [_doc, _p1, 0, null, "ab"],
2: [_doc, _p1, 1, "a", "b"],
3: [_doc, _p1, 2, "ab", null],
4: [_doc, 4, _p1.node, _blk.node],
5: [_doc, _blk, 0, null, _p2.node],
6: [_doc, _blk, _p2, 0, null, "cd"],
7: [_doc, _blk, _p2, 1, "c", "d"],
8: [_doc, _blk, _p2, 2, "cd", "ef"],
9: [_doc, _blk, _p2, 3, "e", "f"],
10: [_doc, _blk, _p2, 4, "ef", null],
11: [_doc, _blk, 6, _p2.node, null],
12: [_doc, 12, _blk.node, null]
}
for (let pos = 0; pos <= testDoc.content.size; pos++) {
let $pos = testDoc.resolve(pos), exp = expected[pos]
ist($pos.depth, exp.length - 4)
for (let i = 0; i < exp.length - 3; i++) {
ist($pos.node(i).eq(exp[i].node))
ist($pos.start(i), exp[i].start)
ist($pos.end(i), exp[i].end)
if (i) {
ist($pos.before(i), exp[i].start - 1)
ist($pos.after(i), exp[i].end + 1)
}
}
ist($pos.parentOffset, exp[exp.length - 3])
let before = $pos.nodeBefore, eBefore = exp[exp.length - 2]
ist(typeof eBefore == "string" ? before.textContent : before, eBefore)
let after = $pos.nodeAfter, eAfter = exp[exp.length - 1]
ist(typeof eAfter == "string" ? after.textContent : after, eAfter)
}
})
it("has a working posAtIndex method", () => {
let d = doc(blockquote(p("one"), blockquote(p("two ", em("three")), p("four"))))
let pThree = d.resolve(12) // Start of em("three")
ist(pThree.posAtIndex(0), 8)
ist(pThree.posAtIndex(1), 12)
ist(pThree.posAtIndex(2), 17)
ist(pThree.posAtIndex(0, 2), 7)
ist(pThree.posAtIndex(1, 2), 18)
ist(pThree.posAtIndex(2, 2), 24)
ist(pThree.posAtIndex(0, 1), 1)
ist(pThree.posAtIndex(1, 1), 6)
ist(pThree.posAtIndex(2, 1), 25)
ist(pThree.posAtIndex(0, 0), 0)
ist(pThree.posAtIndex(1, 0), 26)
})
})
})
node-prosemirror-model-1.16.1+~cs1.1.5/test/test-slice.js 0000664 0000000 0000000 00000006115 14207620105 0022757 0 ustar 00root root 0000000 0000000 const {doc, p, li, ul, em, a, blockquote} = require("prosemirror-test-builder")
const ist = require("ist")
describe("Node", () => {
describe("slice", () => {
function t(doc, expect, openStart, openEnd) {
let slice = doc.slice(doc.tag.a || 0, doc.tag.b)
ist(slice.content.eq(expect.content))
ist(slice.openStart, openStart)
ist(slice.openEnd, openEnd)
}
it("can cut half a paragraph", () =>
t(doc(p("hello world")), doc(p("hello")), 0, 1))
it("can cut to the end of a pragraph", () =>
t(doc(p("hello")), doc(p("hello")), 0, 1))
it("leaves off extra content", () =>
t(doc(p("hello world"), p("rest")), doc(p("hello")), 0, 1))
it("preserves styles", () =>
t(doc(p("hello ", em("WORLD"))), doc(p("hello ", em("WOR"))), 0, 1))
it("can cut multiple blocks", () =>
t(doc(p("a"), p("b")), doc(p("a"), p("b")), 0, 1))
it("can cut to a top-level position", () =>
t(doc(p("a"), "", p("b")), doc(p("a")), 0, 0))
it("can cut to a deep position", () =>
t(doc(blockquote(ul(li(p("a")), li(p("b"))))),
doc(blockquote(ul(li(p("a")), li(p("b"))))), 0, 4))
it("can cut everything after a position", () =>
t(doc(p("hello world")), doc(p(" world")), 1, 0))
it("can cut from the start of a textblock", () =>
t(doc(p("hello")), doc(p("hello")), 1, 0))
it("leaves off extra content before", () =>
t(doc(p("foo"), p("barbaz")), doc(p("baz")), 1, 0))
it("preserves styles after cut", () =>
t(doc(p("a sentence with an ", em("emphasized ", a("link")), " in it")),
doc(p(em(a("nk")), " in it")), 1, 0))
it("preserves styles started after cut", () =>
t(doc(p("a ", em("sentence"), " with ", em("text"), " in it")),
doc(p("th ", em("text"), " in it")), 1, 0))
it("can cut from a top-level position", () =>
t(doc(p("a"), "", p("b")), doc(p("b")), 0, 0))
it("can cut from a deep position", () =>
t(doc(blockquote(ul(li(p("a")), li(p("b"))))),
doc(blockquote(ul(li(p("b"))))), 4, 0))
it("can cut part of a text node", () =>
t(doc(p("hello world")), p("o wo"), 0, 0))
it("can cut across paragraphs", () =>
t(doc(p("one"), p("two")), doc(p("e"), p("t")), 1, 1))
it("can cut part of marked text", () =>
t(doc(p("here's nothing and ", em("here's em"))),
p("ing and ", em("here's e")), 0, 0))
it("can cut across different depths", () =>
t(doc(ul(li(p("hello")), li(p("world")), li(p("x"))), p(em("boo"))),
doc(ul(li(p("rld")), li(p("x"))), p(em("bo"))), 3, 1))
it("can cut between deeply nested nodes", () =>
t(doc(blockquote(p("foobar"), ul(li(p("a")), li(p("b"), "", p("c"))), p("d"))),
blockquote(p("bar"), ul(li(p("a")), li(p("b")))), 1, 2))
it("can include parents", () => {
let d = doc(blockquote(p("foo"), p("bar")))
let slice = d.slice(d.tag.a, d.tag.b, true)
ist(slice.toString(), '(2,2)')
})
})
})
one
two
", doc(blockquote(p("woo ", em("hooo")))))) it("removes whitespace after a hard break", recover("woo \n hooo
hello
\n world
foo", doc(pre("foo\nbar")))) it("finds a valid place for invalid content", recover("
bar
- hi
- again
whoah
hello
bye
",
doc(p("hello"), hr, p("bye"))))
it("doesn't ignore whitespace-only text nodes",
recover("bye
one two
", doc(p(em("one"), " ", strong("two"))))) it("can handle stray tab characters", recover("", doc(p()))) it("normalizes random spaces", recover("
1
", doc(p(strong("1"))))) it("can parse an empty code block", recover("", doc(pre()))) it("preserves trailing space in a code block", recover("foo\n", doc(pre("foo\n")))) it("normalizes newlines when preserving whitespace", recover("
foo bar\nbaz
", doc(p("foo bar baz")), {preserveWhitespace: true})) it("ignores !", doc(p("hello!")))) it("can handle a head/body input structure", recover("A big strong monster.
", doc(p("A ", strong("big strong monster"), ".")))) it("interprets font-style: italic as em", recover("Hello!
", doc(p(em("Hello"), "!")))) it("interprets font-weight: bold as strong", recover("Hello
", doc(p(strong("Hello"))))) it("ignores unknown inline tags", recover("abc
", doc(p("abc")))) it("can add marks specified before their parent node is opened", recover("hi you", doc(p(em("hi"), " you")))) it("keeps applying a mark for the all of the node's content", recover("xxbar
", doc(p(strong("xxbar"))))) it("doesn't ignore whitespace-only nodes in preserveWhitespace full mode", recover(" x", doc(p(" x")), {preserveWhitespace: "full"})) function parse(html, options, doc) { return () => { let dom = document.createElement("div") dom.innerHTML = html let result = parser.parse(dom, options) ist(result, doc, eq) } } it("accepts the topNode option", parse("- x
foo
bar
bar
", ["foo", p("bar")], 0, 1)) it("will open all the way to the inner nodes", open("- foo
- bar
- a
foo
bar
foo
bar
",
[p("foo"), p(em("bar"))], 1, 1))
it("will not apply invalid marks to nodes",
open("- foo
- foo
- bar
foobarbaz
", [p(strong("foobarbaz"))], 1, 1)) it("drops block-level whitespace", open("ooo
ooo
hello
", doc(p("hello")))) it("can find a position at the end of a paragraph", find("hello
", doc(p("hello")))) it("can find a position inside text", find("hello
", doc(p("hello")))) it("can find a position inside an ignored node", find("hi
ok
", doc(p("hi"), "", p("ok")))) it("can find a position between nodes", find("- foo
- bar
hi
", doc("", p("hi")))) it("can find a position at the end of the document", find("hi
", doc(p("hi"), ""))) let quoteSchema = new Schema({nodes: schema.spec.nodes, marks: schema.spec.marks, topNode: "blockquote"}) it("uses a custom top node when parsing", test(quoteSchema.node("blockquote", null, quoteSchema.node("paragraph", null, quoteSchema.text("hello"))), "hello
")) function contextParser(context) { return new DOMParser(schema, [{tag: "foo", node: "horizontal_rule", context}].concat(DOMParser.schemaRules(schema))) } it("recognizes context restrictions", () => { ist(contextParser("blockquote/").parse(domFrom("")), doc(blockquote(hr, p())), eq) }) it("accepts group names in contexts", () => { ist(contextParser("block/").parse(domFrom("
")), doc(blockquote(hr, p())), eq) }) it("understands nested context restrictions", () => { ist(contextParser("blockquote/ordered_list//") .parse(domFrom("
")), doc(blockquote(ol(li(p("a"), hr)))), eq) }) it("understands double slashes in context restrictions", () => { ist(contextParser("blockquote//list_item/") .parse(domFrom("
a
")), doc(blockquote(ol(li(p("a"), hr)))), eq) }) it("understands pipes in context restrictions", () => { ist(contextParser("list_item/|blockquote/") .parse(domFrom("
a
a
"), { topNode: blockquote(), context: cxDoc.resolve(cxDoc.tag.a) }), blockquote(blockquote(hr)), eq) }) it("uses the passed context when parsing a slice", () => { let cxDoc = doc(blockquote("", hr)) ist(contextParser("doc//blockquote/").parseSlice(domFrom("
one
two
one
one
")), doc(p(em(strong("one")))), eq) }) it("doesn't get confused by nested mark tags", recover("AB
C",
doc(p(strong("A"), "B"), p("C"))))
})
describe("schemaRules", () => {
it("defaults to schema order", () => {
let schema = new Schema({
marks: {em: {parseDOM: [{tag: "i"}, {tag: "em"}]}},
nodes: {doc: {content: "inline*"},
text: {group: "inline"},
foo: {group: "inline", inline: true, parseDOM: [{tag: "foo"}]},
bar: {group: "inline", inline: true, parseDOM: [{tag: "bar"}]}}
})
ist(DOMParser.schemaRules(schema).map(r => r.tag).join(" "), "i em foo bar")
})
it("understands priority", () => {
let schema = new Schema({
marks: {em: {parseDOM: [{tag: "i", priority: 40}, {tag: "em", priority: 70}]}},
nodes: {doc: {content: "inline*"},
text: {group: "inline"},
foo: {group: "inline", inline: true, parseDOM: [{tag: "foo"}]},
bar: {group: "inline", inline: true, parseDOM: [{tag: "bar", priority: 60}]}}
})
ist(DOMParser.schemaRules(schema).map(r => r.tag).join(" "), "em bar foo i")
})
function nsParse(doc, namespace) {
let schema = new Schema({
nodes: {doc: {content: "h*"}, text: {},
h: {parseDOM: [{tag: "h", namespace}]}}
})
return DOMParser.fromSchema(schema).parse(doc)
}
it("includes nodes when namespace is correct", () => {
let doc = xmlDocument.createElement("doc")
let h = xmlDocument.createElementNS("urn:ns", "h")
doc.appendChild(h)
ist(nsParse(doc, "urn:ns").childCount, 1)
})
it("excludes nodes when namespace is wrong", () => {
let doc = xmlDocument.createElement("doc")
let h = xmlDocument.createElementNS("urn:nt", "h")
doc.appendChild(h)
ist(nsParse(doc, "urn:ns").childCount, 0)
})
it("excludes nodes when namespace is absent", () => {
let doc = xmlDocument.createElement("doc")
// in HTML documents, createElement gives namespace
// 'http://www.w3.org/1999/xhtml' so use createElementNS
let h = xmlDocument.createElementNS(null, "h")
doc.appendChild(h)
ist(nsParse(doc, "urn:ns").childCount, 0)
})
it("excludes nodes when namespace is wrong and xhtml", () => {
let doc = xmlDocument.createElement("doc")
let h = xmlDocument.createElementNS("urn:nt", "h")
doc.appendChild(h)
ist(nsParse(doc, "http://www.w3.org/1999/xhtml").childCount, 0)
})
it("excludes nodes when namespace is wrong and empty", () => {
let doc = xmlDocument.createElement("doc")
let h = xmlDocument.createElementNS("urn:nt", "h")
doc.appendChild(h)
ist(nsParse(doc, "").childCount, 0)
})
it("includes nodes when namespace is correct and empty", () => {
let doc = xmlDocument.createElement("doc")
let h = xmlDocument.createElementNS(null, "h")
doc.appendChild(h)
ist(nsParse(doc, null).childCount, 1)
})
})
})
describe("DOMSerializer", () => {
let noEm = new DOMSerializer(serializer.nodes, Object.assign({}, serializer.marks, {em: null}))
it("can omit a mark", () => {
ist(noEm.serializeNode(p("foo", em("bar"), strong("baz")), {document}).innerHTML,
"foobarbaz")
})
it("doesn't split other marks for omitted marks", () => {
ist(noEm.serializeNode(p("foo", code("bar"), em(code("baz"), "quux"), "xyz"), {document}).innerHTML,
"foobarbazquuxxyz")
})
it("can render marks with complex structure", () => {
let deepEm = new DOMSerializer(serializer.nodes, Object.assign({}, serializer.marks, {
em() { return ["em", ["i", {"data-emphasis": true}, 0]] }
}))
ist(deepEm.serializeNode(p(strong("foo", code("bar"), em(code("baz"))), em("quux"), "xyz"), {document}).innerHTML,
"foobarbazquuxxyz")
})
})
node-prosemirror-model-1.16.1+~cs1.1.5/test/test-mark.js 0000664 0000000 0000000 00000015441 14207620105 0022614 0 ustar 00root root 0000000 0000000 const {Mark, Schema} = require("..")
const {schema, doc, p, em, a} = require("prosemirror-test-builder")
const ist = require("ist")
let em_ = schema.mark("em")
let strong = schema.mark("strong")
let link = (href, title) => schema.mark("link", {href, title})
let code = schema.mark("code")
let customSchema = new Schema({
nodes: {doc: {content: "paragraph+"}, paragraph: {content: "text*"}, text: {}},
marks: {
remark: {attrs: {id: {}}, excludes: "", inclusive: false},
user: {attrs: {id: {}}, excludes: "_"},
strong: {excludes: "em-group"},
em: {group: "em-group"}
}
}), custom = customSchema.marks
let remark1 = custom.remark.create({id: 1}), remark2 = custom.remark.create({id: 2}),
user1 = custom.user.create({id: 1}), user2 = custom.user.create({id: 2}),
customEm = custom.em.create(), customStrong = custom.strong.create()
describe("Mark", () => {
describe("sameSet", () => {
it("returns true for two empty sets", () => ist(Mark.sameSet([], [])))
it("returns true for simple identical sets", () =>
ist(Mark.sameSet([em_, strong], [em_, strong])))
it("returns false for different sets", () =>
ist(!Mark.sameSet([em_, strong], [em_, code])))
it("returns false when set size differs", () =>
ist(!Mark.sameSet([em_, strong], [em_, strong, code])))
it("recognizes identical links in set", () =>
ist(Mark.sameSet([link("http://foo"), code], [link("http://foo"), code])))
it("recognizes different links in set", () =>
ist(!Mark.sameSet([link("http://foo"), code], [link("http://bar"), code])))
})
describe("eq", () => {
it("considers identical links to be the same", () =>
ist(link("http://foo").eq(link("http://foo"))))
it("considers different links to differ", () =>
ist(!link("http://foo").eq(link("http://bar"))))
it("considers links with different titles to differ", () =>
ist(!link("http://foo", "A").eq(link("http://foo", "B"))))
})
describe("addToSet", () => {
it("can add to the empty set", () =>
ist(em_.addToSet([]), [em_], Mark.sameSet))
it("is a no-op when the added thing is in set", () =>
ist(em_.addToSet([em_]), [em_], Mark.sameSet))
it("adds marks with lower rank before others", () =>
ist(em_.addToSet([strong]), [em_, strong], Mark.sameSet))
it("adds marks with higher rank after others", () =>
ist(strong.addToSet([em_]), [em_, strong], Mark.sameSet))
it("replaces different marks with new attributes", () =>
ist(link("http://bar").addToSet([link("http://foo"), em_]),
[link("http://bar"), em_], Mark.sameSet))
it("does nothing when adding an existing link", () =>
ist(link("http://foo").addToSet([em_, link("http://foo")]),
[em_, link("http://foo")], Mark.sameSet))
it("puts code marks at the end", () =>
ist(code.addToSet([em_, strong, link("http://foo")]),
[em_, strong, link("http://foo"), code], Mark.sameSet))
it("puts marks with middle rank in the middle", () =>
ist(strong.addToSet([em_, code]), [em_, strong, code], Mark.sameSet))
it("allows nonexclusive instances of marks with the same type", () =>
ist(remark2.addToSet([remark1]), [remark1, remark2], Mark.sameSet))
it("doesn't duplicate identical instances of nonexclusive marks", () =>
ist(remark1.addToSet([remark1]), [remark1], Mark.sameSet))
it("clears all others when adding a globally-excluding mark", () =>
ist(user1.addToSet([remark1, customEm]), [user1], Mark.sameSet))
it("does not allow adding another mark to a globally-excluding mark", () =>
ist(customEm.addToSet([user1]), [user1], Mark.sameSet))
it("does overwrite a globally-excluding mark when adding another instance", () =>
ist(user2.addToSet([user1]), [user2], Mark.sameSet))
it("doesn't add anything when another mark excludes the added mark", () =>
ist(customEm.addToSet([remark1, customStrong]), [remark1, customStrong], Mark.sameSet))
it("remove excluded marks when adding a mark", () =>
ist(customStrong.addToSet([remark1, customEm]), [remark1, customStrong], Mark.sameSet))
})
describe("removeFromSet", () => {
it("is a no-op for the empty set", () =>
ist(Mark.sameSet(em_.removeFromSet([]), [])))
it("can remove the last mark from a set", () =>
ist(Mark.sameSet(em_.removeFromSet([em_]), [])))
it("is a no-op when the mark isn't in the set", () =>
ist(Mark.sameSet(strong.removeFromSet([em_]), [em_])))
it("can remove a mark with attributes", () =>
ist(Mark.sameSet(link("http://foo").removeFromSet([link("http://foo")]), [])))
it("doesn't remove a mark when its attrs differ", () =>
ist(Mark.sameSet(link("http://foo", "title").removeFromSet([link("http://foo")]),
[link("http://foo")])))
})
describe("ResolvedPos.marks", () => {
function isAt(doc, mark, result) {
ist(mark.isInSet(doc.resolve(doc.tag.a).marks()), result)
}
it("recognizes a mark exists inside marked text", () =>
isAt(doc(p(em("foo"))), em_, true))
it("recognizes a mark doesn't exist in non-marked text", () =>
isAt(doc(p(em("foo"))), strong, false))
it("considers a mark active after the mark", () =>
isAt(doc(p(em("hi"), " there")), em_, true))
it("considers a mark inactive before the mark", () =>
isAt(doc(p("one ", em("two"))), em_, false))
it("considers a mark active at the start of the textblock", () =>
isAt(doc(p(em("one"))), em_, true))
it("notices that attributes differ", () =>
isAt(doc(p(a("link"))), link("http://baz"), false))
let customDoc = customSchema.node("doc", null, [
customSchema.node("paragraph", null, [ // pos 1
customSchema.text("one", [remark1, customStrong]), customSchema.text("two")
]),
customSchema.node("paragraph", null, [ // pos 9
customSchema.text("one"), customSchema.text("two", [remark1]), customSchema.text("three", [remark1])
]), // pos 22
customSchema.node("paragraph", null, [
customSchema.text("one", [remark2]), customSchema.text("two", [remark1])
])
])
it("omits non-inclusive marks at end of mark", () =>
ist(Mark.sameSet(customDoc.resolve(4).marks(), [customStrong])))
it("includes non-inclusive marks inside a text node", () =>
ist(Mark.sameSet(customDoc.resolve(3).marks(), [remark1, customStrong])))
it("omits non-inclusive marks at the end of a line", () =>
ist(Mark.sameSet(customDoc.resolve(20).marks(), [])))
it("includes non-inclusive marks between two marked nodes", () =>
ist(Mark.sameSet(customDoc.resolve(15).marks(), [remark1])))
it("excludes non-inclusive marks at a point where mark attrs change", () =>
ist(Mark.sameSet(customDoc.resolve(25).marks(), [])))
})
})
node-prosemirror-model-1.16.1+~cs1.1.5/test/test-node.js 0000664 0000000 0000000 00000013307 14207620105 0022606 0 ustar 00root root 0000000 0000000 const ist = require("ist")
const {Fragment, Schema} = require("..")
const {schema, eq, doc, blockquote, p, li, ul, em, strong, code, a, br, hr, img} = require("prosemirror-test-builder")
let customSchema = new Schema({
nodes: {
doc: {content: "paragraph+"},
paragraph: {content: "text*"},
text: { toDebugString() { return 'custom_text' } },
hard_break: { toDebugString() { return 'custom_hard_break' } }
},
})
describe("Node", () => {
describe("toString", () => {
it("nests", () => {
ist(doc(ul(li(p("hey"), p()), li(p("foo")))).toString(),
'doc(bullet_list(list_item(paragraph("hey"), paragraph), list_item(paragraph("foo"))))')
})
it("shows inline children", () => {
ist(doc(p("foo", img, br, "bar")).toString(),
'doc(paragraph("foo", image, hard_break, "bar"))')
})
it("shows marks", () => {
ist(doc(p("foo", em("bar", strong("quux")), code("baz"))).toString(),
'doc(paragraph("foo", em("bar"), em(strong("quux")), code("baz")))')
})
})
describe("cut", () => {
function cut(doc, cut) {
ist(doc.cut(doc.tag.a || 0, doc.tag.b), cut, eq)
}
it("extracts a full block", () =>
cut(doc(p("foo"), "", p("bar"), "", p("baz")),
doc(p("bar"))))
it("cuts text", () =>
cut(doc(p("0"), p("foobarbaz"), p("2")),
doc(p("bar"))))
it("cuts deeply", () =>
cut(doc(blockquote(ul(li(p("a"), p("bc")), li(p("d")), "", li(p("e"))), p("3"))),
doc(blockquote(ul(li(p("c")), li(p("d")))))))
it("works from the left", () =>
cut(doc(blockquote(p("foobar"))),
doc(blockquote(p("foo")))))
it("works to the right", () =>
cut(doc(blockquote(p("foobar"))),
doc(blockquote(p("bar")))))
it("preserves marks", () =>
cut(doc(p("foo", em("bar", img, strong("baz"), br), "quux", code("xyz"))),
doc(p(em("r", img, strong("baz"), br), "qu"))))
})
describe("between", () => {
function between(doc, ...nodes) {
let i = 0
doc.nodesBetween(doc.tag.a, doc.tag.b, (node, pos) => {
if (i == nodes.length)
throw new Error("More nodes iterated than listed (" + node.type.name + ")")
let compare = node.isText ? node.text : node.type.name
if (compare != nodes[i++])
throw new Error("Expected " + JSON.stringify(nodes[i - 1]) + ", got " + JSON.stringify(compare))
if (!node.isText && doc.nodeAt(pos) != node)
throw new Error("Pos " + pos + " does not point at node " + node + " " + doc.nodeAt(pos))
})
}
it("iterates over text", () =>
between(doc(p("foobarbaz")),
"paragraph", "foobarbaz"))
it("descends multiple levels", () =>
between(doc(blockquote(ul(li(p("foo")), p("b"), ""), p("c"))),
"blockquote", "bullet_list", "list_item", "paragraph", "foo", "paragraph", "b"))
it("iterates over inline nodes", () =>
between(doc(p(em("x"), "foo", em("bar", img, strong("baz"), br), "quux", code("xyz"))),
"paragraph", "foo", "bar", "image", "baz", "hard_break", "quux", "xyz"))
})
describe("textBetween", () => {
it("works when passing a custom function as leafText", () => {
const d = doc(p("foo", img, br))
ist(d.textBetween(0, d.content.size, '', (node) => {
if (node.type.name === 'image') {
return '
two
three