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 { expect, test, describe } from "vitest";
import {
createTemplateComponentFixture,
css,
renderTemplate,
token,
ws,
} from "@webstudio-is/template";
import type { WebstudioFragment } from "@webstudio-is/sdk";
import { generateFragmentFromHtml as _generateFragmentFromHtml } from "./html";
const HtmlEmbed = createTemplateComponentFixture("HtmlEmbed");
const Image = createTemplateComponentFixture("Image");
// Wrapper that strips skippedSelectors for tests that only compare fragment shape
const generateFragmentFromHtml = (html: string) => {
const { skippedSelectors: _skipped, ...fragment } =
_generateFragmentFromHtml(html);
return fragment;
};
test("generate instances from html", () => {
expect(
generateFragmentFromHtml(`
<main>
<section>
<h1>It works!</h1>
<p>Webstudio is great.</p>
<ul>
<li>one</li>
<li>two</li>
</ul>
</section>
</main>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="main">
<ws.element ws:tag="section">
<ws.element ws:tag="h1">It works!</ws.element>
<ws.element ws:tag="p">Webstudio is great.</ws.element>
<ws.element ws:tag="ul">
<ws.element ws:tag="li">one</ws.element>
<ws.element ws:tag="li">two</ws.element>
</ws.element>
</ws.element>
</ws.element>
)
);
});
test("generate multiple root instances from html", () => {
expect(
generateFragmentFromHtml(`
<section>
<h1>One</h1>
</section>
<section>
<h1>Two</h1>
</section>
`)
).toEqual(
renderTemplate(
<>
<ws.element ws:tag="section">
<ws.element ws:tag="h1">One</ws.element>
</ws.element>
<ws.element ws:tag="section">
<ws.element ws:tag="h1">Two</ws.element>
</ws.element>
</>
)
);
});
test("handle broken html", () => {
expect(
generateFragmentFromHtml(`
<section>
<h1>One</h1>
</section attribute="value">
`)
).toEqual(
renderTemplate(
<>
<ws.element ws:tag="section">
<ws.element ws:tag="h1">One</ws.element>
</ws.element>
</>
)
);
});
test("handle non-html", () => {
expect(generateFragmentFromHtml("")).toEqual(renderTemplate(<></>));
expect(generateFragmentFromHtml("It works!")).toEqual(renderTemplate(<></>));
});
test("ignore custom elements", () => {
expect(
generateFragmentFromHtml(`
<custom-element>
<div></div>
</custom-element>
<section></section>
`)
).toEqual(renderTemplate(<ws.element ws:tag="section"></ws.element>));
});
test("ignore not allowed tags", () => {
expect(
generateFragmentFromHtml(`<div><marquee>test</marquee></div>`)
).toEqual(renderTemplate(<ws.element ws:tag="div"></ws.element>));
});
test("generate props from html attributes", () => {
expect(
generateFragmentFromHtml(`
<form action="/my-action">
<button class="my-button">My Button</button>
</form>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="form" action="/my-action">
<ws.element ws:tag="button" class="my-button">
My Button
</ws.element>
</ws.element>
)
);
});
test("generate props from number and boolean html attributes", () => {
expect(
generateFragmentFromHtml(`
<button autofocus tabindex="-1">My Button</button>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="button" autofocus={true} tabindex={-1}>
My Button
</ws.element>
)
);
});
test("generate props from number and boolean aria attributes", () => {
expect(
generateFragmentFromHtml(`
<button aria-expanded aria-valuemin="100">My Button</button>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="button" aria-expanded={true} aria-valuemin={100}>
My Button
</ws.element>
)
);
});
test("skip webstudio runtime attributes from pasted html", () => {
const fragment = generateFragmentFromHtml(`
<a
data-ws-tag="a"
href="#services"
data-ws-text-content="View solutions "
data-ws-id="V8q7r5rwOIOz7m_od3wi3"
data-ws-component="ws:element"
data-ws-selector="V8q7r5rwOIOz7m_od3wi3,BUSoEKIavhIKiBd1COmHZ"
>View solutions </a>
`);
expect(fragment.props).toEqual([
expect.objectContaining({ name: "href", value: "#services" }),
]);
expect(fragment.props.some((prop) => prop.name.startsWith("data-ws-"))).toBe(
false
);
expect(fragment.instances[0]).toEqual(
expect.objectContaining({
tag: "a",
children: [{ type: "text", value: "View solutions " }],
})
);
});
test("wrap text with span when spotted outside of rich text", () => {
expect(
generateFragmentFromHtml(`
<div>div<article>article</article></div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div">
<ws.element ws:tag="span">div</ws.element>
<ws.element ws:tag="article">article</ws.element>
</ws.element>
)
);
expect(
generateFragmentFromHtml(`
<div>div<b><br></b></div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div">
<ws.element ws:tag="span">div</ws.element>
<ws.element ws:tag="b">
<ws.element ws:tag="br"></ws.element>
</ws.element>
</ws.element>
)
);
});
test("do not wrap text with span when spotted near link", () => {
expect(
generateFragmentFromHtml(`
<div>div<a>link</a></div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div">
div
<ws.element ws:tag="a">link</ws.element>
</ws.element>
)
);
});
test("collapse any spacing characters inside text", () => {
expect(
generateFragmentFromHtml(`
<div>
line
another line
</div>
`)
).toEqual(
renderTemplate(<ws.element ws:tag="div">{"line another line"}</ws.element>)
);
});
test("collapse any spacing characters inside rich text", () => {
expect(
generateFragmentFromHtml(`
<div>
<i> line </i>
<b> another line </b>
text
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div">
<ws.element ws:tag="i">{"line "}</ws.element>
<ws.element ws:tag="b">another line</ws.element> text
</ws.element>
)
);
});
test("preserve leading space in inline element following text without trailing space", () => {
expect(generateFragmentFromHtml(`<h2>About<span> Us</span></h2>`)).toEqual(
renderTemplate(
<ws.element ws:tag="h2">
{"About"}
<ws.element ws:tag="span">{" Us"}</ws.element>
</ws.element>
)
);
});
test("generate style attribute as local styles", () => {
expect(
generateFragmentFromHtml(`
<div style="display: inline"></div>
`)
).toEqual(
renderTemplate(
<ws.element
ws:tag="div"
ws:style={css`
display: inline;
`}
></ws.element>
)
);
});
test("generate nested css math functions as unparsed local styles", () => {
const value =
"clamp(1rem, calc(1rem + (2rem - 1rem) * ((100vw - 20rem) / (80rem - 20rem))), 2rem)";
const fragment = generateFragmentFromHtml(`
<div style="font-size:${value}">One clamp div</div>
`);
expect(fragment.styles).toEqual(
expect.arrayContaining([
expect.objectContaining({
property: "fontSize",
value: {
type: "unparsed",
value:
"clamp(1rem,calc(1rem + (2rem - 1rem)*((100vw - 20rem)/(80rem - 20rem))),2rem)",
},
}),
])
);
});
test("script as html embed", () => {
expect(generateFragmentFromHtml(`<script>a;</script>`)).toEqual(
renderTemplate(
<HtmlEmbed
ws:label="Script"
clientOnly={true}
code={`<script>a;</script>`}
/>
)
);
});
test("style as html embed", () => {
expect(generateFragmentFromHtml(`<style>a;</style>`)).toEqual(
renderTemplate(<HtmlEmbed code={`<style>a;</style>`} ws:label="Style" />)
);
});
test("generate textarea element", () => {
expect(
generateFragmentFromHtml(`
<div>
<textarea>
my text
</textarea>
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div">
<ws.element ws:tag="textarea" value="my text" />
</ws.element>
)
);
});
test("generate select element", () => {
expect(
generateFragmentFromHtml(`
<div>
<select>
<option value="one">One</option>
<option value="two" selected>Two</option>
</select>
<select>
<option>One</option>
<option selected>Two</option>
</select>
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div">
<ws.element ws:tag="select" value="two">
<ws.element ws:tag="option" value="one">
One
</ws.element>
<ws.element ws:tag="option" value="two">
Two
</ws.element>
</ws.element>
<ws.element ws:tag="select" value="Two">
<ws.element ws:tag="option">One</ws.element>
<ws.element ws:tag="option">Two</ws.element>
</ws.element>
</ws.element>
)
);
});
test("generate Image component instead of img element", () => {
expect(
generateFragmentFromHtml(`
<div>
<img src="./my-url">
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div">
<Image src="./my-url" />
</ws.element>
)
);
});
test("strip unsupported attribute names", () => {
expect(
generateFragmentFromHtml(`
<button @click="open = true">Expand</button>
<button x-on:click="open = !open">
Toggle
</button>
`)
).toEqual(
renderTemplate(
<>
<ws.element ws:tag="button">Expand</ws.element>
<ws.element ws:tag="button" x-on:click="open = !open">
Toggle
</ws.element>
</>
)
);
});
describe("style tag to tokens", () => {
test("extract single class from style tag as token", () => {
const cardToken = token(
"card",
css`
display: flex;
`
);
expect(
generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<div class="card">Hello</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" ws:tokens={[cardToken]}>
Hello
</ws.element>
)
);
});
test("extract multiple classes from style tag as tokens", () => {
const cardToken = token(
"card",
css`
display: flex;
padding: 16px;
`
);
const titleToken = token(
"title",
css`
font-size: 24px;
font-weight: bold;
`
);
expect(
generateFragmentFromHtml(`
<style>
.card { display: flex; padding: 16px; }
.title { font-size: 24px; font-weight: bold; }
</style>
<div class="card">
<h1 class="title">Hello</h1>
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" ws:tokens={[cardToken]}>
<ws.element ws:tag="h1" ws:tokens={[titleToken]}>
Hello
</ws.element>
</ws.element>
)
);
});
test("reuse same token when class appears on multiple elements", () => {
const cardToken = token(
"card",
css`
display: flex;
`
);
expect(
generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<div class="card">
<section class="card">Hello</section>
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" ws:tokens={[cardToken]}>
<ws.element ws:tag="section" ws:tokens={[cardToken]}>
Hello
</ws.element>
</ws.element>
)
);
});
test("preserve unresolved class names as class prop", () => {
const cardToken = token(
"card",
css`
display: flex;
`
);
expect(
generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<div class="card external-lib">Hello</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" class="external-lib" ws:tokens={[cardToken]}>
Hello
</ws.element>
)
);
});
test("remove class prop entirely when all classes resolved to tokens", () => {
const fragment = generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<div class="card">Hello</div>
`);
expect(fragment.props.find((p) => p.name === "class")).toBeUndefined();
});
test("combine inline style attribute with class token", () => {
const fragment = generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<div class="card" style="color: red">Hello</div>
`);
const cardToken = fragment.styleSources.find(
(source) => source.type === "token" && source.name === "card"
);
expect(cardToken).toBeDefined();
expect(fragment.children).toEqual([{ type: "id", value: "0" }]);
expect(fragment.instances).toEqual([
{
type: "instance",
id: "0",
component: "ws:element",
tag: "div",
children: [{ type: "text", value: "Hello" }],
},
]);
expect(fragment.styleSourceSelections).toEqual([
{ instanceId: "0", values: [cardToken!.id, "0:ws:style"] },
]);
expect(fragment.styles).toEqual(
expect.arrayContaining([
{
styleSourceId: cardToken!.id,
breakpointId: "base",
property: "display",
value: { type: "keyword", value: "flex" },
},
{
styleSourceId: "0:ws:style",
breakpointId: "base",
property: "color",
value: { type: "keyword", value: "red" },
},
])
);
});
test("no html embed when all style rules are class rules", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { display: flex; }
.title { font-size: 24px; }
</style>
<div class="card">
<h1 class="title">Hello</h1>
</div>
`);
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
});
test("keep style tag as html embed when it has no class rules", () => {
expect(
generateFragmentFromHtml(`
<style>#hero { color: red; }</style>
<div>Hello</div>
`)
).toEqual(
renderTemplate(
<>
<HtmlEmbed
ws:label="Style"
code={`<style>#hero { color: red; }</style>`}
/>
<ws.element ws:tag="div">Hello</ws.element>
</>
)
);
});
test("extract class rules and keep remaining rules as html embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { display: flex; }
#hero { color: red; }
</style>
<div class="card">Hello</div>
`);
// token for .card should be created
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// remaining #hero rule should stay as HtmlEmbed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
const codeProp = fragment.props.find(
(p) => p.instanceId === htmlEmbed!.id && p.name === "code"
);
expect(codeProp).toBeDefined();
expect(codeProp!.type === "string" && codeProp!.value).toContain("#hero");
// class prop should not be set since .card was resolved
expect(fragment.props.find((p) => p.name === "class")).toBeUndefined();
});
test("extract classes from multiple style tags", () => {
const cardToken = token(
"card",
css`
display: flex;
`
);
const titleToken = token(
"title",
css`
font-size: 24px;
`
);
expect(
generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<style>.title { font-size: 24px; }</style>
<div class="card">
<h1 class="title">Hello</h1>
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" ws:tokens={[cardToken]}>
<ws.element ws:tag="h1" ws:tokens={[titleToken]}>
Hello
</ws.element>
</ws.element>
)
);
});
test("resolve nested selectors - descendant", () => {
const cardInnerToken = token(
"card__inner",
css`
color: red;
`
);
expect(
generateFragmentFromHtml(`
<style>.card .inner { color: red; }</style>
<div class="card">
<span class="inner">Hello</span>
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" class="card">
<ws.element ws:tag="span" ws:tokens={[cardInnerToken]}>
Hello
</ws.element>
</ws.element>
)
);
});
test("resolve nested selectors - child combinator", () => {
const parentChildToken = token(
"parent__child",
css`
margin: 0;
`
);
expect(
generateFragmentFromHtml(`
<style>.parent > .child { margin: 0; }</style>
<div class="parent"><span class="child">Hello</span></div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" class="parent">
<ws.element ws:tag="span" ws:tokens={[parentChildToken]}>
Hello
</ws.element>
</ws.element>
)
);
});
test("ignore element selectors in style tag", () => {
// element selectors like `div { }` should not become tokens
expect(
generateFragmentFromHtml(`
<style>div { color: red; }</style>
<div>Hello</div>
`)
).toEqual(
renderTemplate(
<>
<HtmlEmbed
ws:label="Style"
code={`<style>div { color: red; }</style>`}
/>
<ws.element ws:tag="div">Hello</ws.element>
</>
)
);
});
test("handle multiple classes on one element with multiple tokens", () => {
const cardToken = token(
"card",
css`
display: flex;
`
);
const largeToken = token(
"large",
css`
font-size: 32px;
`
);
expect(
generateFragmentFromHtml(`
<style>
.card { display: flex; }
.large { font-size: 32px; }
</style>
<div class="card large">Hello</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" ws:tokens={[cardToken, largeToken]}>
Hello
</ws.element>
)
);
});
test("handle class with multiple properties", () => {
const cardToken = token(
"card",
css`
display: flex;
gap: 16px;
padding: 24px;
border-radius: 8px;
`
);
expect(
generateFragmentFromHtml(`
<style>
.card {
display: flex;
gap: 16px;
padding: 24px;
border-radius: 8px;
}
</style>
<div class="card">Hello</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" ws:tokens={[cardToken]}>
Hello
</ws.element>
)
);
});
test("empty style tag produces no html embed", () => {
expect(
generateFragmentFromHtml(`
<style></style>
<div>Hello</div>
`)
).toEqual(renderTemplate(<ws.element ws:tag="div">Hello</ws.element>));
});
test("class attribute without any style tag stays as prop", () => {
// existing behavior: class is just a prop when no style tag is present
expect(
generateFragmentFromHtml(`
<div class="my-class">Hello</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" class="my-class">
Hello
</ws.element>
)
);
});
test("style tag with only whitespace produces no html embed", () => {
expect(
generateFragmentFromHtml(`
<style> </style>
<div>Hello</div>
`)
).toEqual(renderTemplate(<ws.element ws:tag="div">Hello</ws.element>));
});
test("extract token and apply to nested structure", () => {
const wrapperToken = token(
"wrapper",
css`
max-width: 1200px;
margin-left: auto;
margin-right: auto;
`
);
const gridToken = token(
"grid",
css`
display: grid;
gap: 16px;
`
);
const itemToken = token(
"item",
css`
padding: 8px;
`
);
expect(
generateFragmentFromHtml(`
<style>
.wrapper { max-width: 1200px; margin-left: auto; margin-right: auto; }
.grid { display: grid; gap: 16px; }
.item { padding: 8px; }
</style>
<div class="wrapper">
<div class="grid">
<div class="item">One</div>
<div class="item">Two</div>
<div class="item">Three</div>
</div>
</div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" ws:tokens={[wrapperToken]}>
<ws.element ws:tag="div" ws:tokens={[gridToken]}>
<ws.element ws:tag="div" ws:tokens={[itemToken]}>
One
</ws.element>
<ws.element ws:tag="div" ws:tokens={[itemToken]}>
Two
</ws.element>
<ws.element ws:tag="div" ws:tokens={[itemToken]}>
Three
</ws.element>
</ws.element>
</ws.element>
)
);
});
test("element with both resolved and unresolved classes plus inline style", () => {
const fragment = generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<div class="card external" style="color: red">Hello</div>
`);
const cardToken = fragment.styleSources.find(
(source) => source.type === "token" && source.name === "card"
);
expect(cardToken).toBeDefined();
expect(fragment.children).toEqual([{ type: "id", value: "0" }]);
expect(fragment.instances).toEqual([
{
type: "instance",
id: "0",
component: "ws:element",
tag: "div",
children: [{ type: "text", value: "Hello" }],
},
]);
expect(fragment.props).toEqual([
{
id: "0:class",
instanceId: "0",
name: "class",
type: "string",
value: "external",
},
]);
expect(fragment.styleSourceSelections).toEqual([
{ instanceId: "0", values: [cardToken!.id, "0:ws:style"] },
]);
expect(fragment.styles).toEqual(
expect.arrayContaining([
{
styleSourceId: cardToken!.id,
breakpointId: "base",
property: "display",
value: { type: "keyword", value: "flex" },
},
{
styleSourceId: "0:ws:style",
breakpointId: "base",
property: "color",
value: { type: "keyword", value: "red" },
},
])
);
});
test("token names preserve original class names", () => {
const fragment = generateFragmentFromHtml(`
<style>
.my-component { display: flex; }
.text-lg { font-size: 18px; }
.bg_primary { background-color: blue; }
</style>
<div class="my-component">
<span class="text-lg bg_primary">Hello</span>
</div>
`);
const tokenNames = fragment.styleSources
.filter((s) => s.type === "token")
.map((s) => (s as { name: string }).name);
expect(tokenNames).toContain("my-component");
expect(tokenNames).toContain("text-lg");
expect(tokenNames).toContain("bg_primary");
});
test("class defined in style tag but not used by any element", () => {
const fragment = generateFragmentFromHtml(`
<style>
.used { display: flex; }
.unused { color: red; }
</style>
<div class="used">Hello</div>
`);
// all class rules become tokens, even if not referenced by elements
const tokenNames = fragment.styleSources
.filter((s) => s.type === "token")
.map((s) => (s as { name: string }).name);
expect(tokenNames).toContain("used");
expect(tokenNames).toContain("unused");
// only "used" is assigned to the instance
const divInstance = fragment.instances.find((i) => i.tag === "div");
const sel = fragment.styleSourceSelections.find(
(s) => s.instanceId === divInstance?.id
);
const usedToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "used"
);
const unusedToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "unused"
);
expect(sel?.values).toContain(usedToken?.id);
expect(sel?.values).not.toContain(unusedToken?.id);
// no HtmlEmbed since all rules are class rules
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
});
test("duplicate class rules across multiple style tags are merged", () => {
const fragment = generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<style>.card { padding: 16px; }</style>
<div class="card">Hello</div>
`);
// should create a single token with both properties
const tokens = fragment.styleSources.filter((s) => s.type === "token");
expect(tokens).toHaveLength(1);
const tokenId = tokens[0].id;
const tokenStyles = fragment.styles.filter(
(s) => s.styleSourceId === tokenId
);
const properties = tokenStyles.map((s) => s.property);
expect(properties).toContain("display");
expect(properties).toContain("paddingTop");
});
test("script tag still becomes html embed alongside token extraction", () => {
const cardToken = token(
"card",
css`
display: flex;
`
);
expect(
generateFragmentFromHtml(`
<style>.card { display: flex; }</style>
<script>console.log("hi");</script>
<div class="card">Hello</div>
`)
).toEqual(
renderTemplate(
<>
<HtmlEmbed
ws:label="Script"
clientOnly={true}
code={`<script>console.log("hi");</script>`}
/>
<ws.element ws:tag="div" ws:tokens={[cardToken]}>
Hello
</ws.element>
</>
)
);
});
test("style tag with pseudo-class creates token with state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn { background-color: blue; }
.btn:hover { background-color: darkblue; }
</style>
<button class="btn">Click me</button>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "btn"
);
expect(tokenSource).toBeDefined();
// base style
const baseStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "backgroundColor" &&
s.state === undefined
);
expect(baseStyle).toBeDefined();
// hover state style
const hoverStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "backgroundColor" &&
s.state === ":hover"
);
expect(hoverStyle).toBeDefined();
});
test("style tag with media query creates token with breakpoint styles", () => {
const fragment = generateFragmentFromHtml(`
<style>
.container { padding: 8px; }
@media (min-width: 768px) {
.container { padding: 16px; }
}
</style>
<div class="container">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "container"
);
expect(tokenSource).toBeDefined();
// should have styles on different breakpoints
const tokenStyles = fragment.styles.filter(
(s) => s.styleSourceId === tokenSource!.id
);
const breakpointIds = new Set(tokenStyles.map((s) => s.breakpointId));
// should have at least 2 different breakpoints (base + media query)
expect(breakpointIds.size).toBeGreaterThanOrEqual(2);
});
test("handle real-world html snippet with style tag", () => {
const heroToken = token(
"hero",
css`
display: flex;
flex-direction: column;
align-items: center;
padding: 64px;
`
);
const heroTitleToken = token(
"hero-title",
css`
font-size: 48px;
font-weight: bold;
line-height: 1.2;
`
);
const heroTextToken = token(
"hero-text",
css`
font-size: 18px;
color: gray;
`
);
expect(
generateFragmentFromHtml(`
<style>
.hero {
display: flex;
flex-direction: column;
align-items: center;
padding: 64px;
}
.hero-title {
font-size: 48px;
font-weight: bold;
line-height: 1.2;
}
.hero-text {
font-size: 18px;
color: gray;
}
</style>
<section class="hero">
<h1 class="hero-title">Welcome</h1>
<p class="hero-text">Build something amazing</p>
</section>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="section" ws:tokens={[heroToken]}>
<ws.element ws:tag="h1" ws:tokens={[heroTitleToken]}>
Welcome
</ws.element>
<ws.element ws:tag="p" ws:tokens={[heroTextToken]}>
Build something amazing
</ws.element>
</ws.element>
)
);
});
test("create tokens from style-only paste without HTML elements", () => {
const result = generateFragmentFromHtml(`
<style>.card { display: flex; padding: 16px; }</style>
`);
expect(result.children).toEqual([]);
expect(result.instances).toEqual([]);
expect(result.styleSources).toEqual([
{ type: "token", id: expect.any(String), name: "card" },
]);
expect(result.styles).toEqual([
{
styleSourceId: result.styleSources[0].id,
breakpointId: expect.any(String),
property: "display",
value: { type: "keyword", value: "flex" },
},
{
styleSourceId: result.styleSources[0].id,
breakpointId: expect.any(String),
property: "paddingTop",
value: { type: "unit", unit: "px", value: 16 },
},
{
styleSourceId: result.styleSources[0].id,
breakpointId: expect.any(String),
property: "paddingRight",
value: { type: "unit", unit: "px", value: 16 },
},
{
styleSourceId: result.styleSources[0].id,
breakpointId: expect.any(String),
property: "paddingBottom",
value: { type: "unit", unit: "px", value: 16 },
},
{
styleSourceId: result.styleSources[0].id,
breakpointId: expect.any(String),
property: "paddingLeft",
value: { type: "unit", unit: "px", value: 16 },
},
]);
expect(result.styleSourceSelections).toEqual([]);
});
test("create multiple tokens from style-only paste", () => {
const result = generateFragmentFromHtml(`
<style>
.card { display: flex; }
.title { font-weight: bold; }
</style>
`);
expect(result.children).toEqual([]);
expect(result.styleSources).toEqual([
{ type: "token", id: expect.any(String), name: "card" },
{ type: "token", id: expect.any(String), name: "title" },
]);
expect(result.styles).toHaveLength(2);
});
test("create tokens with media queries from style-only paste", () => {
const result = generateFragmentFromHtml(`
<style>
.card { display: flex; }
@media (min-width: 768px) {
.card { flex-direction: row; }
}
</style>
`);
expect(result.children).toEqual([]);
expect(result.styleSources).toEqual([
{ type: "token", id: expect.any(String), name: "card" },
]);
// base style + breakpoint style
expect(result.styles).toHaveLength(2);
expect(result.breakpoints).toHaveLength(2); // base + 768px
});
test("style-only paste with non-class rules creates leftover embed", () => {
const result = generateFragmentFromHtml(`
<style>
.card { display: flex; }
div { color: red; }
</style>
`);
// card token created
expect(result.styleSources).toEqual([
{ type: "token", id: expect.any(String), name: "card" },
]);
// leftover non-class rule kept as HtmlEmbed
expect(result.instances).toHaveLength(1);
expect(result.instances[0].component).toBe("HtmlEmbed");
});
describe("media queries", () => {
test("extract class with min-width media query into breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { display: flex; }
@media (min-width: 768px) {
.card { flex-direction: row; }
}
</style>
<div class="card">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// base style
const baseStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "display" &&
s.state === undefined
);
expect(baseStyle).toBeDefined();
// breakpoint style
const bpStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id && s.property === "flexDirection"
);
expect(bpStyle).toBeDefined();
expect(bpStyle!.breakpointId).not.toBe(baseStyle!.breakpointId);
// breakpoint should be created with minWidth
const bp = fragment.breakpoints.find(
(b) => b.id === bpStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.minWidth).toBe(768);
});
test("extract class with max-width media query into breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.container { padding: 32px; }
@media (max-width: 480px) {
.container { padding: 16px; }
}
</style>
<div class="container">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "container"
);
expect(tokenSource).toBeDefined();
const bpStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "paddingTop" &&
s.breakpointId !== "base"
);
expect(bpStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === bpStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.maxWidth).toBe(480);
});
test("extract class across multiple media queries", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { font-size: 14px; }
@media (min-width: 768px) {
.card { font-size: 16px; }
}
@media (min-width: 1024px) {
.card { font-size: 18px; }
}
</style>
<div class="card">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
const tokenStyles = fragment.styles.filter(
(s) => s.styleSourceId === tokenSource!.id
);
const breakpointIds = new Set(tokenStyles.map((s) => s.breakpointId));
// base + 768px + 1024px = 3 breakpoints
expect(breakpointIds.size).toBe(3);
});
test("media query with non-class selectors stays as html embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
@media (min-width: 768px) {
#hero { font-size: 24px; }
}
</style>
<div>Hello</div>
`);
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
true
);
expect(
fragment.styleSources.filter((s) => s.type === "token")
).toHaveLength(0);
});
test("media query with mixed class and non-class selectors", () => {
const fragment = generateFragmentFromHtml(`
<style>
@media (min-width: 768px) {
.card { display: flex; }
#hero { color: red; }
}
</style>
<div class="card">Hello</div>
`);
// .card in media query should become token
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// #hero in media query should remain as html embed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
});
test("same class in base and media query produces single token", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn { padding: 8px; }
@media (min-width: 768px) {
.btn { padding: 16px; }
}
</style>
<button class="btn">Click</button>
`);
const tokens = fragment.styleSources.filter((s) => s.type === "token");
expect(tokens).toHaveLength(1);
expect(tokens[0].type === "token" && tokens[0].name).toBe("btn");
});
test("multiple classes in same media query", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { display: flex; }
.title { font-size: 16px; }
@media (min-width: 768px) {
.card { flex-direction: row; }
.title { font-size: 24px; }
}
</style>
<div class="card">
<h1 class="title">Hello</h1>
</div>
`);
const tokens = fragment.styleSources.filter((s) => s.type === "token");
expect(tokens).toHaveLength(2);
const cardToken = tokens.find(
(s) => s.type === "token" && s.name === "card"
);
const titleToken = tokens.find(
(s) => s.type === "token" && s.name === "title"
);
expect(cardToken).toBeDefined();
expect(titleToken).toBeDefined();
});
});
describe("pseudo-classes and pseudo-elements", () => {
test("extract :hover pseudo-class as state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.link { color: blue; }
.link:hover { color: darkblue; }
</style>
<a class="link">Click</a>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "link"
);
expect(tokenSource).toBeDefined();
const hoverStyle = fragment.styles.find(
(s) => s.styleSourceId === tokenSource!.id && s.state === ":hover"
);
expect(hoverStyle).toBeDefined();
});
test("extract :focus pseudo-class as state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.input { border-color: gray; }
.input:focus { border-color: blue; }
</style>
<input class="input" />
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "input"
);
expect(tokenSource).toBeDefined();
const focusStyle = fragment.styles.find(
(s) => s.styleSourceId === tokenSource!.id && s.state === ":focus"
);
expect(focusStyle).toBeDefined();
});
test("extract multiple pseudo-classes on same class", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn { background: blue; }
.btn:hover { background: darkblue; }
.btn:focus { outline-color: blue; }
.btn:active { background: navy; }
</style>
<button class="btn">Click</button>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "btn"
);
expect(tokenSource).toBeDefined();
const states = fragment.styles
.filter((s) => s.styleSourceId === tokenSource!.id && s.state)
.map((s) => s.state);
expect(states).toContain(":hover");
expect(states).toContain(":focus");
expect(states).toContain(":active");
});
test("extract ::before pseudo-element as state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.decorated { position: relative; }
.decorated::before { content: "★"; }
</style>
<div class="decorated">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "decorated"
);
expect(tokenSource).toBeDefined();
const beforeStyle = fragment.styles.find(
(s) => s.styleSourceId === tokenSource!.id && s.state === "::before"
);
expect(beforeStyle).toBeDefined();
});
test("extract ::after pseudo-element as state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.clearfix::after {
content: "";
display: table;
clear: both;
}
</style>
<div class="clearfix">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "clearfix"
);
expect(tokenSource).toBeDefined();
const afterStyles = fragment.styles.filter(
(s) => s.styleSourceId === tokenSource!.id && s.state === "::after"
);
expect(afterStyles.length).toBeGreaterThanOrEqual(1);
});
test("pseudo-class on non-class selector ignored (stays in embed)", () => {
const fragment = generateFragmentFromHtml(`
<style>
a:hover { color: red; }
</style>
<a>Link</a>
`);
expect(
fragment.styleSources.filter((s) => s.type === "token")
).toHaveLength(0);
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
true
);
});
test("pseudo-class combined with media query", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn { background: blue; }
.btn:hover { background: darkblue; }
@media (min-width: 768px) {
.btn { padding: 16px; }
.btn:hover { background: royalblue; }
}
</style>
<button class="btn">Click</button>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "btn"
);
expect(tokenSource).toBeDefined();
// should have hover styles on base breakpoint
const baseHover = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.state === ":hover" &&
s.breakpointId === "base"
);
expect(baseHover).toBeDefined();
// should have hover styles on 768px breakpoint
const bpHover = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.state === ":hover" &&
s.breakpointId !== "base"
);
expect(bpHover).toBeDefined();
});
test("::placeholder pseudo-element as state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.input { color: black; }
.input::placeholder { color: gray; }
</style>
<input class="input" />
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "input"
);
expect(tokenSource).toBeDefined();
const placeholderStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id && s.state === "::placeholder"
);
expect(placeholderStyle).toBeDefined();
});
});
describe("at-rules and special CSS", () => {
test("@keyframes stays as html embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
@keyframes spin {
from { transform: rotate(0deg); }
to { transform: rotate(360deg); }
}
.spinner { animation: spin 1s infinite; }
</style>
<div class="spinner">Loading</div>
`);
// .spinner class should still become a token
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "spinner"
);
expect(tokenSource).toBeDefined();
// @keyframes should remain as html embed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
const codeProp = fragment.props.find(
(p) => p.instanceId === htmlEmbed!.id && p.name === "code"
);
expect(codeProp).toBeDefined();
expect(codeProp!.type === "string" && codeProp!.value).toContain(
"@keyframes"
);
});
test("@font-face stays as html embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
@font-face {
font-family: "MyFont";
src: url("font.woff2");
}
.text { font-family: "MyFont"; }
</style>
<p class="text">Hello</p>
`);
// .text class should become a token
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "text"
);
expect(tokenSource).toBeDefined();
// @font-face should remain as html embed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
const codeProp = fragment.props.find(
(p) => p.instanceId === htmlEmbed!.id && p.name === "code"
);
expect(codeProp).toBeDefined();
expect(codeProp!.type === "string" && codeProp!.value).toContain(
"@font-face"
);
});
test("@media print stays as html embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { display: flex; }
@media print {
.card { display: block; }
}
</style>
<div class="card">Hello</div>
`);
// base .card should become a token
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// @media print should remain as html embed since parseCss ignores print
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
});
test("grouped class selectors like .a, .b are extracted as separate tokens", () => {
const fragment = generateFragmentFromHtml(`
<style>
.primary, .secondary { font-weight: bold; }
</style>
<span class="primary">One</span>
<span class="secondary">Two</span>
`);
const primaryToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "primary"
);
const secondaryToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "secondary"
);
expect(primaryToken).toBeDefined();
expect(secondaryToken).toBeDefined();
// both should have the same style
const primaryStyle = fragment.styles.find(
(s) => s.styleSourceId === primaryToken!.id
);
const secondaryStyle = fragment.styles.find(
(s) => s.styleSourceId === secondaryToken!.id
);
expect(primaryStyle?.property).toBe("fontWeight");
expect(secondaryStyle?.property).toBe("fontWeight");
});
test("grouped selector with class + non-class stays partially in embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card, #hero { display: flex; }
</style>
<div class="card">Hello</div>
`);
// .card should become token
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// #hero part should remain as html embed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
});
});
describe("condition breakpoints", () => {
test("@media (prefers-color-scheme: dark) creates condition breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { background: white; color: black; }
@media (prefers-color-scheme: dark) {
.card { background: black; color: white; }
}
</style>
<div class="card">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// should have base styles
const baseStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "backgroundColor" &&
s.state === undefined
);
expect(baseStyle).toBeDefined();
// should have dark mode styles on condition breakpoint
const darkStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "backgroundColor" &&
s.breakpointId !== baseStyle!.breakpointId
);
expect(darkStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === darkStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.condition).toBe("prefers-color-scheme:dark");
expect(bp!.minWidth).toBeUndefined();
expect(bp!.maxWidth).toBeUndefined();
});
test("@media (orientation: portrait) creates condition breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.layout { flex-direction: row; }
@media (orientation: portrait) {
.layout { flex-direction: column; }
}
</style>
<div class="layout">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "layout"
);
expect(tokenSource).toBeDefined();
const portraitStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "flexDirection" &&
s.breakpointId !== "base"
);
expect(portraitStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === portraitStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.condition).toBe("orientation:portrait");
});
test("@media (hover: hover) creates condition breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.interactive { cursor: default; }
@media (hover: hover) {
.interactive { cursor: pointer; }
}
</style>
<div class="interactive">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "interactive"
);
expect(tokenSource).toBeDefined();
const hoverStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "cursor" &&
s.breakpointId !== "base"
);
expect(hoverStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === hoverStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.condition).toBe("hover:hover");
});
test("@media (prefers-reduced-motion: reduce) creates condition breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.animated { transition: transform 0.3s; }
@media (prefers-reduced-motion: reduce) {
.animated { transition: none; }
}
</style>
<div class="animated">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "animated"
);
expect(tokenSource).toBeDefined();
const reduceStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "transitionProperty" &&
s.breakpointId !== "base"
);
expect(reduceStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === reduceStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.condition).toBe("prefers-reduced-motion:reduce");
});
test("combined min-width and max-width uses range breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.tablet-only { display: none; }
@media (min-width: 768px) and (max-width: 1024px) {
.tablet-only { display: block; }
}
</style>
<div class="tablet-only">Tablet content</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "tablet-only"
);
expect(tokenSource).toBeDefined();
const tabletStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "display" &&
s.breakpointId !== "base"
);
expect(tabletStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === tabletStyle!.breakpointId
);
expect(bp).toBeDefined();
// Combined width queries use both minWidth and maxWidth
expect(bp!.minWidth).toBe(768);
expect(bp!.maxWidth).toBe(1024);
expect(bp!.condition).toBeUndefined();
});
test("overlapping min/max-width breakpoints get rounded to non-overlapping values", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (min-width: 600px) and (max-width: 900px) {
.a { font-size: 16px; }
}
@media (min-width: 800px) and (max-width: 1200px) {
.a { font-size: 18px; }
}
</style>
<div class="a">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "a"
);
expect(tokenSource).toBeDefined();
const tokenStyles = fragment.styles.filter(
(s) => s.styleSourceId === tokenSource!.id && s.property === "fontSize"
);
// base + 2 range breakpoints = 3 styles
expect(tokenStyles).toHaveLength(3);
const rangeBreakpoints = tokenStyles
.filter((s) => s.breakpointId !== "base")
.map((s) => fragment.breakpoints.find((b) => b.id === s.breakpointId))
.filter(Boolean)
.sort((a, b) => (a!.minWidth ?? 0) - (b!.minWidth ?? 0));
expect(rangeBreakpoints).toHaveLength(2);
// ranges should not overlap: first.maxWidth < second.minWidth
const first = rangeBreakpoints[0]!;
const second = rangeBreakpoints[1]!;
expect(first.maxWidth).toBeDefined();
expect(second.minWidth).toBeDefined();
expect(first.maxWidth!).toBeLessThan(second.minWidth!);
});
test("non-overlapping range breakpoints stay unchanged", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (min-width: 400px) and (max-width: 700px) {
.a { font-size: 16px; }
}
@media (min-width: 800px) and (max-width: 1200px) {
.a { font-size: 18px; }
}
</style>
<div class="a">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "a"
);
expect(tokenSource).toBeDefined();
const rangeBreakpoints = fragment.breakpoints
.filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
.sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
expect(rangeBreakpoints).toHaveLength(2);
// values should remain exactly as authored since they don't overlap
expect(rangeBreakpoints[0].minWidth).toBe(400);
expect(rangeBreakpoints[0].maxWidth).toBe(700);
expect(rangeBreakpoints[1].minWidth).toBe(800);
expect(rangeBreakpoints[1].maxWidth).toBe(1200);
});
test("adjacent range breakpoints (touching) stay unchanged", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (min-width: 400px) and (max-width: 799px) {
.a { font-size: 16px; }
}
@media (min-width: 800px) and (max-width: 1200px) {
.a { font-size: 18px; }
}
</style>
<div class="a">Hello</div>
`);
const rangeBreakpoints = fragment.breakpoints
.filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
.sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
expect(rangeBreakpoints).toHaveLength(2);
// touching but not overlapping — keep as is
expect(rangeBreakpoints[0].maxWidth).toBe(799);
expect(rangeBreakpoints[1].minWidth).toBe(800);
});
test("overlapping range: first.maxWidth rounded down to second.minWidth - 1", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (min-width: 600px) and (max-width: 1000px) {
.a { font-size: 16px; }
}
@media (min-width: 900px) and (max-width: 1400px) {
.a { font-size: 18px; }
}
</style>
<div class="a">Hello</div>
`);
const rangeBreakpoints = fragment.breakpoints
.filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
.sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
expect(rangeBreakpoints).toHaveLength(2);
// first range's maxWidth should be adjusted to not overlap second's minWidth
expect(rangeBreakpoints[0].minWidth).toBe(600);
expect(rangeBreakpoints[0].maxWidth!).toBeLessThan(
rangeBreakpoints[1].minWidth!
);
// second range should keep its original values
expect(rangeBreakpoints[1].minWidth).toBe(900);
expect(rangeBreakpoints[1].maxWidth).toBe(1400);
});
test("three overlapping ranges all get adjusted", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (min-width: 400px) and (max-width: 800px) {
.a { font-size: 16px; }
}
@media (min-width: 700px) and (max-width: 1100px) {
.a { font-size: 18px; }
}
@media (min-width: 1000px) and (max-width: 1400px) {
.a { font-size: 20px; }
}
</style>
<div class="a">Hello</div>
`);
const rangeBreakpoints = fragment.breakpoints
.filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
.sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
expect(rangeBreakpoints).toHaveLength(3);
// no pair should overlap
expect(rangeBreakpoints[0].maxWidth!).toBeLessThan(
rangeBreakpoints[1].minWidth!
);
expect(rangeBreakpoints[1].maxWidth!).toBeLessThan(
rangeBreakpoints[2].minWidth!
);
});
test("exact duplicate range breakpoints get deduplicated", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
.b { color: red; }
@media (min-width: 768px) and (max-width: 1024px) {
.a { font-size: 18px; }
}
@media (min-width: 768px) and (max-width: 1024px) {
.b { color: blue; }
}
</style>
<div class="a"><span class="b">Hello</span></div>
`);
// same range should reuse a single breakpoint
const rangeBreakpoints = fragment.breakpoints.filter(
(b) => b.minWidth !== undefined && b.maxWidth !== undefined
);
expect(rangeBreakpoints).toHaveLength(1);
expect(rangeBreakpoints[0].minWidth).toBe(768);
expect(rangeBreakpoints[0].maxWidth).toBe(1024);
});
test("range breakpoint overlapping with simple min-width breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (min-width: 768px) {
.a { font-size: 18px; }
}
@media (min-width: 600px) and (max-width: 900px) {
.a { font-size: 16px; }
}
</style>
<div class="a">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "a"
);
expect(tokenSource).toBeDefined();
const tokenStyles = fragment.styles.filter(
(s) => s.styleSourceId === tokenSource!.id && s.property === "fontSize"
);
// base + min-width + range = 3 breakpoints
expect(tokenStyles).toHaveLength(3);
// simple min-width breakpoint should exist
const minWidthBp = fragment.breakpoints.find(
(b) =>
b.minWidth !== undefined &&
b.maxWidth === undefined &&
b.condition === undefined
);
expect(minWidthBp).toBeDefined();
// range breakpoint should exist and not overlap min-width
const rangeBp = fragment.breakpoints.find(
(b) => b.minWidth !== undefined && b.maxWidth !== undefined
);
expect(rangeBp).toBeDefined();
// range's maxWidth must be less than the min-width breakpoint's minWidth
// so they don't overlap
expect(rangeBp!.maxWidth!).toBeLessThan(minWidthBp!.minWidth!);
});
test("range breakpoint overlapping with simple max-width breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (max-width: 600px) {
.a { font-size: 12px; }
}
@media (min-width: 400px) and (max-width: 900px) {
.a { font-size: 16px; }
}
</style>
<div class="a">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "a"
);
expect(tokenSource).toBeDefined();
const tokenStyles = fragment.styles.filter(
(s) => s.styleSourceId === tokenSource!.id && s.property === "fontSize"
);
// base + max-width + range = 3 breakpoints
expect(tokenStyles).toHaveLength(3);
// simple max-width breakpoint should exist
const maxWidthBp = fragment.breakpoints.find(
(b) =>
b.maxWidth !== undefined &&
b.minWidth === undefined &&
b.condition === undefined
);
expect(maxWidthBp).toBeDefined();
// range breakpoint should exist and not overlap max-width
const rangeBp = fragment.breakpoints.find(
(b) => b.minWidth !== undefined && b.maxWidth !== undefined
);
expect(rangeBp).toBeDefined();
// range's minWidth must be greater than the max-width breakpoint's maxWidth
expect(rangeBp!.minWidth!).toBeGreaterThan(maxWidthBp!.maxWidth!);
});
test("completely contained range gets clamped", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a { font-size: 14px; }
@media (min-width: 400px) and (max-width: 1200px) {
.a { font-size: 16px; }
}
@media (min-width: 600px) and (max-width: 900px) {
.a { font-size: 18px; }
}
</style>
<div class="a">Hello</div>
`);
const rangeBreakpoints = fragment.breakpoints
.filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
.sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
expect(rangeBreakpoints).toHaveLength(2);
// the outer range should be split/adjusted so inner doesn't overlap
expect(rangeBreakpoints[0].maxWidth!).toBeLessThan(
rangeBreakpoints[1].minWidth!
);
});
test("combined width and feature uses condition breakpoint", () => {
const fragment = generateFragmentFromHtml(`
<style>
.widget { font-size: 14px; }
@media (min-width: 768px) and (orientation: landscape) {
.widget { font-size: 18px; }
}
</style>
<div class="widget">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "widget"
);
expect(tokenSource).toBeDefined();
const landscapeStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "fontSize" &&
s.breakpointId !== "base"
);
expect(landscapeStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === landscapeStyle!.breakpointId
);
expect(bp).toBeDefined();
// Mixed width + feature query becomes a condition
expect(bp!.condition).toBeDefined();
});
test("multiple condition features combined", () => {
const fragment = generateFragmentFromHtml(`
<style>
.accessible { font-size: 16px; }
@media (prefers-color-scheme: dark) and (prefers-contrast: more) {
.accessible { font-size: 18px; }
}
</style>
<div class="accessible">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "accessible"
);
expect(tokenSource).toBeDefined();
const conditionStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "fontSize" &&
s.breakpointId !== "base"
);
expect(conditionStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === conditionStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.condition).toBeDefined();
// condition should contain both features
expect(bp!.condition).toContain("prefers-color-scheme");
expect(bp!.condition).toContain("prefers-contrast");
});
test("same condition breakpoint reused for multiple classes", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { background: white; }
.text { color: black; }
@media (prefers-color-scheme: dark) {
.card { background: black; }
.text { color: white; }
}
</style>
<div class="card">
<p class="text">Hello</p>
</div>
`);
const cardToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
const textToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "text"
);
expect(cardToken).toBeDefined();
expect(textToken).toBeDefined();
// both dark styles should reference the same breakpoint
const cardDarkStyle = fragment.styles.find(
(s) =>
s.styleSourceId === cardToken!.id &&
s.property === "backgroundColor" &&
s.breakpointId !== "base"
);
const textDarkStyle = fragment.styles.find(
(s) =>
s.styleSourceId === textToken!.id &&
s.property === "color" &&
s.breakpointId !== "base"
);
expect(cardDarkStyle).toBeDefined();
expect(textDarkStyle).toBeDefined();
expect(cardDarkStyle!.breakpointId).toBe(textDarkStyle!.breakpointId);
});
});
describe("nested at-rules", () => {
test("nested @media rules extract class with flattened condition", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { display: flex; }
@media (min-width: 768px) {
@media (prefers-color-scheme: dark) {
.card { background: black; }
}
}
</style>
<div class="card">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// nested @media should flatten into a combined condition
const nestedStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "backgroundColor"
);
expect(nestedStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === nestedStyle!.breakpointId
);
expect(bp).toBeDefined();
// flattened condition should include both queries
expect(bp!.condition).toBeDefined();
});
test("deeply nested @media still extracts class tokens", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { padding: 8px; }
@media (min-width: 768px) {
@media (orientation: landscape) {
@media (hover: hover) {
.card { padding: 32px; }
}
}
}
</style>
<div class="card">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
const deepStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "paddingTop" &&
s.breakpointId !== "base"
);
expect(deepStyle).toBeDefined();
const bp = fragment.breakpoints.find(
(b) => b.id === deepStyle!.breakpointId
);
expect(bp).toBeDefined();
expect(bp!.condition).toBeDefined();
});
test("nested @media with same feature type combines correctly", () => {
const fragment = generateFragmentFromHtml(`
<style>
.responsive { font-size: 14px; }
@media (min-width: 768px) {
.responsive { font-size: 16px; }
@media (min-width: 1024px) {
.responsive { font-size: 20px; }
}
}
</style>
<div class="responsive">Hello</div>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "responsive"
);
expect(tokenSource).toBeDefined();
// outer @media (min-width: 768px) should have simple breakpoint
const outerStyle = fragment.styles.find(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "fontSize" &&
s.breakpointId !== "base" &&
fragment.breakpoints.find(
(b) => b.id === s.breakpointId && b.minWidth === 768
)
);
expect(outerStyle).toBeDefined();
// nested @media (min-width: 1024px) inside @media (min-width: 768px)
// should still produce a breakpoint (the effective min-width is 1024px)
const innerStyles = fragment.styles.filter(
(s) =>
s.styleSourceId === tokenSource!.id &&
s.property === "fontSize" &&
s.breakpointId !== "base" &&
s.breakpointId !== outerStyle!.breakpointId
);
expect(innerStyles).toHaveLength(1);
});
test("@supports nested inside @media keeps class in embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
.grid { display: flex; }
@supports (display: grid) {
.grid { display: grid; }
}
</style>
<div class="grid">Hello</div>
`);
// base class should become token
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "grid"
);
expect(tokenSource).toBeDefined();
// @supports should remain as html embed (not a media query)
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
});
});
describe("selector edge cases", () => {
test("class with compound selector .card.active is extracted as combo token", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card.active { opacity: 1; }
</style>
<div class="card active">Hello</div>
`);
// compound selectors become combo tokens (Webflow-style naming)
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card.active"
);
expect(tokenSource).toBeDefined();
// no leftover for pure class rule
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
});
test("class with attribute selector .btn[disabled] is extracted with state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn[disabled] { opacity: 0.5; }
</style>
<button class="btn" disabled>Click</button>
`);
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "btn"
);
expect(tokenSource).toBeDefined();
// the style should have [disabled] state
const style = fragment.styles.find(
(s) => s.styleSourceId === tokenSource!.id
);
expect(style).toBeDefined();
expect(style!.state).toBe("[disabled]");
// no leftover
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
});
test("class with sibling combinator .a + .b is not extracted", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a + .b { margin-top: 8px; }
</style>
<div class="a">A</div>
<div class="b">B</div>
`);
expect(
fragment.styleSources.filter((s) => s.type === "token")
).toHaveLength(0);
});
test("class with general sibling .a ~ .b is not extracted", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a ~ .b { color: red; }
</style>
<div class="a">A</div>
<div class="b">B</div>
`);
expect(
fragment.styleSources.filter((s) => s.type === "token")
).toHaveLength(0);
});
test(":root selector is extracted as local styles on the root instance, not as html embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
:root { --color: blue; }
.card { color: var(--color); }
</style>
<div class="card">Hello</div>
`);
// .card should become token
const tokenSource = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(tokenSource).toBeDefined();
// :root should NOT produce an html embed
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
// :root styles should be on the root instance selection
const rootSelection = fragment.styleSourceSelections.find(
(sel) => sel.instanceId === ":root"
);
expect(rootSelection).toBeDefined();
const rootStyleSourceId = rootSelection!.values[0];
const rootStyle = fragment.styles.find(
(s) => s.styleSourceId === rootStyleSourceId && s.property === "--color"
);
expect(rootStyle).toBeDefined();
});
test(":root only styles are extracted as local styles on root instance", () => {
const fragment = generateFragmentFromHtml(`
<style>
:root {
color: red;
}
</style>
`);
// no html embed
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
// style on :root instance
const rootSelection = fragment.styleSourceSelections.find(
(sel) => sel.instanceId === ":root"
);
expect(rootSelection).toBeDefined();
const rootStyleSourceId = rootSelection!.values[0];
const rootStyle = fragment.styles.find(
(s) => s.styleSourceId === rootStyleSourceId && s.property === "color"
);
expect(rootStyle).toBeDefined();
expect(rootStyle!.value).toMatchObject({ type: "keyword", value: "red" });
});
test("cross-selector gradient vars stay as var() references in pasted tokens", () => {
const fragment = generateFragmentFromHtml(`
<section class="scope">
<style>
.scope {
--tone-1: #ff0000;
--tone-2: #00ff00;
--tone-3: #0000ff;
}
.panel {
background: linear-gradient(38deg, var(--tone-1), var(--tone-2), var(--tone-3));
}
</style>
<div class="panel">test</div>
</section>
`);
const tokenSource = fragment.styleSources.find(
(source) => source.type === "token" && source.name === "panel"
);
expect(tokenSource).toBeDefined();
const backgroundImage = fragment.styles.find(
(style) =>
style.styleSourceId === tokenSource!.id &&
style.property === "backgroundImage"
);
expect(backgroundImage?.value).toMatchObject({
type: "layers",
value: [
{
type: "unparsed",
value:
"linear-gradient(38deg,var(--tone-1),var(--tone-2),var(--tone-3))",
},
],
});
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
});
test("universal selector * stays as html embed", () => {
const fragment = generateFragmentFromHtml(`
<style>
* { box-sizing: border-box; }
</style>
<div>Hello</div>
`);
expect(
fragment.styleSources.filter((s) => s.type === "token")
).toHaveLength(0);
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
true
);
});
});
describe("compound class selectors", () => {
test("compound .card.active extracts as combo token when element has both classes", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card { display: flex; }
.card.active { opacity: 1; }
</style>
<div class="card active">Hello</div>
`);
const cardToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
const comboToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card.active"
);
expect(cardToken).toBeDefined();
expect(comboToken).toBeDefined();
// instance should reference both tokens
const sel = fragment.styleSourceSelections.find(
(s) =>
s.values.includes(cardToken!.id) && s.values.includes(comboToken!.id)
);
expect(sel).toBeDefined();
});
test("compound .a.b.c extracts as triple combo token", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a.b.c { color: red; }
</style>
<div class="a b c">Hello</div>
`);
const comboToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "a.b.c"
);
expect(comboToken).toBeDefined();
const style = fragment.styles.find(
(s) => s.styleSourceId === comboToken!.id && s.property === "color"
);
expect(style).toBeDefined();
});
test("compound class not matched when element is missing a class", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card.active { opacity: 1; }
</style>
<div class="card">Hello</div>
`);
// token is created for all class rules, even if not applied to elements
const comboToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card.active"
);
expect(comboToken).toBeDefined();
// but NOT assigned to the div (missing "active" class)
const divInstance = fragment.instances.find((i) => i.tag === "div");
const sel = fragment.styleSourceSelections.find(
(s) => s.instanceId === divInstance?.id
);
// No selection for this instance, or if one exists, it shouldn't contain the combo token
expect(sel?.values ?? []).not.toContain(comboToken?.id);
});
test("compound class with :hover pseudo extracts correctly", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn.primary:hover { background: blue; }
</style>
<button class="btn primary">Click</button>
`);
const comboToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "btn.primary"
);
expect(comboToken).toBeDefined();
const style = fragment.styles.find(
(s) => s.styleSourceId === comboToken!.id
);
expect(style).toBeDefined();
expect(style!.state).toBe(":hover");
});
test("compound class inside @media query creates breakpoint style", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card.featured { display: block; }
@media (min-width: 768px) {
.card.featured { display: flex; }
}
</style>
<div class="card featured">Hello</div>
`);
const comboToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card.featured"
);
expect(comboToken).toBeDefined();
// Should have both base and breakpoint styles
const comboStyles = fragment.styles.filter(
(s) => s.styleSourceId === comboToken!.id
);
expect(comboStyles.length).toBe(2);
const bpIds = new Set(comboStyles.map((s) => s.breakpointId));
expect(bpIds.size).toBe(2);
});
});
describe("attribute selectors as state", () => {
test(".btn[disabled] extracts with [disabled] state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn { padding: 8px; }
.btn[disabled] { opacity: 0.5; }
</style>
<button class="btn" disabled>Click</button>
`);
const btnToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "btn"
);
expect(btnToken).toBeDefined();
const baseStyle = fragment.styles.find(
(s) => s.styleSourceId === btnToken!.id && s.state === undefined
);
expect(baseStyle).toBeDefined();
expect(baseStyle!.property).toBe("paddingTop");
const stateStyle = fragment.styles.find(
(s) => s.styleSourceId === btnToken!.id && s.state === "[disabled]"
);
expect(stateStyle).toBeDefined();
expect(stateStyle!.property).toBe("opacity");
});
test(".input[readonly] extracts with [readonly] state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.input[readonly] { background: #eee; }
</style>
<input class="input" readonly>
`);
const inputToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "input"
);
expect(inputToken).toBeDefined();
const stateStyle = fragment.styles.find(
(s) => s.styleSourceId === inputToken!.id && s.state === "[readonly]"
);
expect(stateStyle).toBeDefined();
});
test("attribute selector combined with pseudo keeps pseudo state", () => {
const fragment = generateFragmentFromHtml(`
<style>
.btn:hover { color: blue; }
.btn[disabled] { opacity: 0.5; }
</style>
<button class="btn" disabled>Click</button>
`);
const btnToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "btn"
);
expect(btnToken).toBeDefined();
const hoverStyle = fragment.styles.find(
(s) => s.styleSourceId === btnToken!.id && s.state === ":hover"
);
expect(hoverStyle).toBeDefined();
const disabledStyle = fragment.styles.find(
(s) => s.styleSourceId === btnToken!.id && s.state === "[disabled]"
);
expect(disabledStyle).toBeDefined();
});
});
describe("mixed comma selectors (partial extraction)", () => {
test(".card, div {} extracts .card token, keeps div in leftover", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card, div { display: flex; }
</style>
<div class="card">Hello</div>
`);
const cardToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
expect(cardToken).toBeDefined();
// div part should stay as html embed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
const codeProp = fragment.props.find(
(p) => p.instanceId === htmlEmbed!.id && p.name === "code"
);
expect(codeProp).toBeDefined();
// The leftover should only contain the div selector, not .card
expect(codeProp!.type === "string" && codeProp!.value).toContain("div");
expect(codeProp!.type === "string" && codeProp!.value).not.toMatch(
/\.card/
);
});
test(".a, .b, #id {} extracts .a and .b, keeps #id in leftover", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a, .b, #id { color: red; }
</style>
<div class="a">A</div>
<div class="b">B</div>
`);
const tokenA = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "a"
);
const tokenB = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "b"
);
expect(tokenA).toBeDefined();
expect(tokenB).toBeDefined();
// #id should stay in embed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
});
test(".a, .b {} with all class selectors produces no leftover", () => {
const fragment = generateFragmentFromHtml(`
<style>
.a, .b { padding: 4px; }
</style>
<div class="a">A</div>
<div class="b">B</div>
`);
// Both should become tokens
expect(
fragment.styleSources.filter((s) => s.type === "token")
).toHaveLength(2);
// No leftover embed
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
});
});
describe("breakpoint labels", () => {
test("condition breakpoint gets human-readable label", () => {
const fragment = generateFragmentFromHtml(`
<style>
@media (prefers-color-scheme: dark) {
.card { background: black; }
}
</style>
<div class="card">Hello</div>
`);
const condBp = fragment.breakpoints.find((b) => b.condition);
expect(condBp).toBeDefined();
// capitalCase transforms "prefers-color-scheme:dark" → "Prefers Color Scheme Dark"
expect(condBp!.label).toBe("Prefers Color Scheme Dark");
});
test("width breakpoint gets readable label", () => {
const fragment = generateFragmentFromHtml(`
<style>
@media (min-width: 768px) {
.card { display: flex; }
}
</style>
<div class="card">Hello</div>
`);
const bp = fragment.breakpoints.find((b) => b.minWidth === 768);
expect(bp).toBeDefined();
expect(bp!.label).toBe("≥ 768px");
});
test("range breakpoint gets combined label", () => {
const fragment = generateFragmentFromHtml(`
<style>
@media (min-width: 768px) and (max-width: 1024px) {
.card { display: flex; }
}
</style>
<div class="card">Hello</div>
`);
const bp = fragment.breakpoints.find(
(b) => b.minWidth === 768 && b.maxWidth === 1024
);
expect(bp).toBeDefined();
expect(bp!.label).toBe("≥ 768px and ≤ 1024px");
});
});
describe("complex real-world scenarios", () => {
test("responsive card component with hover states", () => {
const fragment = generateFragmentFromHtml(`
<style>
.card {
display: flex;
flex-direction: column;
padding: 16px;
border-radius: 8px;
}
.card:hover {
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
}
@media (min-width: 768px) {
.card {
flex-direction: row;
padding: 24px;
}
}
.card-title {
font-size: 18px;
font-weight: bold;
}
@media (min-width: 768px) {
.card-title {
font-size: 24px;
}
}
</style>
<div class="card">
<h2 class="card-title">Title</h2>
<p>Description</p>
</div>
`);
// both tokens should be created
const cardToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
);
const titleToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card-title"
);
expect(cardToken).toBeDefined();
expect(titleToken).toBeDefined();
// card should have hover state
expect(
fragment.styles.some(
(s) => s.styleSourceId === cardToken!.id && s.state === ":hover"
)
).toBe(true);
// card should have breakpoint styles
const cardBreakpoints = new Set(
fragment.styles
.filter((s) => s.styleSourceId === cardToken!.id && !s.state)
.map((s) => s.breakpointId)
);
expect(cardBreakpoints.size).toBeGreaterThanOrEqual(2);
// title should have breakpoint styles
const titleBreakpoints = new Set(
fragment.styles
.filter((s) => s.styleSourceId === titleToken!.id)
.map((s) => s.breakpointId)
);
expect(titleBreakpoints.size).toBeGreaterThanOrEqual(2);
// no HtmlEmbed (all rules are class-based)
expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
false
);
});
test("html with mixed class rules, id rules, keyframes, and media queries", () => {
const fragment = generateFragmentFromHtml(`
<style>
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}
.fade-in { animation: fadeIn 0.3s ease-in; }
.card { display: flex; }
#app { min-height: 100vh; }
@media (min-width: 768px) {
.card { flex-direction: row; }
}
</style>
<div class="card fade-in">
<p>Hello</p>
</div>
`);
// class tokens should be extracted
expect(
fragment.styleSources.find(
(s) => s.type === "token" && s.name === "card"
)
).toBeDefined();
expect(
fragment.styleSources.find(
(s) => s.type === "token" && s.name === "fade-in"
)
).toBeDefined();
// @keyframes and #app should remain as html embed
const htmlEmbed = fragment.instances.find(
(i) => i.component === "HtmlEmbed"
);
expect(htmlEmbed).toBeDefined();
const codeProp = fragment.props.find(
(p) => p.instanceId === htmlEmbed!.id && p.name === "code"
);
expect(codeProp!.type === "string" && codeProp!.value).toContain(
"@keyframes"
);
expect(codeProp!.type === "string" && codeProp!.value).toContain("#app");
});
test("navigation component with multiple states and breakpoints", () => {
const fragment = generateFragmentFromHtml(`
<style>
.nav { display: flex; gap: 8px; }
.nav-link { color: gray; text-decoration: none; }
.nav-link:hover { color: blue; }
.nav-link:focus { outline: 2px solid blue; }
.nav-link::after { content: ""; display: block; height: 2px; }
@media (min-width: 768px) {
.nav { gap: 16px; }
.nav-link { font-size: 16px; }
}
</style>
<nav class="nav">
<a class="nav-link">Home</a>
<a class="nav-link">About</a>
</nav>
`);
const navToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "nav"
);
const linkToken = fragment.styleSources.find(
(s) => s.type === "token" && s.name === "nav-link"
);
expect(navToken).toBeDefined();
expect(linkToken).toBeDefined();
// nav-link should have hover, focus, and ::after states
const linkStates = new Set(
fragment.styles
.filter((s) => s.styleSourceId === linkToken!.id && s.state)
.map((s) => s.state)
);
expect(linkStates.has(":hover")).toBe(true);
expect(linkStates.has(":focus")).toBe(true);
expect(linkStates.has("::after")).toBe(true);
// both should have breakpoint styles
const navBreakpoints = new Set(
fragment.styles
.filter((s) => s.styleSourceId === navToken!.id)
.map((s) => s.breakpointId)
);
expect(navBreakpoints.size).toBeGreaterThanOrEqual(2);
// nav-link token should be reused for both <a> elements
const linkSelections = fragment.styleSourceSelections.filter((sel) =>
sel.values.includes(linkToken!.id)
);
expect(linkSelections).toHaveLength(2);
});
});
describe("nested selectors", () => {
test("resolve descendant selector to matching element", () => {
const cardInnerToken = token(
"card__inner",
css`
color: red;
`
);
expect(
generateFragmentFromHtml(`
<style>.card .inner { color: red; }</style>
<div class="card"><span class="inner">Hello</span></div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" class="card">
<ws.element ws:tag="span" ws:tokens={[cardInnerToken]}>
Hello
</ws.element>
</ws.element>
)
);
});
test("resolve child combinator to direct child", () => {
const parentChildToken = token(
"parent__child",
css`
margin: 0;
`
);
expect(
generateFragmentFromHtml(`
<style>.parent > .child { margin: 0; }</style>
<div class="parent"><span class="child">Hello</span></div>
`)
).toEqual(
renderTemplate(
<ws.element ws:tag="div" class="parent">
<ws.element ws:tag="span" ws:tokens={[parentChildToken]}>
Hello
</ws.element>
</ws.element>
)
);
});
test("child combinator does not match non-direct child", () => {
const result = _generateFragmentFromHtml(`
<style>.parent > .child { color: red; }</style>
<div class="parent"><div><span class="child">Hello</span></div></div>
`);
// .child is nested inside an intermediate div, not a direct child of .parent
expect(result.skippedSelectors).toEqual([".parent > .child"]);
// no token created for the nested rule
expect(
result.styleSources.filter((s) => s.type === "token")
).toHaveLength(0);
});
test("skip unresolved nested selector and report it", () => {
const result = _generateFragmentFromHtml(`
<style>.card .title { color: red; }</style>
<div class="card"><span>No title class here</span></div>
`);
expect(result.skippedSelectors).toEqual([".card .title"]);
expect(
result.styleSources.filter((s) => s.type === "token")
).toHaveLength(0);
});
test("style-only paste with nested selector — all skipped", () => {
const result = _generateFragmentFromHtml(`
<style>.card .title { color: red; }</style>
`);
expect(result.skippedSelectors).toEqual([".card .title"]);
expect(result.styleSources).toHaveLength(0);
});
test("mixed simple and nested selectors", () => {
const result = _generateFragmentFromHtml(`
<style>
.card { display: flex; }
.card .title { font-weight: bold; }
</style>
<div class="card"><h1 class="title">Hello</h1></div>
`);
expect(result.skippedSelectors).toEqual([]);
// .card token + .card__title nested token
const tokenNames = result.styleSources
.filter((s) => s.type === "token")
.map((s) => s.name);
expect(tokenNames).toContain("card");
expect(tokenNames).toContain("card__title");
});
test("multiple ancestors: .a .b .c", () => {
const result = _generateFragmentFromHtml(`
<style>.a .b .c { color: red; }</style>
<div class="a"><div class="b"><span class="c">Hi</span></div></div>
`);
expect(result.skippedSelectors).toEqual([]);
const tokenNames = result.styleSources
.filter((s) => s.type === "token")
.map((s) => s.name);
expect(tokenNames).toContain("a__b__c");
});
test("nested selector with media query", () => {
const result = _generateFragmentFromHtml(`
<style>
.card .title { color: red; }
@media (min-width: 768px) {
.card .title { color: blue; }
}
</style>
<div class="card"><h1 class="title">Hello</h1></div>
`);
expect(result.skippedSelectors).toEqual([]);
const nestedToken = result.styleSources.find(
(s) => s.type === "token" && s.name === "card__title"
);
expect(nestedToken).toBeDefined();
// should have styles at base breakpoint and 768px breakpoint
const nestedStyles = result.styles.filter(
(s) => s.styleSourceId === nestedToken!.id
);
const breakpointIds = new Set(nestedStyles.map((s) => s.breakpointId));
expect(breakpointIds.size).toBe(2);
});
test("sibling combinators stay as leftover", () => {
const result = _generateFragmentFromHtml(`
<style>.a + .b { color: red; }</style>
<div class="a">A</div><div class="b">B</div>
`);
// sibling selector is not class-based → stays as HtmlEmbed
expect(result.instances.some((i) => i.component === "HtmlEmbed")).toBe(
true
);
});
});
test("resolves cross-rule CSS variable in background shorthand", () => {
// --clr-red is defined in .my-parent but used in .my-child.
// background: var(--clr-red) must expand to background-color with the
// var() reference preserved — NOT inlined to the concrete color #f00.
const result = _generateFragmentFromHtml(`
<style>
.my-parent { --clr-red: #f00; }
.my-child { background: var(--clr-red); }
</style>
<div class="my-parent">
<div class="my-child">test</div>
</div>
`);
const childToken = result.styleSources.find(
(s) => s.type === "token" && s.name === "my-child"
);
expect(childToken).toBeDefined();
const bgColor = result.styles.find(
(s) =>
s.styleSourceId === childToken!.id && s.property === "backgroundColor"
);
// Must be a var() reference, not a concrete inlined color
expect(bgColor?.value).toEqual(
expect.objectContaining({ type: "var", value: "clr-red" })
);
});
describe("preserve border color var() references", () => {
const getTokenStyle = (
fragment: WebstudioFragment,
tokenName: string,
property: string
) => {
const tokenSource = fragment.styleSources.find(
(source) => source.type === "token" && source.name === tokenName
);
expect(tokenSource).toBeDefined();
return fragment.styles.find(
(style) =>
style.styleSourceId === tokenSource!.id && style.property === property
);
};
const getSelection = (fragment: WebstudioFragment, instanceId: string) => {
return fragment.styleSourceSelections.find(
(selection) => selection.instanceId === instanceId
);
};
test("typed arbitrary color utility keeps var reference", () => {
const fragment = _generateFragmentFromHtml(`
<style>
.border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
.border-\\[color\\:var\\(--border-color\\)\\] { border-color: var(--border-color); }
</style>
<div class="p-8 border border-[color:var(--border-color)]"></div>
`);
const borderColorStyle = getTokenStyle(
fragment,
"border-[color:var(--border-color)]",
"borderTopColor"
);
expect(borderColorStyle?.value).toEqual(
expect.objectContaining({ type: "var", value: "border-color" })
);
});
test("css variable shorthand utility keeps var reference", () => {
const fragment = _generateFragmentFromHtml(`
<style>
.border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
.border-\\(--border-color\\) { border-color: var(--border-color); }
</style>
<div class="p-8 border border-(--border-color)"></div>
`);
const borderColorStyle = getTokenStyle(
fragment,
"border-(--border-color)",
"borderTopColor"
);
expect(borderColorStyle?.value).toEqual(
expect.objectContaining({ type: "var", value: "border-color" })
);
});
test("inline border-color style keeps var reference", () => {
const fragment = _generateFragmentFromHtml(`
<style>
.border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
</style>
<div class="p-8 border" style="border-color: var(--border-color)"></div>
`);
const divInstance = fragment.instances.find(
(instance) => instance.tag === "div"
);
expect(divInstance).toBeDefined();
expect(getSelection(fragment, divInstance!.id)?.values).toEqual([
expect.any(String),
`${divInstance!.id}:ws:style`,
]);
const localStyle = fragment.styles.find(
(style) =>
style.styleSourceId === `${divInstance!.id}:ws:style` &&
style.property === "borderTopColor"
);
expect(localStyle?.value).toEqual(
expect.objectContaining({ type: "var", value: "border-color" })
);
});
test("arbitrary property utility keeps var reference", () => {
const fragment = _generateFragmentFromHtml(`
<style>
.border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
.\\[border-color\\:var\\(--border-color\\)\\] { border-color: var(--border-color); }
</style>
<div class="p-8 border [border-color:var(--border-color)]"></div>
`);
const borderColorStyle = getTokenStyle(
fragment,
"[border-color:var(--border-color)]",
"borderTopColor"
);
expect(borderColorStyle?.value).toEqual(
expect.objectContaining({ type: "var", value: "border-color" })
);
});
test("typed literal utility keeps literal color", () => {
const fragment = _generateFragmentFromHtml(`
<style>
.border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
.border-\\[color\\:\\#000\\] { border-color: #000; }
</style>
<div class="p-8 border border-[color:#000]"></div>
`);
const borderColorStyle = getTokenStyle(
fragment,
"border-[color:#000]",
"borderTopColor"
);
expect(borderColorStyle?.value).toEqual(
expect.objectContaining({ type: "color", colorSpace: "hex" })
);
});
test("border side utility with var color keeps var reference", () => {
const fragment = _generateFragmentFromHtml(`
<style>
.border-t { border-top-width: 1px; border-top-style: solid; border-color: #e5e7eb; }
.border-\\[color\\:var\\(--border-color\\)\\] { border-color: var(--border-color); }
</style>
<div class="p-8 border-t border-[color:var(--border-color)]"></div>
`);
const borderColorStyle = getTokenStyle(
fragment,
"border-[color:var(--border-color)]",
"borderTopColor"
);
expect(borderColorStyle?.value).toEqual(
expect.objectContaining({ type: "var", value: "border-color" })
);
});
test("inline border shorthand keeps var color reference", () => {
const fragment = _generateFragmentFromHtml(`
<style>
.border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
</style>
<div class="p-8 border" style="border: 1px solid var(--border-color)"></div>
`);
const divInstance = fragment.instances.find(
(instance) => instance.tag === "div"
);
expect(divInstance).toBeDefined();
expect(getSelection(fragment, divInstance!.id)?.values).toEqual([
expect.any(String),
`${divInstance!.id}:ws:style`,
]);
const localStyle = fragment.styles.find(
(style) =>
style.styleSourceId === `${divInstance!.id}:ws:style` &&
style.property === "borderTopColor"
);
expect(localStyle?.value).toEqual(
expect.objectContaining({ type: "var", value: "border-color" })
);
});
});
});