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 {
Fragment,
useMemo,
type ForwardRefExoticComponent,
type JSX,
type RefAttributes,
type RefObject,
} from "react";
import { useStore } from "@nanostores/react";
import { formatManagedFormErrors } from "@webstudio-is/sdk";
import type { Instance, Instances } from "@webstudio-is/sdk";
import type { Components } from "@webstudio-is/react-sdk";
import { renderText as renderTextValue } from "@webstudio-is/react-sdk/runtime";
import {
computeExpression,
type InstanceSelector,
} from "@webstudio-is/project-build/runtime";
import {
$unscopedVariableValues,
$variableValuesByInstanceSelector,
} from "~/shared/nano-states";
import { getInstanceVariableValues } from "~/shared/instance-utils/variable-values";
import { useAsyncValue } from "~/shared/use-async-value";
export type WebstudioComponentProps = {
instance: Instance;
instanceSelector: Instance["id"][];
components: Components;
};
export const createInstanceElement = ({
instances,
instanceId,
instanceSelector,
Component,
components,
ref,
}: {
instances: Instances;
instanceId: Instance["id"];
instanceSelector: InstanceSelector;
Component: ForwardRefExoticComponent<
WebstudioComponentProps & RefAttributes<HTMLElement>
>;
components: Components;
ref?: RefObject<HTMLElement>;
}) => {
const instance = instances.get(instanceId);
if (instance === undefined) {
return null;
}
return (
<Component
ref={ref}
key={instance.id}
instance={instance}
instanceSelector={instanceSelector}
components={components}
/>
);
};
const renderText = (text: string): Array<JSX.Element> => {
const lines = text.split("\n");
return lines.map((line, index) => (
<Fragment key={index}>
{line}
{index < lines.length - 1 && <br />}
</Fragment>
));
};
const AsyncTextExpression = ({
managedFormErrors = false,
expression,
instanceSelector,
}: {
expression: string;
managedFormErrors?: boolean;
instanceSelector: InstanceSelector;
}) => {
const variableValuesByInstanceSelector = useStore(
$variableValuesByInstanceSelector
);
const unscopedVariableValues = useStore($unscopedVariableValues);
const variableValues = useMemo(
() =>
getInstanceVariableValues(
variableValuesByInstanceSelector,
instanceSelector,
unscopedVariableValues
) ?? new Map(),
[variableValuesByInstanceSelector, instanceSelector, unscopedVariableValues]
);
const value = useAsyncValue(
() => computeExpression(expression, variableValues),
[expression, variableValues],
undefined
);
return renderText(
managedFormErrors
? formatManagedFormErrors(value)
: String(renderTextValue(value))
);
};
export const createManagedFormErrorElements = (
expression: string,
instanceSelector: InstanceSelector
) => (
<AsyncTextExpression
expression={expression}
instanceSelector={instanceSelector}
managedFormErrors
/>
);
export const createInstanceChildrenElements = ({
instances,
instanceSelector,
children,
Component,
components,
}: {
instances: Instances;
instanceSelector: InstanceSelector;
children: Instance["children"][0][];
Component: ForwardRefExoticComponent<
WebstudioComponentProps & RefAttributes<HTMLElement>
>;
components: Components;
}) => {
const elements = children.map((child) => {
if (child.type === "text") {
return renderText(child.value);
}
if (child.type === "expression") {
return (
<AsyncTextExpression
key={child.value}
expression={child.value}
instanceSelector={instanceSelector}
/>
);
}
if (child.type === "id") {
return createInstanceElement({
instances,
instanceId: child.value,
instanceSelector: [child.value, ...instanceSelector],
Component,
components,
});
}
child satisfies never;
});
// let empty children be coalesced with fallback
if (elements.length === 0) {
return;
}
return elements;
};