Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
import { describe, expect, test } from "vitest";
import { type Prop, type Props } from "@webstudio-is/sdk";
import { componentMetas } from "@webstudio-is/sdk-components-registry/metas";
import {
createTemplateComponentFixture,
expression,
renderData,
ws,
} from "@webstudio-is/template";
import {
canHaveTextContent,
findClosestContainer,
findClosestNonTextualContainer,
findClosestRichText,
isRichTextTree,
isTreeSatisfyingContentModel,
} from "./content-model";
const Body = createTemplateComponentFixture("Body");
const BlockTemplate = createTemplateComponentFixture("ws:block-template");
const Bold = createTemplateComponentFixture("Bold");
const Box = createTemplateComponentFixture("Box");
const CodeText = createTemplateComponentFixture("CodeText");
const Fragment = createTemplateComponentFixture("Fragment");
const HeadSlot = createTemplateComponentFixture("HeadSlot");
const HtmlEmbed = createTemplateComponentFixture("HtmlEmbed");
const Image = createTemplateComponentFixture("Image");
const Italic = createTemplateComponentFixture("Italic");
const JsonLd = createTemplateComponentFixture("JsonLd");
const Link = createTemplateComponentFixture("Link");
const Paragraph = createTemplateComponentFixture("Paragraph");
const Slot = createTemplateComponentFixture("Slot");
const Vimeo = createTemplateComponentFixture("Vimeo");
const VimeoSpinner = createTemplateComponentFixture("VimeoSpinner");
const XmlNode = createTemplateComponentFixture("XmlNode");
const defaultMetas = componentMetas;
test.each(["body", "templates", "list-item"])(
"validates template HTML independently when starting at %s",
(start) => {
const { instances, props } = renderData(
<ws.element ws:tag="body" ws:id="body">
<ws.block ws:id="block">
<BlockTemplate ws:id="templates">
<ws.element ws:tag="li" ws:id="list-item">
<ws.element ws:tag="p">Item</ws.element>
</ws.element>
</BlockTemplate>
</ws.block>
</ws.element>
);
const selector = ["list-item", "templates", "block", "body"];
expect(
isTreeSatisfyingContentModel({
instances,
props,
metas: defaultMetas,
instanceSelector: selector.slice(selector.indexOf(start)),
})
).toBe(true);
}
);
test.each(["list", "templates", "box", "paragraph"])(
"does not inherit a description-list parent into a template from %s",
(start) => {
const data = renderData(
<ws.element ws:tag="dl" ws:id="list">
<ws.block ws:id="block">
<BlockTemplate ws:id="templates">
<ws.element ws:tag="div" ws:id="box">
<ws.element ws:tag="p" ws:id="paragraph">
Content
</ws.element>
</ws.element>
</BlockTemplate>
</ws.block>
</ws.element>
);
const selector = ["paragraph", "box", "templates", "block", "list"];
expect(
isTreeSatisfyingContentModel({
...data,
metas: defaultMetas,
instanceSelector: selector.slice(selector.indexOf(start)),
})
).toBe(true);
}
);
test.each(["template", "body"])(
"still rejects invalid list nesting in %s content",
(location) => {
const invalid = <ws.element ws:tag="li" ws:id="invalid" />;
const { instances, props } = renderData(
<ws.element ws:tag="body" ws:id="body">
<ws.block>
<BlockTemplate>
{location === "template" ? (
<ws.element ws:tag="li">{invalid}</ws.element>
) : undefined}
</BlockTemplate>
{location === "body" ? invalid : undefined}
</ws.block>
</ws.element>
);
const errors: string[][] = [];
expect(
isTreeSatisfyingContentModel({
instances,
props,
metas: defaultMetas,
instanceSelector: ["body"],
onError: (_message, selector) => errors.push(selector),
})
).toBe(false);
expect(errors[0][0]).toBe("invalid");
}
);
test("checks direct text capability without promoting the outer rich-text root", () => {
const { instances, props } = renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="p" ws:id="paragraphId">
prefix
<ws.element ws:tag="span" ws:id="readingTimeId">
· reading time
</ws.element>
</ws.element>
<ws.element ws:tag="input" ws:id="inputId"></ws.element>
</ws.element>
);
expect(
canHaveTextContent({
instanceId: "readingTimeId",
instances,
props,
metas: defaultMetas,
})
).toBe(true);
expect(
canHaveTextContent({
instanceId: "paragraphId",
instances,
props,
metas: defaultMetas,
})
).toBe(true);
expect(
canHaveTextContent({
instanceId: "inputId",
instances,
props,
metas: defaultMetas,
})
).toBe(false);
});
test("support element with ws:tag", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span">
<ws.element ws:tag="article"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("support Box with ws:tag", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<Body ws:id="bodyId">
<Box ws:tag="span">
<Box ws:tag="article"></Box>
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("support legacy tag property", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<Body ws:id="bodyId">
<Box tag="span">
<Box tag="article"></Box>
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("flow accepts flow", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="article"></ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("none category accepted by parent by tag", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="ul">
<ws.element ws:tag="li"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
describe("description lists", () => {
test("does not accept an internal context marker as an HTML tag", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="dl" ws:id="listId">
<ws.element ws:tag="dl-child" />
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["listId"],
})
).toBe(false);
});
test.each([
["listId"],
["groupId", "listId"],
["termId", "groupId", "listId"],
["detailId", "groupId", "listId"],
])("accepts div groups when validating from %j", (...instanceSelector) => {
const errors: string[] = [];
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="dl" ws:id="listId">
<ws.element ws:tag="div" ws:id="groupId">
<ws.element ws:tag="dt" ws:id="termId">
Company
</ws.element>
<ws.element ws:tag="dd" ws:id="detailId">
XXX
</ws.element>
</ws.element>
<ws.element ws:tag="div">
<ws.element ws:tag="dt">Tax ID (NIP EU)</ws.element>
<ws.element ws:tag="dd">XXX</ws.element>
</ws.element>
<ws.element ws:tag="div">
<ws.element ws:tag="dt">Address</ws.element>
<ws.element ws:tag="dd">...</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector,
onError: (message) => errors.push(message),
})
).toBe(true);
expect(errors).toEqual([]);
});
test("accepts div groups through components without HTML tags", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="dl" ws:id="listId">
<Fragment>
<ws.element ws:tag="div">
<Slot>
<ws.element ws:tag="dt">Company</ws.element>
<ws.element ws:tag="dd">XXX</ws.element>
</Slot>
</ws.element>
</Fragment>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["listId"],
})
).toBe(true);
});
test("rejects flow content directly inside a description-list group", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="dl" ws:id="listId">
<ws.element ws:tag="div">
<ws.element ws:tag="p">Company</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["listId"],
})
).toBe(false);
});
test.each(["dt", "dd"])("keeps %s restricted to description lists", (tag) => {
for (const [ancestor, parent] of [
["div", "div"],
["dl", "div"],
["dl", "a"],
["dl", "section"],
]) {
const data = renderData(
<ws.element ws:tag={ancestor} ws:id="rootId">
<ws.element ws:tag={parent} ws:id="groupId">
<ws.element ws:tag="div" ws:id="wrapperId">
<ws.element ws:tag={tag} ws:id="childId">
XXX
</ws.element>
</ws.element>
</ws.element>
</ws.element>
);
expect(
isTreeSatisfyingContentModel({
...data,
metas: defaultMetas,
instanceSelector: ["childId", "wrapperId", "groupId", "rootId"],
})
).toBe(false);
}
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="dl" ws:id="listId">
<ws.element ws:tag="div">
<ws.element ws:tag={tag}>XXX</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["listId"],
})
).toBe(true);
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="dl" ws:id="listId">
<ws.element ws:tag="dt">Company</ws.element>
<ws.element ws:tag="dd">XXX</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["listId"],
})
).toBe(true);
});
});
test("none category prevents unacceptable parent", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="li"></ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="ul">
<ws.element ws:tag="div">
<ws.element ws:tag="li"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("slot without tag accepts transparent category", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="ul">
<Slot>
<Fragment>
<ws.element ws:tag="li"></ws.element>
</Fragment>
</Slot>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("collection without tag accepts transparent category", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="ul">
<ws.collection>
<ws.element ws:tag="li"></ws.element>
</ws.collection>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("transparent category accepts flow", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="a">
<ws.element ws:tag="article"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("transparent root element accepts flow without allowing interactive children", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="a" ws:id="linkId">
<ws.element ws:tag="p"></ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["linkId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="a" ws:id="linkId">
<ws.element ws:tag="button"></ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["linkId"],
})
).toBeFalsy();
});
test("phrasing category accepts element with transparent children", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span">
<ws.element ws:tag="a"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("transparent category should pass through phrasing category and forbid flow inside", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span">
<ws.element ws:tag="a">
<ws.element ws:tag="span"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span">
<ws.element ws:tag="a">
<ws.element ws:tag="article"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("transparent category should not pass through invalid parent", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="ul">
<ws.element ws:tag="a">
<ws.element ws:tag="li"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("reports the ancestor that introduces a transparent constraint", () => {
const messages: string[] = [];
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="ul" ws:id="listId">
<Slot>
<ws.element ws:tag="div" />
</Slot>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
onError: (message) => messages.push(message),
})
).toBeFalsy();
expect(messages).toEqual([
"Placing <div> element inside a <ul> violates HTML spec.",
]);
});
test("transparent category should pass through category when check deep in the tree", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span" ws:id="spanId">
<ws.element ws:tag="a" ws:id="linkId">
<ws.element ws:tag="strong"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["linkId", "spanId", "bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span" ws:id="spanId">
<ws.element ws:tag="a" ws:id="linkId">
<ws.element ws:tag="article"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["linkId", "spanId", "bodyId"],
})
).toBeFalsy();
});
test("restrict empty category", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="hr"></ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="hr">
<ws.element ws:tag="span"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("prevent nesting interactive instances", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="button">
<ws.element ws:tag="button"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="button">
<ws.element ws:tag="span">
<ws.element ws:tag="a"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("prevent nesting interactive instances with slots in between", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="button">
<Slot>
<Fragment>
<ws.element ws:tag="textarea"></ws.element>
</Fragment>
</Slot>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("prevent nesting interactive instances when check deep in the tree", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="button" ws:id="buttonId">
<ws.element ws:tag="span" ws:id="spanId">
<ws.element ws:tag="a" ws:id="linkId"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["linkId", "spanId", "buttonId", "bodyId"],
})
).toBeFalsy();
});
test("prevent nesting forms", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="form">
<ws.element ws:tag="button"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="form" ws:id="formId">
<ws.element ws:tag="div" ws:id="divId">
<ws.element ws:tag="form" ws:id="anotherFormId">
<ws.element ws:tag="button"></ws.element>
</ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["anotherFormId", "divId", "formId", "bodyId"],
})
).toBeFalsy();
});
test("allow wrapping labelable controls with label", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="label">
<ws.element ws:tag="span">
<ws.element ws:tag="input"></ws.element>
</ws.element>
</ws.element>
<ws.element ws:tag="label">
<ws.element ws:tag="span">
<ws.element ws:tag="button"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="label">
<ws.element ws:tag="span">
<ws.element ws:tag="a"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="label">
<ws.element ws:tag="button">
<ws.element ws:tag="input"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("edge case: allow inserting div where phrasing is required", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="button">
<ws.element ws:tag="div"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("edge case: support a > img", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="a">
<ws.element ws:tag="img"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("support video > source", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="video">
<ws.element ws:tag="source" />
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("support xml node with tags", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<XmlNode tag="url">
<XmlNode tag="loc"></XmlNode>
</XmlNode>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("support headings inside of summary", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="details">
<ws.element ws:tag="summary">
<ws.element ws:tag="h3"></ws.element>
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("support links inside of details", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="details">
<ws.element ws:tag="a"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
describe("component content model", () => {
test("accepts childless JSON-LD in page flow", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<JsonLd code='{"@context":"https://schema.org"}' />
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
});
test("accepts JSON-LD in Head Slot", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<HeadSlot ws:id="headSlotId">
<JsonLd code='{"@context":"https://schema.org"}' />
</HeadSlot>
),
metas: defaultMetas,
instanceSelector: ["headSlotId"],
})
).toBeTruthy();
});
test("restrict children with specific component", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<HtmlEmbed>
<ws.descendant />
</HtmlEmbed>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<HtmlEmbed>
<ws.element ws:tag="div" />
</HtmlEmbed>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("restrict components within specific ancestor", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<Vimeo>
<VimeoSpinner></VimeoSpinner>
</Vimeo>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<Vimeo>
<ws.element ws:tag="div">
<VimeoSpinner></VimeoSpinner>
</ws.element>
</Vimeo>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<VimeoSpinner></VimeoSpinner>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("pass constraints when check deep in the tree", () => {
expect(
isTreeSatisfyingContentModel({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<Vimeo ws:id="vimeoId">
<ws.element ws:tag="div" ws:id="divId">
<VimeoSpinner></VimeoSpinner>
</ws.element>
</Vimeo>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["divId", "vimeoId", "bodyId"],
})
).toBeTruthy();
});
});
describe("rich text tree", () => {
test("uses provided html tags index without scanning props", () => {
const { instances } = renderData(
<Paragraph ws:id="instanceId"></Paragraph>
);
const props = new (class extends Map<string, Prop> {
values(): MapIterator<Prop> {
throw new Error("props should not be scanned");
}
})() as Props;
expect(
isRichTextTree({
instances,
props,
metas: defaultMetas,
instanceId: "instanceId",
htmlTagsByInstanceId: new Map(),
})
).toBeTruthy();
});
test("reads updated tag props from mutable props maps", () => {
const { instances, props } = renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<ws.element ws:tag="article"></ws.element>
</Box>
</Body>
);
expect(
isTreeSatisfyingContentModel({
instances,
props,
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeTruthy();
props.set("tagPropId", {
id: "tagPropId",
instanceId: "boxId",
name: "tag",
type: "string",
value: "span",
});
expect(
isTreeSatisfyingContentModel({
instances,
props,
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toBeFalsy();
});
test("check empty instance is rich text", () => {
expect(
isRichTextTree({
...renderData(<Bold ws:id="instanceId"></Bold>),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeTruthy();
expect(
isRichTextTree({
...renderData(<HeadSlot ws:id="instanceId"></HeadSlot>),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeFalsy();
});
test("any instance with text can be edited", () => {
expect(
isRichTextTree({
...renderData(<HeadSlot ws:id="instanceId">my text</HeadSlot>),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeTruthy();
expect(
isRichTextTree({
...renderData(<HeadSlot ws:id="instanceId">{expression``}</HeadSlot>),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeTruthy();
});
test("does not edit mixed text and image as rich text", () => {
expect(
isRichTextTree({
...renderData(
<Paragraph ws:id="instanceId">
Heading <Image ws:id="imageId" />
</Paragraph>
),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeFalsy();
expect(
isRichTextTree({
...renderData(
<ws.element ws:tag="h2" ws:id="instanceId">
Heading <ws.element ws:tag="img" ws:id="imageId" />
</ws.element>
),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeFalsy();
});
test("rich text content tags can be edited", () => {
expect(
isRichTextTree({
...renderData(
<Bold ws:id="instanceId">
<Italic></Italic>
</Bold>
),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeTruthy();
});
test("rich text instances with rich text content can be edited", () => {
expect(
isRichTextTree({
...renderData(
<Paragraph ws:id="instanceId">
<Bold>bold</Bold>
</Paragraph>
),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeTruthy();
expect(
isRichTextTree({
...renderData(
<HeadSlot ws:id="instanceId">
<Bold>bold</Bold>
</HeadSlot>
),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeFalsy();
});
test("div with paragraph cannot be rich text", () => {
expect(
isRichTextTree({
...renderData(
<Box ws:id="instanceId">
<Paragraph></Paragraph>
</Box>
),
metas: defaultMetas,
instanceId: "instanceId",
})
).toBeFalsy();
});
test("finds closest rich text with rich text content", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="p" ws:id="paragraphId">
<ws.element ws:tag="b" ws:id="boldId"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["boldId", "paragraphId", "bodyId"],
})
).toEqual(["paragraphId", "bodyId"]);
});
test("finds closest rich text with rich text content", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="p" ws:id="paragraphId">
text
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["paragraphId", "bodyId"],
})
).toEqual(["paragraphId", "bodyId"]);
});
test("treat Link component as container when look for closest rich text", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span" ws:id="spanId">
<Link ws:id="linkId">
<Bold ws:id="boldId">link</Bold>
</Link>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["linkId", "spanId", "bodyId"],
})
).toEqual(["linkId", "spanId", "bodyId"]);
});
test("treat body as rich text when has text inside", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
text
<ws.element ws:tag="p" ws:id="paragraphId">
<ws.element ws:tag="b" ws:id="boldId"></ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["boldId", "paragraphId", "bodyId"],
})
).toEqual(["bodyId"]);
});
test("ignore <a> with <div> inside", () => {
const data = renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="a" ws:id="linkId">
<ws.element ws:tag="div" ws:id="divId"></ws.element>
</ws.element>
</ws.element>
);
expect(
findClosestRichText({
...data,
metas: defaultMetas,
instanceSelector: ["divId", "linkId", "bodyId"],
})
).toEqual(["divId", "linkId", "bodyId"]);
expect(
findClosestRichText({
...data,
metas: defaultMetas,
instanceSelector: ["linkId", "bodyId"],
})
).toEqual(undefined);
});
test("finds link rich text", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="div" ws:id="divId">
<ws.element ws:tag="a" ws:id="linkId">
my link
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["linkId", "divId", "bodyId"],
})
).toEqual(["linkId", "divId", "bodyId"]);
});
test("finds span rich text", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="div" ws:id="divId">
<ws.element ws:tag="span" ws:id="spanId">
my span
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["spanId", "divId", "bodyId"],
})
).toEqual(["spanId", "divId", "bodyId"]);
});
test("finds rich text with mixed children", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="div" ws:id="divId">
<ws.element ws:tag="span" ws:id="spanId">
my link
</ws.element>
<ws.element ws:tag="b" ws:id="boldId">
my link
</ws.element>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["spanId", "divId", "bodyId"],
})
).toEqual(["divId", "bodyId"]);
});
test("does not treat image component as rich text", () => {
expect(
findClosestRichText({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="div" ws:id="divId">
<Image ws:id="imgId" />
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["imgId", "divId", "bodyId"],
})
).toEqual(undefined);
});
});
describe("closest container", () => {
test("skips non-container instances", () => {
expect(
findClosestContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<Image ws:id="imageId" />
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["imageId", "boxId", "bodyId"],
})
).toEqual(["boxId", "bodyId"]);
});
test("allow containers with text", () => {
expect(
findClosestContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<Box ws:id="box-with-text">text</Box>
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["box-with-text", "boxId", "bodyId"],
})
).toEqual(["box-with-text", "boxId", "bodyId"]);
});
test("allow containers with expression", () => {
expect(
findClosestContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<Box ws:id="box-with-expr">{expression`1 + 1`}</Box>
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["box-with-expr", "boxId", "bodyId"],
})
).toEqual(["box-with-expr", "boxId", "bodyId"]);
});
test("allow root with text", () => {
expect(
findClosestContainer({
...renderData(<Body ws:id="bodyId">text</Body>),
metas: defaultMetas,
instanceSelector: ["bodyId"],
})
).toEqual(["bodyId"]);
});
});
describe("closest non textual container", () => {
test("skips image tag", () => {
expect(
findClosestNonTextualContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<Image ws:id="imageId" />
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["imageId", "boxId", "bodyId"],
})
).toEqual(["boxId", "bodyId"]);
});
test("skips CodeText component", () => {
expect(
findClosestNonTextualContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<CodeText ws:id="codeId" />
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["codeId", "boxId", "bodyId"],
})
).toEqual(["boxId", "bodyId"]);
});
test("skips containers with text", () => {
expect(
findClosestNonTextualContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<Box ws:id="box-with-text">text</Box>
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["box-with-text", "boxId", "bodyId"],
})
).toEqual(["boxId", "bodyId"]);
});
test("skips containers with expression", () => {
expect(
findClosestNonTextualContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<Box ws:id="box-with-expr">{expression`1 + 1`}</Box>
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["box-with-expr", "boxId", "bodyId"],
})
).toEqual(["boxId", "bodyId"]);
});
test("skips containers with rich text children", () => {
expect(
findClosestNonTextualContainer({
...renderData(
<Body ws:id="bodyId">
<Box ws:id="boxId">
<Box ws:id="box-with-bold">
<Bold ws:id="boldId"></Bold>
</Box>
</Box>
</Body>
),
metas: defaultMetas,
instanceSelector: ["box-with-bold", "boxId", "bodyId"],
})
).toEqual(["boxId", "bodyId"]);
});
test("allow root with text", () => {
expect(
findClosestNonTextualContainer({
...renderData(<Body ws:id="body">text</Body>),
metas: defaultMetas,
instanceSelector: ["body"],
})
).toEqual(["body"]);
});
test("matches empty div", () => {
expect(
findClosestNonTextualContainer({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="div" ws:id="divId"></ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["divId", "bodyId"],
})
).toEqual(["divId", "bodyId"]);
});
test("treat Link component as rich text container", () => {
expect(
findClosestNonTextualContainer({
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="span" ws:id="spanId">
<Link ws:id="linkId">
<Bold ws:id="boldId">link</Bold>
</Link>
</ws.element>
</ws.element>
),
metas: defaultMetas,
instanceSelector: ["boldId", "linkId", "spanId", "bodyId"],
})
).toEqual(["spanId", "bodyId"]);
});
});