Skip to content

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.

3.3 KB
Raw Blame
import {
  getStyleDeclKey,
  type AssetFolders,
  type WebstudioData,
} from "@webstudio-is/sdk";
import { migratePages } from "@webstudio-is/project-migrations/pages";
import {
  type MarketplaceProduct,
  type ProjectSettings,
} from "@webstudio-is/project-build";
import type { Project } from "@webstudio-is/project";
import type { inferRouterOutputs } from "@trpc/server";
import type { AppRouter } from "~/services/trcp-router.server";
import { $project, readBuilderStateStores } from "~/shared/sync/data-stores";
import { nativeClient } from "~/shared/trpc/trpc-client";

export type BuilderData = Omit<WebstudioData, "assetFolders"> & {
  assetFolders: AssetFolders;
  marketplaceProduct: undefined | MarketplaceProduct;
  projectSettings: ProjectSettings;
  project: Project;
};

type LoadDataOutput = inferRouterOutputs<AppRouter>["build"]["loadData"];

export type LoadedBuilderData = BuilderData &
  Pick<LoadDataOutput, "id" | "version" | "publisherHost" | "projectId">;

export const getBuilderData = (): BuilderData => {
  const data = readBuilderStateStores();
  const { pages, projectSettings } = data;
  if (pages === undefined) {
    throw Error(`Cannot get webstudio data with empty pages`);
  }
  const project = $project.get();
  if (project === undefined) {
    throw Error(`Cannot get webstudio data with empty project`);
  }
  if (projectSettings === undefined) {
    throw Error(`Cannot get webstudio data with empty project settings`);
  }
  return {
    ...data,
    pages,
    project,
    projectSettings,
  };
};

const getPair = <Item extends { id: string }>(item: Item) =>
  [item.id, item] as const;

const hydrateIdMap = <Item extends { id: string }>(items: Item[]) =>
  new Map(items.map(getPair));

const hydrateMap = <Item, Key>(items: Item[], getKey: (item: Item) => Key) =>
  new Map(items.map((item) => [getKey(item), item] as const));

export const loadBuilderData = async ({
  projectId,
  signal,
}: {
  projectId: string;
  signal: AbortSignal;
}): Promise<LoadedBuilderData> => {
  try {
    const data = await nativeClient.build.loadData.query(
      { projectId },
      { signal }
    );
    const pages = migratePages(data.pages);
    return {
      id: data.id,
      version: data.version,
      projectId: data.projectId,
      project: data.project,
      publisherHost: data.publisherHost,
      assets: hydrateIdMap(data.assets),
      assetFolders: hydrateIdMap(data.assetFolders),
      instances: hydrateIdMap(data.instances),
      dataSources: hydrateIdMap(data.dataSources),
      resources: hydrateIdMap(data.resources),
      props: hydrateIdMap(data.props),
      pages,
      breakpoints: hydrateIdMap(data.breakpoints),
      styleSources: hydrateIdMap(data.styleSources),
      styleSourceSelections: hydrateMap(
        data.styleSourceSelections,
        (item) => item.instanceId
      ),
      styles: hydrateMap(data.styles, (item) => getStyleDeclKey(item)),
      marketplaceProduct: data.marketplaceProduct,
      projectSettings: data.projectSettings,
    };
  } catch (error) {
    const message =
      error instanceof Error ? error.message : JSON.stringify(error);

    if (signal.aborted === false) {
      // No toasts available in this context
      alert(`Unable to load builder data. ${message}`);
    }

    throw new Error(`Unable to load builder data. ${message}`, {
      cause: error,
    });
  }
};