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.

23.9 KB
Raw Blame
import { atom, computed } from "nanostores";
import type {
  DataSource,
  Instance,
  Prop,
  ImageAsset,
  Resource,
} from "@webstudio-is/sdk";
import {
  decodeDataSourceVariable,
  encodeDataSourceVariable,
  collectionComponent,
  blockComponent,
  contentBlockDocumentProp,
  getPageResourceRootIds,
  portalComponent,
  ROOT_INSTANCE_ID,
  SYSTEM_VARIABLE_ID,
} from "@webstudio-is/sdk";
import { transpileExpression } from "@webstudio-is/expression";
import {
  normalizeProps,
  textContentAttribute,
  getCollectionEntries,
  findTreeInstanceIdsExcludingStaticHidden,
} from "@webstudio-is/react-sdk";
import { mapGroupBy } from "~/shared/shim";
import { $instances } from "../sync/data-stores";
import { $dataSources, $props, $assets, $resources } from "../sync/data-stores";
import { $uploadingFilesDataStore, $memoryProps, $isPreviewMode } from "./misc";
import { $pages } from "../sync/data-stores";
import type { InstanceSelector } from "@webstudio-is/project-build/runtime";
import { $dataSourceVariables } from "./variables";
import { uploadingFileDataToAsset } from "~/builder/shared/assets/asset-utils";
import { $selectedPage } from "./pages";
import { $selectedInstanceSelector, getInstanceKey } from "./instances";
import {
  $indexesWithinAncestors,
  $registeredComponentMetas,
} from "./components";
import { getSelectionOverrides } from "./selection-reveal";
import { computeExpression } from "@webstudio-is/project-build/runtime";
import { $currentSystem } from "../system";
import {
  $resourcesCache,
  type ResourceRequestPlan,
  computeResourceRequestPlan,
  preloadResources,
} from "../resources";
import {
  $externalContentRoots,
  findExternalContentRoot,
} from "../external-content-mutations";

export const assetBaseUrl = "/cgi/asset/";

export const getIndexedInstanceId = (
  instanceId: Instance["id"],
  index: number | string
) => `${instanceId}[${index}]`;

const setContentBlockDocumentValue = ({
  instance,
  instanceSelector,
  parameters,
  propsByInstanceId,
  variableValues,
  externalContentRoots,
}: {
  instance: Instance;
  instanceSelector: InstanceSelector;
  parameters: ReadonlyMap<Prop["name"], DataSource["id"]>;
  propsByInstanceId: ReadonlyMap<Instance["id"], readonly Prop[]>;
  variableValues: Map<string, unknown>;
  externalContentRoots: ReturnType<typeof $externalContentRoots.get>;
}) => {
  if (instance.component !== blockComponent) {
    return;
  }
  const root =
    findExternalContentRoot(
      externalContentRoots,
      instance.id,
      JSON.stringify(instanceSelector)
    ) ??
    Array.from(externalContentRoots.values()).find(
      (candidate) => candidate.blockInstanceId === instance.id
    );
  const sourceBlockInstanceId = root?.sourceBlockInstanceId ?? instance.id;
  const documentProp = propsByInstanceId
    .get(sourceBlockInstanceId)
    ?.find(
      (prop) =>
        prop.name === contentBlockDocumentProp && prop.type === "parameter"
    );
  const documentParameterId =
    parameters.get(contentBlockDocumentProp) ??
    (documentProp?.type === "parameter" ? documentProp.value : undefined);
  if (documentParameterId === undefined) {
    return;
  }
  variableValues.delete(documentParameterId);
  if (root?.frontmatter !== undefined) {
    variableValues.set(documentParameterId, {
      frontmatter: root.frontmatter,
    });
  }
};

/**
 * (arg1) => {
 * let $ws$dataSource$id = _getVariable('id')
 * $ws$dataSource$id = $ws$dataSource$id + arg1
 * _setVariable('id', $ws$dataSource$id)
 * }
 */
const generateAction = (prop: Extract<Prop, { type: "action" }>) => {
  const getters = new Set<DataSource["id"]>();
  const setters = new Set<DataSource["id"]>();
  // important to fallback to empty argumets to render empty function
  let args: string[] = [];
  let assignersCode = "";
  for (const value of prop.value) {
    args = value.args;
    assignersCode += transpileExpression({
      expression: value.code,
      executable: true,
      replaceVariable: (identifier, assignee) => {
        if (args?.includes(identifier)) {
          return;
        }
        const depId = decodeDataSourceVariable(identifier);
        if (depId) {
          getters.add(depId);
          if (assignee) {
            setters.add(depId);
          }
        }
      },
    });
    assignersCode += `\n`;
  }
  let gettersCode = "";
  for (const dataSourceId of getters) {
    const valueName = encodeDataSourceVariable(dataSourceId);
    gettersCode += `let ${valueName} = _getVariable("${dataSourceId}");\n`;
  }
  let settersCode = "";
  for (const dataSourceId of setters) {
    const valueName = encodeDataSourceVariable(dataSourceId);
    settersCode += `_setVariable("${dataSourceId}", ${valueName})\n`;
  }
  let generated = "";
  generated += `return (${args.join(", ")}) => {\n`;
  generated += gettersCode;
  generated += assignersCode;
  generated += settersCode;
  generated += `}`;
  return generated;
};

const getAction = (
  prop: Extract<Prop, { type: "action" }>,
  values: Map<string, unknown>
) => {
  const generatedAction = generateAction(prop);
  try {
    const executeFn = new Function(
      "_getVariable",
      "_setVariable",
      generatedAction
    );
    const getVariable = (id: string) => {
      return values.get(id);
    };
    const setVariable = (id: string, value: unknown) => {
      const dataSourceVariables = new Map($dataSourceVariables.get());
      dataSourceVariables.set(id, value);
      $dataSourceVariables.set(dataSourceVariables);
    };
    return executeFn(getVariable, setVariable);
  } catch (error) {
    console.error(error);
  }
};

/**
 * similar to below but should not depend on resource values
 * because these values are used to load resources
 * which result in updated resource values and may trigger
 * circular updates
 */
const $resourceVariableValues = computed(
  [$dataSources, $selectedPage, $currentSystem],
  (dataSources, selectedPage, system) => {
    const values = new Map<string, unknown>();
    values.set(SYSTEM_VARIABLE_ID, system);
    for (const [dataSourceId, dataSource] of dataSources) {
      if (dataSource.type === "variable") {
        values.set(dataSourceId, dataSource.value.value);
      }
      if (
        dataSource.type === "parameter" ||
        dataSource.id === selectedPage?.systemDataSourceId
      ) {
        values.set(dataSourceId, system);
      }
    }
    return values;
  }
);

type ResourceRequestPlanInput = {
  rootResourceIds: Iterable<Resource["id"]>;
  resources: ReturnType<typeof $resources.get>;
  dataSources: ReturnType<typeof $dataSources.get>;
  values: ReturnType<typeof $resourceVariableValues.get>;
  resourceCache: ReturnType<typeof $resourcesCache.get>;
};

const getResourceRequestPlanInput = ({
  page,
  instances,
  props,
  dataSources,
  resources,
  values,
  resourceCache,
}: {
  page: ReturnType<typeof $selectedPage.get>;
  instances: ReturnType<typeof $instances.get>;
  props: ReturnType<typeof $props.get>;
  dataSources: ReturnType<typeof $dataSources.get>;
  resources: ReturnType<typeof $resources.get>;
  values: ReturnType<typeof $resourceVariableValues.get>;
  resourceCache: ReturnType<typeof $resourcesCache.get>;
}): ResourceRequestPlanInput => {
  if (page === undefined) {
    return {
      rootResourceIds: [],
      resources,
      dataSources,
      values,
      resourceCache,
    };
  }
  const instanceIds = findTreeInstanceIdsExcludingStaticHidden({
    instances,
    props,
    rootInstanceId: page.rootInstanceId,
  });
  const visibleInstances = new Map<Instance["id"], Instance>();
  for (const instanceId of instanceIds) {
    const instance = instances.get(instanceId);
    if (instance !== undefined) {
      visibleInstances.set(instanceId, instance);
    }
  }
  const rootResourceIds = getPageResourceRootIds({
    page,
    instances: visibleInstances,
    props,
    dataSources,
  });
  return {
    rootResourceIds,
    resources,
    dataSources,
    values,
    resourceCache,
  };
};

const $resourceRequestPlanInput = computed(
  [
    $selectedPage,
    $instances,
    $props,
    $dataSources,
    $resources,
    $resourceVariableValues,
    $resourcesCache,
  ],
  (page, instances, props, dataSources, resources, values, resourceCache) =>
    getResourceRequestPlanInput({
      page,
      instances,
      props,
      dataSources,
      resources,
      values,
      resourceCache,
    })
);

const createEmptyResourceRequestPlan = (): ResourceRequestPlan => ({
  requests: [],
  documents: new Map(),
});

const $resourceRequestPlan = atom<ResourceRequestPlan>(
  createEmptyResourceRequestPlan()
);

/**
 * values of all variables without computing scope specifics like collections
 * simplified version of variable values by instance selector
 */
export const $unscopedVariableValues = computed(
  [
    $dataSources,
    $dataSourceVariables,
    $resourceRequestPlan,
    $selectedPage,
    $currentSystem,
  ],
  (dataSources, dataSourceVariables, resourceRequestPlan, page, system) => {
    const values = new Map<string, unknown>();
    // support global system
    values.set(SYSTEM_VARIABLE_ID, system);
    for (const [dataSourceId, dataSource] of dataSources) {
      if (dataSource.type === "variable") {
        values.set(
          dataSourceId,
          dataSourceVariables.get(dataSourceId) ?? dataSource.value.value
        );
      }
      if (dataSource.type === "parameter") {
        let value = dataSourceVariables.get(dataSourceId);
        // support page system
        if (dataSource.id === page?.systemDataSourceId) {
          value = system;
        }
        values.set(dataSourceId, value);
      }
      if (dataSource.type === "resource") {
        values.set(
          dataSourceId,
          resourceRequestPlan.documents.get(dataSource.resourceId)
        );
      }
    }
    return values;
  }
);

/**
 * compute prop values within context of instance ancestors
 * like a dry-run of rendering and accessing react contexts deep in the tree
 * essential to support collections which provide different values in each item
 * for same variables
 */
const $propValuesInput = computed(
  [
    $instances,
    $props,
    $selectedPage,
    $unscopedVariableValues,
    $pages,
    $assets,
    $uploadingFilesDataStore,
    $externalContentRoots,
  ],
  (
    instances,
    props,
    page,
    unscopedVariableValues,
    pages,
    assets,
    uploadingFilesDataStore,
    externalContentRoots
  ) => ({
    instances,
    props,
    page,
    unscopedVariableValues,
    pages,
    assets,
    uploadingFilesDataStore,
    externalContentRoots,
  })
);

const computePropValues = async ({
  instances,
  props,
  page,
  unscopedVariableValues,
  pages,
  assets,
  uploadingFilesDataStore,
  externalContentRoots,
}: ReturnType<typeof $propValuesInput.get>) => {
  // already includes global variables
  const variableValues = new Map<string, unknown>(unscopedVariableValues);

  let propsList = Array.from(props.values());

  // ignore asset and page props when params is not provided
  if (pages) {
    const uploadingImageAssets = uploadingFilesDataStore
      .map(uploadingFileDataToAsset)
      .filter(<T>(value: T): value is NonNullable<T> => value !== undefined)
      .filter((asset): asset is ImageAsset => asset.type === "image");

    // use whole props list to let access hash props from other pages and instances
    propsList = normalizeProps({
      props: propsList,
      assetBaseUrl,
      assets,
      uploadingImageAssets,
      pages,
      source: "canvas",
    });
  }
  // collect props and group by instances
  const propsByInstanceId = mapGroupBy(propsList, (prop) => prop.instanceId);

  // traverse instances tree and compute props within each instance
  const propValuesByInstanceSelector = new Map<
    Instance["id"],
    Map<Prop["name"], unknown>
  >();
  if (page === undefined) {
    return propValuesByInstanceSelector;
  }
  const traverseInstances = async (instanceSelector: InstanceSelector) => {
    const [instanceId] = instanceSelector;
    const instance = instances.get(instanceId);
    if (instance === undefined) {
      return;
    }

    const propValues = new Map<Prop["name"], unknown>();
    const props = propsByInstanceId.get(instanceId);
    const parameters = new Map<Prop["name"], DataSource["id"]>();

    if (props) {
      for (const prop of props) {
        // at this point asset and page either already converted to string
        // or can be ignored
        if (prop.type === "asset" || prop.type === "page") {
          continue;
        }
        if (prop.type === "expression") {
          const value = await computeExpression(prop.value, variableValues);
          if (value !== undefined) {
            propValues.set(prop.name, value);
          }
          continue;
        }
        if (prop.type === "action") {
          const action = getAction(prop, variableValues);
          if (typeof action === "function") {
            propValues.set(prop.name, action);
          }
          continue;
        }
        if (prop.type === "parameter") {
          parameters.set(prop.name, prop.value);
          continue;
        }
        propValues.set(prop.name, prop.value);
      }
    }

    setContentBlockDocumentValue({
      instance,
      instanceSelector,
      parameters,
      propsByInstanceId,
      variableValues,
      externalContentRoots,
    });

    propValuesByInstanceSelector.set(
      getInstanceKey(instanceSelector),
      propValues
    );

    if (instance.component === collectionComponent) {
      const originalData = propValues.get("data");
      const itemVariableId = parameters.get("item");
      const itemKeyVariableId = parameters.get("itemKey");
      if (originalData) {
        for (const [key, value] of getCollectionEntries(originalData)) {
          if (itemVariableId !== undefined) {
            variableValues.set(itemVariableId, value);
          }
          if (itemKeyVariableId !== undefined) {
            variableValues.set(itemKeyVariableId, key);
          }
          for (const child of instance.children) {
            if (child.type === "id") {
              const indexId = getIndexedInstanceId(instanceId, key);
              await traverseInstances([
                child.value,
                indexId,
                ...instanceSelector,
              ]);
            }
          }
        }
      }
      return;
    }
    for (const child of instance.children) {
      // plain text can be edited from props panel
      if (child.type === "text" && instance.children.length === 1) {
        propValues.set(textContentAttribute, child.value);
      }
      if (child.type === "expression" && instance.children.length === 1) {
        const value = await computeExpression(child.value, variableValues);
        if (value !== undefined) {
          propValues.set(textContentAttribute, value);
        }
      }
      if (child.type === "id") {
        await traverseInstances([child.value, ...instanceSelector]);
      }
    }
  };

  await traverseInstances([page.rootInstanceId]);

  return propValuesByInstanceSelector;
};

export const $propValuesByInstanceSelector = atom(
  new Map<string, Map<Prop["name"], unknown>>()
);

let propValuesRevision = 0;
$propValuesInput.subscribe((input) => {
  const revision = ++propValuesRevision;
  void computePropValues(input).then((values) => {
    if (revision === propValuesRevision) {
      $propValuesByInstanceSelector.set(values);
    }
  });
});

export const $selectionOverrides = computed(
  [
    $selectedInstanceSelector,
    $selectedPage,
    $instances,
    $registeredComponentMetas,
    $propValuesByInstanceSelector,
    $indexesWithinAncestors,
  ],
  (selectedSelector, page, instances, metas, propValues, indexes) =>
    getSelectionOverrides({
      selectedSelector,
      rootInstanceId: page?.rootInstanceId,
      instances,
      metas,
      propValues,
      indexesWithinAncestors: indexes,
    })
);

export const $propValuesByInstanceSelectorWithMemoryProps = computed(
  [
    $propValuesByInstanceSelector,
    $memoryProps,
    $selectionOverrides,
    $isPreviewMode,
  ],
  (
    propValuesByInstanceSelector,
    memoryProps,
    selectionOverrides,
    isPreviewMode
  ) => {
    if (false === isPreviewMode) {
      const result = new Map(propValuesByInstanceSelector);

      for (const [memoryKey, memoryValue] of memoryProps) {
        const propsBySelector = new Map(result.get(memoryKey));

        for (const [memoryProp, memoryPropValue] of memoryValue) {
          propsBySelector.set(memoryProp, memoryPropValue.value);
        }

        result.set(memoryKey, propsBySelector);
      }
      for (const [selectionKey, selectionProps] of selectionOverrides) {
        const propsBySelector = new Map(result.get(selectionKey));
        for (const [name, value] of selectionProps) {
          propsBySelector.set(name, value);
        }
        result.set(selectionKey, propsBySelector);
      }
      return result;
    }
    return propValuesByInstanceSelector;
  }
);

const $variableValuesInput = computed(
  [
    $instances,
    $props,
    $selectedPage,
    $dataSources,
    $dataSourceVariables,
    $resourceRequestPlan,
    $currentSystem,
    $externalContentRoots,
  ],
  (
    instances,
    props,
    page,
    dataSources,
    dataSourceVariables,
    resourceRequestPlan,
    system,
    externalContentRoots
  ) => ({
    instances,
    props,
    page,
    dataSources,
    dataSourceVariables,
    resourceRequestPlan,
    system,
    externalContentRoots,
  })
);

const computeVariableValues = async ({
  instances,
  props,
  page,
  dataSources,
  dataSourceVariables,
  resourceRequestPlan,
  system,
  externalContentRoots,
}: ReturnType<typeof $variableValuesInput.get>) => {
  const propsByInstanceId = mapGroupBy(
    props.values(),
    (prop) => prop.instanceId
  );

  const variablesByInstanceId = mapGroupBy(
    dataSources.values(),
    (dataSource) => dataSource.scopeInstanceId
  );

  // traverse instances tree and compute props within each instance
  const variableValuesByInstanceSelector = new Map<
    Instance["id"],
    Map<Prop["name"], unknown>
  >();
  if (page === undefined) {
    return variableValuesByInstanceSelector;
  }

  const collectVariables = (
    instanceSelector: InstanceSelector,
    parentVariableValues = new Map<string, unknown>()
  ) => {
    const [instanceId] = instanceSelector;
    const variableValues = new Map<string, unknown>(parentVariableValues);
    variableValuesByInstanceSelector.set(
      getInstanceKey(instanceSelector),
      variableValues
    );
    const variables = variablesByInstanceId.get(instanceId);
    // set global system value
    if (instanceId === ROOT_INSTANCE_ID) {
      variableValues.set(SYSTEM_VARIABLE_ID, system);
    }
    if (variables) {
      for (const variable of variables) {
        if (variable.type === "variable") {
          const value = dataSourceVariables.get(variable.id);
          variableValues.set(variable.id, value ?? variable.value.value);
        }
        if (variable.type === "parameter") {
          const value = dataSourceVariables.get(variable.id);
          variableValues.set(variable.id, value);
          // set page system value
          if (variable.id === page.systemDataSourceId) {
            variableValues.set(variable.id, system);
          }
        }
        if (variable.type === "resource") {
          variableValues.set(
            variable.id,
            resourceRequestPlan.documents.get(variable.resourceId)
          );
        }
      }
    }
    return variableValues;
  };

  const traverseInstances = async (
    instanceSelector: InstanceSelector,
    parentVariableValues = new Map<string, unknown>()
  ) => {
    let variableValues = collectVariables(
      instanceSelector,
      parentVariableValues
    );

    const [instanceId] = instanceSelector;
    const propValues = new Map<Prop["name"], unknown>();
    const props = propsByInstanceId.get(instanceId);
    const parameters = new Map<Prop["name"], DataSource["id"]>();
    if (props) {
      for (const prop of props) {
        if (
          prop.type === "asset" ||
          prop.type === "page" ||
          prop.type === "action"
        ) {
          continue;
        }
        if (prop.type === "expression") {
          const value = await computeExpression(prop.value, variableValues);
          if (value !== undefined) {
            propValues.set(prop.name, value);
          }
          continue;
        }
        if (prop.type === "parameter") {
          parameters.set(prop.name, prop.value);
          continue;
        }
        propValues.set(prop.name, prop.value);
      }
    }

    const instance = instances.get(instanceId);
    if (instance === undefined) {
      return;
    }

    setContentBlockDocumentValue({
      instance,
      instanceSelector,
      parameters,
      propsByInstanceId,
      variableValues,
      externalContentRoots,
    });

    if (instance.component === collectionComponent) {
      const originalData = propValues.get("data");
      const itemVariableId = parameters.get("item");
      const itemKeyVariableId = parameters.get("itemKey");
      // prevent accessing item from collection
      if (itemVariableId !== undefined) {
        variableValues.delete(itemVariableId);
      }
      if (itemKeyVariableId !== undefined) {
        variableValues.delete(itemKeyVariableId);
      }
      if (originalData) {
        for (const [key, value] of getCollectionEntries(originalData)) {
          const itemVariableValues = new Map(variableValues);
          if (itemVariableId !== undefined) {
            itemVariableValues.set(itemVariableId, value);
          }
          if (itemKeyVariableId !== undefined) {
            itemVariableValues.set(itemKeyVariableId, key);
          }
          for (const child of instance.children) {
            if (child.type === "id") {
              const indexId = getIndexedInstanceId(instanceId, key);
              await traverseInstances(
                [child.value, indexId, ...instanceSelector],
                itemVariableValues
              );
            }
          }
        }
      }
      return;
    }
    // reset values for slot children to let slots behave as isolated components
    if (instance.component === portalComponent) {
      // allow accessing global variables in slots
      variableValues = globalVariableValues;
    }
    for (const child of instance.children) {
      if (child.type === "id") {
        await traverseInstances(
          [child.value, ...instanceSelector],
          variableValues
        );
      }
    }
  };
  const globalVariableValues = collectVariables([ROOT_INSTANCE_ID]);
  await traverseInstances(
    [page.rootInstanceId, ROOT_INSTANCE_ID],
    globalVariableValues
  );
  return variableValuesByInstanceSelector;
};

export const $variableValuesByInstanceSelector = atom(
  new Map<string, Map<string, unknown>>()
);

let variableValuesRevision = 0;
$variableValuesInput.subscribe((input) => {
  const revision = ++variableValuesRevision;
  void computeVariableValues(input).then((values) => {
    if (revision === variableValuesRevision) {
      $variableValuesByInstanceSelector.set(values);
    }
  });
});

/** Recompute the async resource plan when its inputs change. */
export const subscribeResourceRequestPlan = (
  onPlan: (plan: ResourceRequestPlan) => void
) => {
  $resourceRequestPlan.set(createEmptyResourceRequestPlan());
  let active = true;
  let revision = 0;
  const unsubscribe = $resourceRequestPlanInput.subscribe((input) => {
    const currentRevision = ++revision;
    void computeResourceRequestPlan(input)
      .then((resourceRequestPlan) => {
        if (active && currentRevision === revision) {
          $resourceRequestPlan.set(resourceRequestPlan);
          onPlan(resourceRequestPlan);
        }
      })
      .catch((error: unknown) => {
        if (active && currentRevision === revision) {
          console.error("Failed to compute resource requests", error);
        }
      });
  });
  return () => {
    active = false;
    revision += 1;
    unsubscribe();
    $resourceRequestPlan.set(createEmptyResourceRequestPlan());
  };
};

/** Recompute the plan and preload the requests it produces. */
export const subscribeResources = () =>
  subscribeResourceRequestPlan(({ requests }) => {
    preloadResources(requests);
  });