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 { createNanoEvents } from "nanoevents";
import { createId } from "@webstudio-is/sdk";
import type { Change, Store } from "immerhin";
import type { WritableAtom } from "nanostores";
import type {
Transaction,
RevertedTransaction,
SyncMessage,
SyncEmitter,
} from "@webstudio-is/sync-client";
export interface SyncStorage {
name: string;
sendTransaction(transaction: Transaction): void;
subscribe(setState: (state: unknown) => void, signal: AbortSignal): void;
}
const subscribeStorages = (
storages: SyncStorage[],
setState: (state: unknown) => void,
signal: AbortSignal
) => {
if (storages.length === 0) {
setState(undefined);
return;
}
storages[0].subscribe((value) => {
if (value === undefined) {
// invoke the next storage
subscribeStorages(storages.slice(1), setState, signal);
return;
}
setState(value);
}, signal);
};
interface SyncObject {
name: string;
getState(): unknown;
setState(state: unknown): void;
applyTransaction(transaction: Transaction): void;
revertTransaction(transaction: RevertedTransaction): void;
subscribe(
sendTransaction: (transaction: Transaction) => void,
signal: AbortSignal
): void;
}
export class ImmerhinSyncObject implements SyncObject {
name: string;
store: Store;
transformOnSend?: (changes: Change[]) => Change[];
transformOnReceive?: (changes: Change[]) => Change[];
onRevert?: (changes: Change[]) => void;
constructor(
name: string,
store: Store,
transform?: {
onSend?: (changes: Change[]) => Change[];
onReceive?: (changes: Change[]) => Change[];
onRevert?: (changes: Change[]) => void;
}
) {
this.name = name;
this.store = store;
this.transformOnSend = transform?.onSend;
this.transformOnReceive = transform?.onReceive;
this.onRevert = transform?.onRevert;
}
getState() {
const state = new Map<string, unknown>();
for (const [namespace, $store] of this.store.containers) {
state.set(namespace, $store.get());
}
return state;
}
setState(state: Map<string, unknown>) {
for (const [namespace, $store] of this.store.containers) {
// catch errors triggered by CSP configuration when user put iframe onto canvas
try {
// Immer cannot handle Map instances from another realm.
// Use `clone` to recreate the data with the current realm's classes.
// This works because the structured clone algorithm skips prototype chains; classes must be defined in both realms.
$store.set(structuredClone(state.get(namespace)));
} catch (error) {
console.error(error);
}
}
}
applyTransaction(transaction: Transaction<Change[]>) {
// Immer cannot handle values whose prototypes come from another realm.
// Recreate received patches with the current realm's classes before applying them.
const receivedPayload = structuredClone(transaction.payload);
const payload = this.transformOnReceive
? this.transformOnReceive(receivedPayload)
: receivedPayload;
this.store.addTransaction(transaction.id, payload, "remote");
}
revertTransaction(transaction: RevertedTransaction) {
const revertedChanges = this.store.transactionManager.currentStack
.find(({ id }) => id === transaction.id)
?.getChanges();
this.store.revertTransaction(transaction.id);
if (revertedChanges !== undefined) {
this.onRevert?.(revertedChanges);
}
}
subscribe(
sendTransaction: (transaction: Transaction<Change[]>) => void,
signal: AbortSignal
) {
const unsubscribe = this.store.subscribe((id, payload, source) => {
if (source === "remote") {
return;
}
const outgoing = this.transformOnSend
? this.transformOnSend(payload)
: payload;
sendTransaction({ id, object: this.name, payload: outgoing });
});
signal.addEventListener("abort", unsubscribe);
}
}
export class NanostoresSyncObject implements SyncObject {
name: string;
store: WritableAtom<unknown>;
// track the source of "store.set" to avoid cyclic updates
operation: "local" | "state" | "add" = "local";
constructor(name: string, store: WritableAtom<unknown>) {
this.name = name;
this.store = store;
}
getState() {
return this.store.get();
}
setState(state: unknown) {
this.operation = "state";
this.store.set(state);
this.operation = "local";
}
applyTransaction(transaction: Transaction) {
this.operation = "add";
// catch errors triggered by CSP configuration when user put iframe onto canvas
try {
// `instanceof` checks do not work with instances like Map, File, etc., from another realm.
// Use `clone` to recreate the data with the current realm's classes.
// This works because the structured clone algorithm skips prototype chains; classes must be defined in both realms.
this.store.set(structuredClone(transaction.payload));
} catch (error) {
console.error(error);
}
this.operation = "local";
}
revertTransaction(_transaction: RevertedTransaction) {
// @todo store the list of transactions
}
subscribe(
sendTransaction: (transaction: Transaction) => void,
signal: AbortSignal
) {
const unsubscribe = this.store.listen((payload) => {
if (this.operation !== "local") {
return;
}
const transaction = {
id: createId("nano"),
object: this.name,
payload,
};
sendTransaction(transaction);
});
signal.addEventListener("abort", unsubscribe);
}
}
export class SyncObjectPool implements SyncObject {
name = "SyncObjectPool";
objects = new Map<string, SyncObject>();
constructor(objects: SyncObject[]) {
for (const object of objects) {
this.objects.set(object.name, object);
}
}
getState() {
const state = new Map<string, unknown>();
for (const [name, object] of this.objects) {
state.set(name, object.getState());
}
return state;
}
setState(state: Map<string, unknown>) {
for (const [name, object] of this.objects) {
// merge into existing state to partially restore from storage
if (state.has(name)) {
object.setState(state.get(name) as never);
}
}
}
applyTransaction(transaction: Transaction) {
this.objects.get(transaction.object)?.applyTransaction(transaction);
}
revertTransaction(transaction: RevertedTransaction) {
this.objects.get(transaction.object)?.revertTransaction(transaction);
}
subscribe(
sendTransaction: (transaction: Transaction) => void,
signal: AbortSignal
) {
for (const object of this.objects.values()) {
object.subscribe(sendTransaction, signal);
}
}
}
export class NanoEventsSyncEmitter implements SyncEmitter {
private inner = createNanoEvents<{ message: (m: SyncMessage) => void }>();
emit(message: SyncMessage): void {
this.inner.emit("message", message);
}
on(handler: (message: SyncMessage) => void): () => void {
return this.inner.on("message", handler);
}
}
type SyncClientOptions = {
role: "leader" | "follower";
object: SyncObject;
emitter?: SyncEmitter;
storages?: SyncStorage[];
};
export class SyncClient {
clientId = createId("nano");
role: SyncClientOptions["role"];
object: SyncObject;
storages: SyncStorage[];
emitter: SyncEmitter;
connection: "disconnected" | "connecting" | "connected" = "disconnected";
constructor(options: SyncClientOptions) {
this.role = options.role;
this.object = options.object;
this.storages = options.storages ?? [];
this.emitter = options.emitter ?? new NanoEventsSyncEmitter();
}
lead() {
this.role = "leader";
this.emitter.emit({
clientId: this.clientId,
type: "state",
state: this.object.getState(),
});
}
connect({ signal, onReady }: { signal: AbortSignal; onReady?: () => void }) {
const off = this.emitter.on((message) => {
// ignore own messages
if (this.clientId === message.clientId) {
return;
}
if (message.type === "connect") {
if (this.role !== "leader") {
return;
}
this.emitter.emit({
clientId: this.clientId,
type: "state",
state: this.object.getState(),
});
}
if (message.type === "state") {
if (this.connection === "connected") {
return;
}
this.connection = "connected";
this.object.setState(message.state);
}
if (message.type === "apply") {
this.object.applyTransaction(message.transaction);
if (this.role === "leader") {
for (const storage of this.storages) {
storage.sendTransaction(message.transaction);
}
}
}
if (message.type === "revert") {
this.object.revertTransaction(message.transaction);
}
});
signal.addEventListener("abort", off);
this.object.subscribe((transaction) => {
this.emitter.emit({
clientId: this.clientId,
type: "apply",
transaction,
});
if (this.role === "leader") {
for (const storage of this.storages) {
storage.sendTransaction(transaction);
}
}
}, signal);
this.emitter.emit({
clientId: this.clientId,
type: "connect",
});
if (this.connection === "disconnected") {
this.connection = "connecting";
}
if (this.role === "leader") {
subscribeStorages(
this.storages,
(state) => {
// fallback to default object state
state ??= this.object.getState();
this.object.setState(state);
this.emitter.emit({
clientId: this.clientId,
type: "state",
state,
});
onReady?.();
},
signal
);
}
}
}