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 { API, type Snapshot } from "typescript/unstable/sync";
import { afterAll, beforeAll, expect, test } from "vitest";
import stripIndent from "strip-indent";
import { transform } from "esbuild";
import { createElement, Fragment as ReactFragment } from "react";
import { renderToStaticMarkup } from "react-dom/server";
import { renderText } from "./context";
import { standardAttributesToReactProps } from "@webstudio-is/content-engine/jsx-attributes";
import {
createScope,
collectionComponent,
encodeDataVariableId,
formatManagedFormErrors,
elementComponent,
ROOT_INSTANCE_ID,
SYSTEM_VARIABLE_ID,
type WsComponentMeta,
} from "@webstudio-is/sdk";
import {
createTemplateComponentFixture,
ActionValue,
AssetValue,
PageValue,
Parameter,
ResourceValue,
Variable,
expression,
renderData,
ws,
} from "@webstudio-is/template";
import {
generateJsxChildren,
generateWebstudioComponent,
} from "./component-generator";
import {
generateManagedFormComponent,
generateManagedFormJsxChildren,
} from "./managed-form-component-generator";
const Body = createTemplateComponentFixture("Body");
const Box = createTemplateComponentFixture("Box");
const Button = createTemplateComponentFixture("Button");
const ResourceForm = createTemplateComponentFixture("ResourceForm");
const Fragment = createTemplateComponentFixture("Fragment");
const HeadSlot = createTemplateComponentFixture("HeadSlot");
const Heading = createTemplateComponentFixture("Heading");
const Image = createTemplateComponentFixture("Image");
const Input = createTemplateComponentFixture("Input");
const Label = createTemplateComponentFixture("Label");
const Tabs = createTemplateComponentFixture("Tabs");
const TabsContent = createTemplateComponentFixture("TabsContent");
const TabsList = createTemplateComponentFixture("TabsList");
const TabsTrigger = createTemplateComponentFixture("TabsTrigger");
const Text = createTemplateComponentFixture("Text");
const Vimeo = createTemplateComponentFixture("Vimeo");
const virtualRoot = "/component-generator-test";
test("string props coerce repeated query values without changing missing values", () => {
const tags = new Variable("Selected Tags", ["red", "blue"]);
const generated = generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map<string, WsComponentMeta>([
[
"Input",
{
props: {
placeholder: {
type: "string",
control: "text",
required: false,
contentMode: true,
},
},
},
],
]),
...renderData(
<Body ws:id="body">
<Input ws:id="input" placeholder={expression`${tags}`} />
</Body>
),
});
expect(generated).toContain("String(SelectedTags)");
expect(generated).toContain("SelectedTags == null ? SelectedTags");
expect(isValidJSX(generated)).toBe(true);
});
test("json-code props keep object expressions as objects", () => {
const code = new Variable("code", { "@type": "Article" });
const JsonLd = createTemplateComponentFixture("JsonLd");
const generated = generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map<string, WsComponentMeta>([
[
"JsonLd",
{
props: {
code: { type: "string", control: "json-code", required: true },
},
},
],
]),
...renderData(
<Body ws:id="body">
<JsonLd ws:id="jsonld" code={expression`${code}`} />
</Body>
),
});
expect(generated).toContain("code={code}");
expect(generated).not.toContain("String(code)");
expect(isValidJSX(generated)).toBe(true);
});
test("Form submission parameters are unavailable during page render", () => {
const formData = new Parameter("formData");
const browserInfo = new Parameter("browserInfo");
const generated = generateManagedFormComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<ResourceForm
ws:id="form"
formData={formData}
browserInfo={browserInfo}
/>
</Body>
),
});
expect(generated).toContain("const formData: any = undefined");
expect(generated).toContain("const browserInfo: any = undefined");
expect(isValidJSX(generated)).toBe(true);
});
test("managed Forms own their server identity after custom props and action deduplication", () => {
const data = renderData(
<Body ws:id="body">
<ResourceForm ws:id="form" />
</Body>
);
data.props.set("custom-id", {
id: "custom-id",
instanceId: "form",
name: "data-ws-managed-form-id",
type: "string",
value: "spoofed",
});
const generate = (managed: boolean) =>
(managed ? generateManagedFormComponent : generateWebstudioComponent)({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...data,
});
expect(generate(false)).toContain('data-ws-managed-form-id={"spoofed"}');
expect(generate(true)).not.toContain("data-ws-managed-form-id");
data.props.set("action", {
id: "action",
instanceId: "form",
name: "action",
type: "json",
value: [{ dataSourceId: "request" }],
});
const managed = generate(true);
expect(managed.match(/data-ws-managed-form-id/g)).toHaveLength(1);
expect(managed).toContain('data-ws-managed-form-id="form"');
expect(managed).not.toContain("spoofed");
expect(isValidJSX(managed)).toBe(true);
data.props.set("later-action", {
id: "later-action",
instanceId: "form",
name: "action",
type: "json",
value: { destinations: ["request"] },
});
expect(generate(true)).not.toContain("data-ws-managed-form-id");
data.props.set("final-action", {
id: "final-action",
instanceId: "form",
name: "action",
type: "json",
value: [{ dataSourceId: "final" }],
});
expect(generate(true)).toContain('data-ws-managed-form-id="form"');
});
test("managed Form policy applies to a root Form and leaves other elements' props intact", () => {
const data = renderData(
<Body ws:id="body">
<ResourceForm ws:id="form" />
<Box ws:id="box" />
</Body>
);
data.props.set("form-id", {
id: "form-id",
instanceId: "form",
name: "data-ws-managed-form-id",
type: "string",
value: "spoofed",
});
data.props.set("box-id", {
id: "box-id",
instanceId: "box",
name: "data-ws-managed-form-id",
type: "string",
value: "ordinary",
});
data.props.set("action", {
id: "action",
instanceId: "form",
name: "action",
type: "json",
value: [{ dataSourceId: "request" }],
});
const generate = (rootInstanceId: string) =>
generateManagedFormComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId,
parameters: [],
metas: new Map(),
...data,
});
const root = generate("form");
expect(root.match(/data-ws-managed-form-id/g)).toHaveLength(1);
expect(root).toContain('data-ws-managed-form-id="form"');
expect(root).not.toContain("spoofed");
const nested = generate("body");
expect(nested).toContain('data-ws-managed-form-id={"ordinary"}');
expect(nested).toContain('data-ws-managed-form-id="form"');
expect(isValidJSX(nested)).toBe(true);
});
const virtualConfig = `${virtualRoot}/tsconfig.json`;
const virtualFile = `${virtualRoot}/virtual.tsx`;
let virtualCode = "";
const typeScriptApi = new API({
cwd: virtualRoot,
fs: {
readFile(fileName) {
if (fileName === virtualConfig) {
return JSON.stringify({
compilerOptions: { jsx: "preserve", strict: true },
files: [virtualFile],
});
}
if (fileName === virtualFile) {
return virtualCode;
}
},
fileExists(fileName) {
return fileName === virtualConfig || fileName === virtualFile;
},
directoryExists(directoryName) {
return directoryName === virtualRoot;
},
},
});
let typeScriptSnapshot: Snapshot;
beforeAll(() => {
typeScriptSnapshot = typeScriptApi.updateSnapshot({
openProjects: [virtualConfig],
});
});
afterAll(() => {
typeScriptSnapshot.dispose();
typeScriptApi.close();
});
const isValidJSX = (code: string): boolean => {
virtualCode = code;
const previousSnapshot = typeScriptSnapshot;
typeScriptSnapshot = typeScriptApi.updateSnapshot({
fileChanges: { changed: [virtualFile] },
});
previousSnapshot.dispose();
const project = typeScriptSnapshot.getProject(virtualConfig);
return project?.program.getSyntacticDiagnostics(virtualFile).length === 0;
};
const validateJSX = (code: string) => {
expect(isValidJSX(code)).toBeTruthy();
return code;
};
const clear = (input: string) =>
stripIndent(input).trimStart().replace(/ +$/, "");
const toMap = <T extends { id: string }>(list: T[]) =>
new Map(list.map((item) => [item.id, item] as const));
test("generate jsx element with children and without them", () => {
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "body" }],
...renderData(<Body ws:id="body">Children</Body>),
})
).toEqual(
validateJSX(
clear(`
<Body>
{"Children"}
</Body>
`)
)
);
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "image" }],
...renderData(<Image ws:id="image"></Image>),
})
).toEqual(
validateJSX(
clear(`
<Image />
`)
)
);
});
test("generate jsx element with a namespaced component", () => {
const LibraryBody = createTemplateComponentFixture(
"@webstudio-is/library:Body"
);
const LibraryImage = createTemplateComponentFixture(
"@webstudio-is/library:Image"
);
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "body" }],
...renderData(<LibraryBody ws:id="body"></LibraryBody>),
})
).toEqual(
validateJSX(
clear(`
<Body />
`)
)
);
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "image" }],
...renderData(<LibraryImage ws:id="image"></LibraryImage>),
})
).toEqual(
validateJSX(
clear(`
<Image />
`)
)
);
});
test("generate jsx element with literal props", () => {
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "body" }],
...renderData(<Body ws:id="body" string="string" number={0}></Body>),
})
).toEqual(
validateJSX(
clear(`
<Body
string={"string"}
number={0} />
`)
)
);
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "image" }],
...renderData(
<Image
ws:id="image"
boolean={true}
stringArray={["value1", "value2"]}
></Image>
),
})
).toEqual(
validateJSX(
clear(`
<Image
boolean={true}
stringArray={["value1","value2"]} />
`)
)
);
});
test("deduplicates duplicate instance props when generating jsx", () => {
const data = renderData(<Image ws:id="image" width={100}></Image>);
const widthProp = Array.from(data.props.values()).find(
(prop) => prop.instanceId === "image" && prop.name === "width"
);
if (widthProp?.type !== "number") {
throw new Error("Expected Image width prop");
}
data.props.set("duplicate-width", {
...widthProp!,
id: "duplicate-width",
value: 200,
});
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "image" }],
...data,
})
).toEqual(
validateJSX(
clear(`
<Image
width={200} />
`)
)
);
});
test("ignore asset and page props", () => {
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "box" }],
...renderData(
<Box
ws:id="box"
page={new PageValue("pageId")}
asset={new AssetValue("assetId")}
></Box>
),
})
).toEqual(
validateJSX(
clear(`
<Box />
`)
)
);
});
test("generate jsx element with data sources and action", () => {
const variable = new Variable("variable", 0);
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "box" }],
...renderData(
<Box
ws:id="box"
variable={expression`${variable}`}
expression={expression`${variable} + 1`}
onChange={new ActionValue(["value"], expression`${variable} = value`)}
></Box>
),
})
).toEqual(
validateJSX(
clear(`
<Box
variable={variable}
expression={variable + 1}
onChange={(value: any) => {
variable = value
set$variable(variable)
}} />
`)
)
);
});
test("generate jsx element with condition based on show prop", () => {
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "box" }],
...renderData(<Box ws:id="box" data-ws-show={true}></Box>),
})
).toEqual(
validateJSX(
clear(`
<Box />
`)
)
);
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "box" }],
...renderData(<Box ws:id="box" data-ws-show={false}></Box>),
})
).toEqual("");
const condition = new Variable("condition", false);
expect(
generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "box" }],
...renderData(
<Box ws:id="box" data-ws-show={expression`${condition}`}></Box>
),
})
).toEqual(
validateJSX(
clear(`
{(condition) &&
<Box />
}
`)
)
);
});
test("generate jsx children with text", () => {
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map(),
children: [
{ type: "text", value: "Some\ntext" },
{ type: "text", value: 'Escaped "text"' },
],
instances: new Map(),
props: new Map(),
dataSources: new Map(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
})
).toEqual(
validateJSX(
clear(`
{"Some"}
<br />
{"text"}
{"Escaped \\"text\\""}
`)
)
);
});
test("exclude text placeholders", () => {
expect(
generateManagedFormJsxChildren({
scope: createScope(),
metas: new Map(),
children: [
{ type: "text", value: "Text" },
{ type: "text", value: "Placeholder text", placeholder: true },
],
instances: new Map(),
props: new Map(),
dataSources: new Map(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
excludePlaceholders: true,
})
).toEqual(
validateJSX(
clear(`
{"Text"}
`)
)
);
});
test("generate jsx children with expression", () => {
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map(),
children: [
{ type: "expression", value: "'Hello ' + $ws$dataSource$var" },
],
instances: new Map(),
props: new Map(),
dataSources: toMap([
{
id: "var",
scopeInstanceId: "body",
name: "my var",
type: "variable",
value: { type: "string", value: "world" },
},
]),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
})
).toEqual(
validateJSX(
clear(`
{renderText('Hello ' + myvar)}
`)
)
);
});
test("preserves siblings before expression children", () => {
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map(),
children: [
{ type: "id", value: "strong" },
{ type: "expression", value: "$ws$dataSource$var" },
],
instances: new Map([
[
"strong",
{
type: "instance",
id: "strong",
component: "Text",
tag: "strong",
children: [{ type: "text", value: "Important: " }],
},
],
]),
props: new Map(),
dataSources: toMap([
{
id: "var",
scopeInstanceId: "body",
name: "message",
type: "variable",
value: { type: "string", value: "Details" },
},
]),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
})
).toEqual(
validateJSX(
clear(`
<Text
data-ws-tag="strong">
{"Important: "}
</Text>
{renderText(message)}
`)
)
);
});
test("generate jsx children with nested instances", () => {
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map(),
children: [{ type: "id", value: "form" }],
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
...renderData(
<ResourceForm ws:id="form" prop="value">
<Input></Input>
<Button></Button>
</ResourceForm>
),
})
).toEqual(
validateJSX(
clear(`
<ResourceForm
prop={"value"}>
<Input />
<Button />
</ResourceForm>
`)
)
);
});
test("a generic policy can resolve an instance to an empty element", () => {
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map(),
children: [{ type: "id", value: "box" }],
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
policy: {
resolveInstance: (instance) => ({ ...instance, children: [] }),
},
...renderData(<Box ws:id="box">Authored text</Box>),
})
).toEqual(validateJSX("<Box />\n"));
});
test("deduplicate base and namespaced components with same short name", () => {
const RadixButton = createTemplateComponentFixture(
"@webstudio-is/sdk-component-react-radix:Button"
);
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map(),
children: [
{ type: "id", value: "button1" },
{ type: "id", value: "button2" },
],
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
...renderData(
<Fragment>
<Button ws:id="button1"></Button>
<RadixButton ws:id="button2"></RadixButton>
</Fragment>
),
})
).toEqual(
clear(`
<Button />
<Button_1 />
`)
);
});
test("generate collection component as map", () => {
const data = new Variable("data", ["apple", "orange", "mango"]);
const element = new Parameter("element");
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map(),
children: [{ type: "id", value: "list" }],
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
...renderData(
<ws.collection ws:id="list" data={expression`${data}`} item={element}>
<Label></Label>
<Button aria-label={expression`${element}`}></Button>
</ws.collection>
),
})
).toEqual(
validateJSX(
clear(`
{Object.entries(
// @ts-ignore
data ?? {}
).map(([_key, element]: any) => {
const index = Array.isArray(data) ? Number(_key) : _key;
return (
<Fragment key={index}>
<Label />
<Button
aria-label={element} />
</Fragment>
)
})
}
`)
)
);
});
test("generate collection component with itemKey", () => {
const data = new Variable("data", { a: "apple", b: "orange" });
const element = new Parameter("element");
const key = new Parameter("key");
expect(
generateJsxChildren({
scope: createScope(),
metas: new Map<string, WsComponentMeta>([
[
collectionComponent,
{
props: {
item: {
type: "string",
control: "text",
required: false,
},
itemKey: {
type: "string",
control: "text",
required: false,
},
},
},
],
]),
children: [{ type: "id", value: "list" }],
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
...renderData(
<ws.collection
ws:id="list"
data={expression`${data}`}
item={element}
itemKey={key}
>
<Label>{expression`${key}`}</Label>
<Button aria-label={expression`${element}`}></Button>
</ws.collection>
),
})
).toEqual(
validateJSX(
clear(`
{Object.entries(
// @ts-ignore
data ?? {}
).map(([_key, element]: any) => {
const key = Array.isArray(data) ? Number(_key) : _key;
return (
<Fragment key={key}>
<Label>
{renderText(key)}
</Label>
<Button
aria-label={element} />
</Fragment>
)
})
}
`)
)
);
});
test("generate component with variables and actions", () => {
const variable = new Variable("variable", "initial");
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<Input
value={expression`${variable}`}
onChange={
new ActionValue(["value"], expression`${variable} = value`)
}
/>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
let [variable, set$variable] = useVariableState<any>("initial")
return <Body>
<Input
value={variable}
onChange={(value: any) => {
variable = value
set$variable(variable)
}} />
</Body>
}
`)
)
);
});
test("merge classes if no className", () => {
expect(
generateWebstudioComponent({
classesMap: new Map([["body", ["cls1"]]]),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(<Body ws:id="body"></Body>),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body
className={\`cls1\`} />
}
`)
)
);
});
test("add classes and merge classes", () => {
expect(
generateWebstudioComponent({
classesMap: new Map([["body", ["cls1"]]]),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(<Body ws:id="body" className='cls2 "cls3"'></Body>),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body
className={\`cls1 \${"cls2 \\"cls3\\""}\`} />
}
`)
)
);
});
test("add classes", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(<Body ws:id="body" className='cls2 "cls3"'></Body>),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body
className={\`\${"cls2 \\"cls3\\""}\`} />
}
`)
)
);
});
test("merges class aliases when generating jsx", () => {
const data = renderData(<Body ws:id="body" className="standard"></Body>);
data.props.set("duplicate-class", {
id: "duplicate-class",
instanceId: "body",
name: "class",
type: "string",
value: "replacement",
});
data.props.set("legacy-class-name", {
id: "legacy-class-name",
instanceId: "body",
name: "className",
type: "string",
value: "legacy",
});
expect(
generateWebstudioComponent({
classesMap: new Map([["body", ["atomic"]]]),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...data,
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body
className={\`atomic \${"replacement"} \${"legacy"}\`} />
}
`)
)
);
});
test.each(
Object.entries(standardAttributesToReactProps).filter(
([standardName, jsxName]) =>
standardName !== "class" && standardName !== jsxName
)
)(
"keeps the last value when %s and %s map to the same JSX prop",
(standardName, jsxName) => {
const generate = (attributes: [name: string, value: string][]) => {
const data = renderData(<Body ws:id="body"></Body>);
const instance = data.instances.get("body");
if (instance === undefined) {
throw new Error("Expected Body instance");
}
data.instances.set("body", { ...instance, tag: "div" });
for (const [index, [name, value]] of attributes.entries()) {
data.props.set(`${index}-${name}`, {
id: `${index}-${name}`,
instanceId: "body",
name,
type: "string",
value,
});
}
return generateJsxChildren({
scope: createScope(),
usedDataSources: new Map(),
indexesWithinAncestors: new Map(),
metas: new Map(),
children: [{ type: "id", value: "body" }],
...data,
});
};
const expected = (value: string) =>
clear(`
<Body
data-ws-tag="div"
${jsxName}={"${value}"} />
`);
expect(
generate([
[standardName, "standard"],
[jsxName, "jsx"],
])
).toBe(expected("jsx"));
expect(
generate([
[jsxName, "jsx"],
[standardName, "standard"],
])
).toBe(expected("standard"));
}
);
test("add bind classes and merge classes", () => {
const hasClass2 = new Variable("variableName", false);
expect(
generateWebstudioComponent({
classesMap: new Map([["body", ["cls1"]]]),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body
ws:id="body"
className={expression`${hasClass2} ? 'cls2' : ''`}
></Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
let [variableName, set$variableName] = useVariableState<any>(false)
return <Body
className={\`cls1 \${variableName ? 'cls2' : ''}\`} />
}
`)
)
);
});
test("avoid generating collection parameter variable as state", () => {
const data = new Variable("data", ["apple", "orange", "mango"]);
const element = new Parameter("element");
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<ws.collection
ws:id="list"
data={expression`${data}`}
item={element}
></ws.collection>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
let [data, set$data] = useVariableState<any>(["apple","orange","mango"])
return <Body>
{Object.entries(
// @ts-ignore
data ?? {}
).map(([_key, element]: any) => {
const index = Array.isArray(data) ? Number(_key) : _key;
return (
<Fragment key={index}>
</Fragment>
)
})
}
</Body>
}
`)
)
);
});
test("generate both page system and global system variables when present", () => {
const system = new Parameter("system");
const data = renderData(
<Body
ws:id="body"
data-page={expression`${system}.params.slug`}
data-global={expression`$ws$system.params.slug`}
></Body>
);
expect(data.dataSources.size).toEqual(1);
const [pageSystemVariableId] = data.dataSources.keys();
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(["system"]),
name: "Page",
rootInstanceId: "body",
parameters: [
{
id: "pathSystemPropId1",
type: "parameter",
instanceId: "",
name: "system",
value: pageSystemVariableId,
},
{
id: "pathSystemPropId2",
type: "parameter",
instanceId: "",
name: "system",
value: SYSTEM_VARIABLE_ID,
},
],
metas: new Map(),
...data,
})
).toEqual(
validateJSX(
clear(`
const Page = (_props: { system: any; }) => {
const system_1 = _props.system;
const system_2 = _props.system;
return <Body
data-page={system_1?.params?.slug}
data-global={system_2?.params?.slug} />
}
`)
)
);
});
test("generate resources loading", () => {
const dataVariable = new Variable("data", "data");
const dataResource = new ResourceValue("data", {
url: expression`""`,
method: "get",
searchParams: [],
headers: [],
});
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body
ws:id="body"
data-data={expression`${dataVariable}`}
data-resource={expression`${dataResource}`}
></Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
let [data, set$data] = useVariableState<any>("data")
let data_1 = useResource("data_2")
return <Body
data-data={data}
data-resource={data_1} />
}
`)
)
);
});
test("avoid generating unused variables", () => {
const usedVariable = new Variable("Used Variable Name", "initial");
const unusedVariable = new Variable("Unused Variable Name", "initial");
const unusedParameter = new Parameter("Unused Parameter Name");
const unusedResource = new ResourceValue("Unused Resource Name", {
url: expression`""`,
method: "get",
searchParams: [],
headers: [],
});
const data = renderData(
<Body
ws:id="body"
data-used={expression`${usedVariable}`}
data-unused={expression`${unusedVariable} ${unusedParameter} ${unusedResource}`}
></Body>
);
expect(Array.from(data.props.values())).toEqual([
expect.objectContaining({ name: "data-used" }),
expect.objectContaining({ name: "data-unused" }),
]);
// make variables unused
data.props.delete(Array.from(data.props.values())[1].id);
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [
{
id: "systemPropId",
type: "parameter",
instanceId: "",
name: "system",
value: "unusedParameterId",
},
],
metas: new Map(),
...data,
})
).toMatchInlineSnapshot(`
"const Page = (_props: { system: any; }) => {
let [UsedVariableName, set$UsedVariableName] = useVariableState<any>("initial")
return <Body
data-used={UsedVariableName} />
}
"
`);
});
test("avoid generating descendant component", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<ws.descendant></ws.descendant>
</Body>
),
})
).toMatchInlineSnapshot(`
"const Page = () => {
return <Body>
</Body>
}
"
`);
});
test("generate conditional collection", () => {
const condition = new Variable("condition", false);
const collectionItem = new Parameter("collectionItem");
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<ws.collection
ws:id="list"
data-ws-show={expression`${condition}`}
data={[]}
item={collectionItem}
></ws.collection>
</Body>
),
})
).toMatchInlineSnapshot(`
"const Page = () => {
let [condition, set$condition] = useVariableState<any>(false)
return <Body>
{(condition) &&
<>
{Object.entries(
// @ts-ignore
[]
).map(([_key, collectionItem]: any) => {
const index = Array.isArray([]) ? Number(_key) : _key;
return (
<Fragment key={index}>
</Fragment>
)
})
}
</>
}
</Body>
}
"
`);
});
test("generate conditional body", () => {
const condition = new Variable("condition", false);
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body" data-ws-show={expression`${condition}`}></Body>
),
})
).toMatchInlineSnapshot(`
"const Page = () => {
let [condition, set$condition] = useVariableState<any>(false)
return (condition) &&
<Body />
}
"
`);
});
test("generate resource prop with configured form method", () => {
const myResource = new ResourceValue("myResource", {
url: expression`"https://my-url.com?with-secret"`,
method: "post",
searchParams: [],
headers: [],
});
const anotherResource = new ResourceValue("anotherResource", {
url: expression`"https://another-url.com?with-secret"`,
method: "get",
searchParams: [],
headers: [],
});
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map([
[
"ResourceForm",
{
props: {
action: {
control: "resource",
type: "resource",
required: false,
generatedProps: ["method"],
},
},
},
],
]),
...renderData(
<Body ws:id="body">
<ResourceForm ws:id="form1" action={myResource}></ResourceForm>
<ResourceForm ws:id="form2" action={anotherResource}></ResourceForm>
<ResourceForm
ws:id="form3"
action={myResource}
method="get"
></ResourceForm>
</Body>
),
})
).toMatchInlineSnapshot(`
"const Page = () => {
return <Body>
<ResourceForm
action={"action"}
method={"post"} />
<ResourceForm
action={"action_1"}
method={"get"} />
<ResourceForm
action={"action"}
method={"get"} />
</Body>
}
"
`);
});
test("skip unsafe properties", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body
ws:id="body"
{...{
"": "unsafe",
"1-numeric-unsafe": "unsafe",
"click.prevent": "unsafe",
}}
></Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body />
}
`)
)
);
});
test("variable names can be js identifiers", () => {
const variable = new Variable("switch", "initial");
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<Input
value={expression`${variable}`}
onChange={
new ActionValue(["value"], expression`${variable} = value`)
}
/>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
let [switch_, set$switch] = useVariableState<any>("initial")
return <Body>
<Input
value={switch_}
onChange={(value: any) => {
switch_ = value
set$switch(switch_)
}} />
</Body>
}
`)
)
);
});
test("renders nothing if only templates are present in block", () => {
const BlockTemplate = ws.blockTemplate;
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<ws.block ws:id="block">
<BlockTemplate>
<Box>Test</Box>
</BlockTemplate>
</ws.block>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
</Body>
}
`)
)
);
});
test("renders only block children", () => {
const BlockTemplate = ws.blockTemplate;
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<ws.block ws:id="block">
<BlockTemplate>
<Box>Test</Box>
</BlockTemplate>
<Box>Child0</Box>
</ws.block>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Box>
{"Child0"}
</Box>
</Body>
}
`)
)
);
});
test("generate unset variables as undefined", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="body">
<Box>{expression`a + b`}</Box>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Box>
{renderText(undefined + undefined)}
</Box>
</Body>
}
`)
)
);
});
test("generate global variables", () => {
const rootVariable = new Variable("rootVariable", "root");
const data = renderData(
<ws.root ws:id={ROOT_INSTANCE_ID} vars={expression`${rootVariable}`}>
<Body ws:id="body">
<Box>{expression`${rootVariable}`}</Box>
</Body>
</ws.root>
);
data.instances.delete(ROOT_INSTANCE_ID);
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...data,
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
let [rootVariable, set$rootVariable] = useVariableState<any>("root")
return <Body>
<Box>
{renderText(rootVariable)}
</Box>
</Body>
}
`)
)
);
});
test("ignore unused global variables", () => {
const rootVariable = new Variable("rootVariable", "root");
const data = renderData(
<ws.root ws:id={ROOT_INSTANCE_ID} vars={expression`${rootVariable}`}>
<Body ws:id="body">
<Box></Box>
</Body>
</ws.root>
);
data.instances.delete(ROOT_INSTANCE_ID);
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...data,
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Box />
</Body>
}
`)
)
);
});
test("generate prop with index within ancestor", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map<string, WsComponentMeta>([
["TabsTrigger", { indexWithinAncestor: "Tabs" }],
["TabsContent", { indexWithinAncestor: "Tabs" }],
]),
...renderData(
<Body ws:id="body">
<Tabs>
<TabsList>
<TabsTrigger></TabsTrigger>
<Box>
<TabsTrigger></TabsTrigger>
</Box>
</TabsList>
<Box>
<TabsContent></TabsContent>
</Box>
<TabsContent></TabsContent>
</Tabs>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Tabs>
<TabsList>
<TabsTrigger
data-ws-index="0" />
<Box>
<TabsTrigger
data-ws-index="1" />
</Box>
</TabsList>
<Box>
<TabsContent
data-ws-index="0" />
</Box>
<TabsContent
data-ws-index="1" />
</Tabs>
</Body>
}
`)
)
);
});
test("ignore ws:block-template when generate index attribute", () => {
const BlockTemplate = ws.blockTemplate;
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map<string, WsComponentMeta>([
["TabsTrigger", { indexWithinAncestor: "Tabs" }],
]),
...renderData(
<Body ws:id="bodyId">
<Tabs>
<BlockTemplate>
<TabsTrigger></TabsTrigger>
</BlockTemplate>
<Box>
<TabsTrigger></TabsTrigger>
</Box>
<TabsTrigger></TabsTrigger>
</Tabs>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Tabs>
<Box>
<TabsTrigger
data-ws-index="0" />
</Box>
<TabsTrigger
data-ws-index="1" />
</Tabs>
</Body>
}
`)
)
);
});
test("renders pre-materialized dynamic Content Block candidates without loading", () => {
const instances = new Map([
[
"body",
{
type: "instance" as const,
id: "body",
component: elementComponent,
tag: "main",
children: [{ type: "id" as const, value: "block" }],
},
],
[
"block",
{
type: "instance" as const,
id: "block",
component: "ws:block",
children: [],
},
],
[
"article-heading",
{
type: "instance" as const,
id: "article-heading",
component: elementComponent,
tag: "h1",
children: [{ type: "text" as const, value: "Article" }],
},
],
[
"other-heading",
{
type: "instance" as const,
id: "other-heading",
component: elementComponent,
tag: "h1",
children: [{ type: "text" as const, value: "Other" }],
},
],
]);
const generated = generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
instances,
props: new Map(),
dataSources: new Map(),
publishedContentBlocks: new Map([
[
"block",
{
sourceExpression: '"article"',
candidates: [
{
assetId: "article",
dependencyRevision: "article-revision",
children: [{ type: "id", value: "article-heading" }],
frontmatter: {},
},
{
assetId: "other",
dependencyRevision: "other-revision",
children: [{ type: "id", value: "other-heading" }],
frontmatter: {},
},
],
},
],
]),
});
expect(generated).toContain('contentSource === "article"');
expect(generated).toContain('contentSource === "other"');
expect(generated.split('("article")')).toHaveLength(2);
expect(generated).toContain("<h1>");
expect(generated).not.toContain("fetch(");
expect(isValidJSX(generated)).toBe(true);
});
test("renders a Content Block source inside its Collection item scope", async () => {
const collectionItem = new Parameter("collectionItem");
const data = renderData(
<Body ws:id="body">
<ws.collection
ws:id="collection"
data={[{ id: "article" }]}
item={collectionItem}
>
<ws.block ws:id="block" />
</ws.collection>
</Body>
);
const itemDataSource = Array.from(data.dataSources.values()).find(
({ name }) => name === "collectionItem"
);
expect(itemDataSource).toBeDefined();
const generated = generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "body",
parameters: [],
metas: new Map(),
...data,
publishedContentBlocks: new Map([
[
"block",
{
sourceExpression: `${encodeDataVariableId(itemDataSource!.id)}.id`,
candidates: [
{
assetId: "article",
dependencyRevision: "revision",
children: [{ type: "text", value: "Article body" }],
frontmatter: {},
},
],
},
],
]),
});
expect(generated).toContain("Article body");
expect(generated).toContain('contentSource === "article"');
expect(isValidJSX(generated)).toBe(true);
const { code } = await transform(generated, {
loader: "tsx",
jsxFactory: "createElement",
jsxFragment: "Fragment",
});
const Page = new Function(
"createElement",
"Fragment",
"Body",
`${code}return Page;`
)(createElement, ReactFragment, "main");
expect(renderToStaticMarkup(createElement(Page))).toContain("Article body");
});
test("renders a Content Block shell with candidate frontmatter and body", () => {
const document = new Parameter("document");
const visible = new Variable("visible", true);
const Block = ws.block;
const BlockBody = ws.contentBlockBody;
const data = renderData(
<Body ws:id="page">
<Block
ws:id="block"
document={document}
data-ws-show={expression`${visible}`}
>
<Heading ws:id="title">
{expression`${document}.frontmatter.title`}
</Heading>
<BlockBody ws:id="content" />
<Text ws:id="footer">Designed footer</Text>
</Block>
</Body>
);
data.instances.set("article-body", {
type: "instance",
id: "article-body",
component: elementComponent,
tag: "p",
children: [{ type: "text", value: "MDX body" }],
});
const generated = generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "page",
parameters: [],
metas: new Map(),
...data,
publishedContentBlocks: new Map([
[
"block",
{
bodyInstanceId: "content",
candidates: [
{
assetId: "article",
dependencyRevision: "revision",
children: [{ type: "id", value: "article-body" }],
frontmatter: { title: "Frontmatter title" },
},
],
},
],
]),
});
expect(generated).toContain("Frontmatter title");
expect(generated).toContain("document?.frontmatter?.title");
expect(generated).toContain("MDX body");
expect(generated).toContain("Designed footer");
expect(isValidJSX(generated)).toBe(true);
});
test("render empty component when no instances found", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "",
parameters: [],
metas: new Map(),
...renderData(<Body ws:id="bodyId"></Body>),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <></>
}
`)
)
);
});
test("render tag property on components", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="bodyId">
<Box ws:id="spanId" ws:tag="span"></Box>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Box
data-ws-tag="span" />
</Body>
}
`)
)
);
});
test("converts instance attributes when tag enables HTML attributes", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="bodyId">
<Box
ws:id="labelId"
ws:tag="label"
tabindex={0}
readonly={true}
></Box>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Box
data-ws-tag="label"
tabIndex={0}
readOnly={true} />
</Body>
}
`)
)
);
});
test("render ws:element component with div tag by default", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="bodyId">
<ws.element id="element1">
<ws.element id="element2"></ws.element>
</ws.element>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<div
id={"element1"}>
<div
id={"element2"} />
</div>
</Body>
}
`)
)
);
});
test("render ws:element component with ws:tag", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map(),
...renderData(
<Body ws:id="bodyId">
<ws.element ws:tag="p" id="paragraph">
<ws.element ws:tag="span" id="span"></ws.element>
</ws.element>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<p
id={"paragraph"}>
<span
id={"span"} />
</p>
</Body>
}
`)
)
);
});
test("render ws:element component with empty tag as div", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map(),
props: new Map(),
dataSources: new Map(),
instances: new Map([
[
"bodyId",
{
type: "instance",
id: "bodyId",
component: "Body",
children: [{ type: "id", value: "elementId" }],
},
],
[
"elementId",
{
type: "instance",
id: "elementId",
component: elementComponent,
tag: "",
children: [],
},
],
]),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<div />
</Body>
}
`)
)
);
});
test("convert attributes to react compatible when render ws:element", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map([[elementComponent, { presetStyle: { div: [] } }]]),
...renderData(
<Body ws:id="bodyId">
<ws.element
class="my-class"
for="my-id"
autocomplete="off"
></ws.element>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<div
htmlFor={"my-id"}
autoComplete={"off"}
className={\`\${"my-class"}\`} />
</Body>
}
`)
)
);
});
test("convert attributes to react compatible when render components with tags", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map([["Box", { presetStyle: { div: [] } }]]),
...renderData(
<Body ws:id="bodyId">
<Box class="my-class" for="my-id" autocomplete="off"></Box>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Box
htmlFor={"my-id"}
autoComplete={"off"}
className={\`\${"my-class"}\`} />
</Body>
}
`)
)
);
});
test("ignore props similar to standard attributes when react components defines them", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map([
[
"Vimeo",
{
presetStyle: { div: [] },
props: {
autoplay: { type: "boolean", control: "boolean", required: true },
},
},
],
]),
...renderData(
<Body ws:id="bodyId">
<Vimeo autoplay={true}></Vimeo>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Vimeo
autoplay={true} />
</Body>
}
`)
)
);
});
test("only converts the universal class alias on components without tags", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map([["HeadSlot", {}]]),
...renderData(
<Body ws:id="bodyId">
<HeadSlot class="my-class" for="my-id" autocomplete="off"></HeadSlot>
</Body>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<HeadSlot
for={"my-id"}
autocomplete={"off"}
className={\`\${"my-class"}\`} />
</Body>
}
`)
)
);
});
test("overrides some element tags with provided components", () => {
expect(
generateWebstudioComponent({
classesMap: new Map(),
scope: createScope(),
name: "Page",
rootInstanceId: "bodyId",
parameters: [],
metas: new Map([["HeadSlot", { icon: "" }]]),
tagsOverrides: {
body: "namespace:Body",
a: "namespace:Link",
},
...renderData(
<ws.element ws:tag="body" ws:id="bodyId">
<ws.element ws:tag="a"></ws.element>
<ws.element ws:tag="div"></ws.element>
</ws.element>
),
})
).toEqual(
validateJSX(
clear(`
const Page = () => {
return <Body>
<Link />
<div />
</Body>
}
`)
)
);
});
test("saved managed Form errors render like Preview for malformed values while preserving the authored element", async () => {
const slot: import("@webstudio-is/sdk").Instance = {
type: "instance",
id: "saved-error",
component: "ws:element",
tag: "div",
label: "Error Message",
children: [
{
type: "text",
placeholder: true,
value: "Sorry, something went wrong.",
},
],
};
const form: import("@webstudio-is/sdk").Instance = {
type: "instance",
id: "saved-form",
component: "ResourceForm",
children: [{ type: "id", value: slot.id }],
};
const dataSources: import("@webstudio-is/sdk").DataSources = new Map([
[
"saved-errors",
{
id: "saved-errors",
name: "errors",
scopeInstanceId: form.id,
type: "variable",
value: { type: "json", value: [] },
},
],
]);
const usedDataSources = new Map();
const usedRuntimeHelpers = new Set<
"renderText" | "formatManagedFormErrors"
>();
const resultAction: import("@webstudio-is/sdk").Prop = {
id: "result-action",
instanceId: form.id,
name: "onResultChange",
type: "action",
value: [
{
type: "execute",
args: ["result"],
code: `${encodeDataVariableId("saved-errors")} = result.errors`,
},
],
};
const generated = generateManagedFormJsxChildren({
scope: createScope(),
usedDataSources,
usedRuntimeHelpers,
indexesWithinAncestors: new Map(),
metas: new Map(),
props: new Map([[resultAction.id, resultAction]]),
children: [{ type: "id", value: form.id }],
instances: new Map([
[form.id, form],
[slot.id, slot],
]),
dataSources,
});
expect(usedRuntimeHelpers).toEqual(
new Set(["renderText", "formatManagedFormErrors"])
);
const { code } = await transform(`const Page = () => (${generated});`, {
loader: "tsx",
jsxFactory: "createElement",
});
const render = new Function(
"createElement",
"renderText",
"formatManagedFormErrors",
"ResourceForm",
"errors",
`${code}return Page();`
);
const values: unknown[] = [
{ message: "Not an array" },
"Not an array",
42,
true,
[{ message: 42 }, null, {}, { message: "Rejected" }],
[{ message: "First" }, { message: "Second" }],
[],
undefined,
null,
];
for (const errors of values) {
const element = render(
createElement,
renderText,
formatManagedFormErrors,
"form",
errors
);
expect(renderToStaticMarkup(element)).toBe(
renderToStaticMarkup(
<form>
<div>{formatManagedFormErrors(errors)}</div>
</form>
)
);
}
expect(generated).toContain("<div>");
expect(generated).not.toContain("Sorry, something went wrong.");
expect(usedDataSources.has("saved-errors")).toBe(true);
expect(slot.children[0].type).toBe("text");
const body: import("@webstudio-is/sdk").Instance = {
type: "instance",
id: "body",
component: "Body",
children: [{ type: "id", value: form.id }],
};
for (const rootInstanceId of [form.id, body.id]) {
const usedRuntimeHelpers = new Set<
"renderText" | "formatManagedFormErrors"
>();
generateManagedFormComponent({
scope: createScope(),
name: "Page",
rootInstanceId,
parameters: [],
classesMap: new Map(),
metas: new Map(),
instances: new Map([
[body.id, body],
[form.id, form],
[slot.id, slot],
]),
props: new Map<string, import("@webstudio-is/sdk").Prop>([
[resultAction.id, resultAction],
[
"hidden",
{
id: "hidden",
instanceId: form.id,
name: "data-ws-show",
type: "boolean",
value: false,
},
],
]),
dataSources,
usedRuntimeHelpers,
});
expect(usedRuntimeHelpers).toEqual(new Set());
}
});