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.

7.0 KB
Raw Blame
import { useState } from "react";
import {
  Flex,
  Text,
  theme,
  Link,
  css,
  List,
  ListItem,
  InsetList,
  InsetListItem,
  IconButton,
  cssVar,
} from "@webstudio-is/design-system";
import { ChevronUpIcon, ChevronDownIcon } from "@webstudio-is/icons";
import type { DashboardProject } from "@webstudio-is/dashboard";
import { builderUrl } from "~/shared/router-utils";
import { ProjectDialogs, type DialogType } from "./project-dialogs";
import type { User } from "~/shared/db/user.server";
import { ProjectMenu } from "./project-menu";
import { formatDate } from "./utils";
import type { SortField, SortOrder } from "./sort";

const projectColumns =
  "minmax(0, 35fr) repeat(3, minmax(0, 20fr)) minmax(0, 5fr)";

const tableStyles = css({
  display: "grid",
  alignContent: "start",
  width: "100%",
  marginBottom: theme.spacing[13],
  minWidth: 550,
  flexGrow: 1,

  '& [role="rowgroup"]': {
    display: "grid",
  },

  '& [role="row"]': {
    display: "grid",
    gridTemplateColumns: projectColumns,
    alignItems: "center",
    position: "relative",
  },

  "& [data-projects-header]": {
    marginInline: theme.spacing[3],
  },

  '& [role="columnheader"]': {
    padding: theme.spacing[5],
    paddingBottom: theme.spacing[3],
    textAlign: "left",
    borderBottom: `1px solid ${cssVar("--border-default")}`,
  },

  '& [role="cell"]': {
    padding: theme.spacing[5],
    minWidth: 0,
  },
});

type ProjectsListItemProps = {
  index: number;
  project: DashboardProject;
  publisherHost: string;
  projectsTags: User["projectsTags"];
};

export const ProjectsListItem = ({
  index,
  project: {
    id,
    title,
    domain,
    isPublished,
    createdAt,
    latestBuildVirtual,
    tags,
    domainsVirtual,
  },
  publisherHost,
  projectsTags,
}: ProjectsListItemProps) => {
  const customDomain = domainsVirtual?.find(
    (d: { domain: string; status: string; verified: boolean }) =>
      d.status === "ACTIVE" && d.verified
  )?.domain;
  const displayDomain = customDomain ?? `${domain}.${publisherHost}`;
  const [openDialog, setOpenDialog] = useState<DialogType | undefined>();
  const [isHidden, setIsHidden] = useState(false);

  if (isHidden) {
    return;
  }

  const linkPath = builderUrl({ origin: window.origin, projectId: id });

  return (
    <>
      <ListItem index={index} asChild>
        <InsetListItem asChild css={{ padding: 0 }}>
          <div role="row">
            <div role="cell">
              <Flex direction="column" gap="1">
                <Link
                  href={linkPath}
                  color="inherit"
                  underline="none"
                  tabIndex={-1}
                  stretched
                >
                  {title}
                </Link>
                {isPublished && (
                  <Link
                    href={`https://${displayDomain}`}
                    target="_blank"
                    rel="noreferrer"
                    color="subtle"
                    underline="hover"
                    tabIndex={-1}
                    aria-label={`Visit ${title} website at ${displayDomain}`}
                    css={{ zIndex: 1 }}
                  >
                    {displayDomain}
                  </Link>
                )}
              </Flex>
            </div>

            <div role="cell">
              <Text color="subtle">
                {latestBuildVirtual?.updatedAt
                  ? formatDate(latestBuildVirtual.updatedAt)
                  : formatDate(createdAt)}
              </Text>
            </div>

            <div role="cell">
              <Text color="subtle">
                {isPublished && latestBuildVirtual
                  ? formatDate(latestBuildVirtual.createdAt)
                  : "Not published"}
              </Text>
            </div>

            <div role="cell">
              <Text color="subtle">{formatDate(createdAt)}</Text>
            </div>

            <div role="cell">
              <ProjectMenu projectId={id} onOpenChange={setOpenDialog} />
            </div>
          </div>
        </InsetListItem>
      </ListItem>

      <ProjectDialogs
        projectId={id}
        title={title}
        tags={tags}
        openDialog={openDialog}
        onOpenDialogChange={setOpenDialog}
        onHiddenChange={setIsHidden}
        projectsTags={projectsTags}
      />
    </>
  );
};

type ProjectsListProps = {
  projects: Array<DashboardProject>;
  publisherHost: string;
  projectsTags: User["projectsTags"];
  sortBy?: SortField;
  sortOrder?: SortOrder;
  onSortChange: (field: SortField) => void;
};

const columns: Array<{ field: SortField; label: string } | null> = [
  { field: "title", label: "Name" },
  { field: "updatedAt", label: "Last modified" },
  { field: "publishedAt", label: "Last published" },
  { field: "createdAt", label: "Date created" },
  null, // Actions column (no sorting)
];

export const ProjectsList = ({
  projects,
  publisherHost,
  projectsTags,
  sortBy,
  sortOrder,
  onSortChange,
}: ProjectsListProps) => {
  return (
    <div className={tableStyles()} role="table" aria-label="Projects list">
      <List asChild>
        <div role="rowgroup">
          <ListItem index={0} asChild>
            <div role="row" data-projects-header>
              {columns.map((column, index) => (
                <div role="columnheader" key={index}>
                  {column ? (
                    <Flex gap="1" align="center">
                      <Text
                        variant="regularBold"
                        id={`sort-${column.field}-label`}
                      >
                        {column.label}
                      </Text>
                      <IconButton
                        onClick={() => onSortChange(column.field)}
                        css={{ opacity: sortBy === column.field ? 1 : 0.5 }}
                        aria-label={`Sort by ${column.label}${
                          sortBy === column.field
                            ? sortOrder === "asc"
                              ? ", sorted ascending"
                              : ", sorted descending"
                            : ", not sorted"
                        }`}
                        aria-describedby={`sort-${column.field}-label`}
                        tabIndex={-1}
                      >
                        {sortBy === column.field && sortOrder === "asc" ? (
                          <ChevronUpIcon />
                        ) : (
                          <ChevronDownIcon />
                        )}
                      </IconButton>
                    </Flex>
                  ) : undefined}
                </div>
              ))}
            </div>
          </ListItem>
        </div>
      </List>

      <List asChild>
        <InsetList role="rowgroup">
          {projects.map((project, index) => (
            <ProjectsListItem
              key={project.id}
              index={index}
              project={project}
              publisherHost={publisherHost}
              projectsTags={projectsTags}
            />
          ))}
        </InsetList>
      </List>
    </div>
  );
};