Skip to content

A modern and easy to use dashboard. 80+ integrations. 20K+ icons built in. Authentication out of the box. No YAML, drag and drop configuration.

36.8 KB
Raw Blame
"use client";

import React, { useCallback, useMemo, useState } from "react";
import {
  Accordion,
  ActionIcon,
  Button,
  Checkbox,
  Code,
  Divider,
  Fieldset,
  Group,
  Image,
  Input,
  Loader,
  PasswordInput,
  Select,
  Stack,
  Text,
  TextInput,
  Title,
  Tooltip,
} from "@mantine/core";
import type { FormErrors } from "@mantine/form";
import {
  IconAlertTriangleFilled,
  IconBrandDocker,
  IconCopy,
  IconCopyCheckFilled,
  IconEdit,
  IconEye,
  IconEyeOff,
  IconKey,
  IconPackageImport,
  IconPlus,
  IconTrash,
  IconTriangleFilled,
  IconZoomScan,
} from "@tabler/icons-react";
import { clientApi } from "@homarr/api/client";
import { useSession } from "@homarr/auth/client";
import { createId } from "@homarr/common";
import type { ReleaseProviderKind } from "@homarr/definitions";
import {
  getReleaseProviderDefaultUrl,
  getReleaseProviderIconUrl,
  getReleaseProviderName,
  getReleaseSourceFromDockerImage,
  releaseProviderKinds,
} from "@homarr/definitions";
import { IconPicker } from "@homarr/forms-collection";
import { createModal, useModalAction } from "@homarr/modals";
import { showErrorNotification } from "@homarr/notifications";
import { useI18n } from "@homarr/translation/client";
import { MaskedImage } from "@homarr/ui";

import type { ReleasesRepository, ReleasesVersionFilter } from "../releases/releases-repository";
import { WidgetIntegrationSelect } from "../widget-integration-select";
import type { IntegrationSelectOption } from "../widget-integration-select";
import type { CommonWidgetInputProps } from "./common";
import { useWidgetInputTranslation } from "./common";
import { useFormContext } from "./form";

interface FormValidation {
  hasErrors: boolean;
  errors: FormErrors;
}

const escapeForRegEx = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

export const WidgetMultiReleasesRepositoriesInput = ({
  property,
  kind,
  itemId,
}: CommonWidgetInputProps<"multiReleasesRepositories">) => {
  const t = useWidgetInputTranslation(kind, property);
  const tRepository = useI18n("widget.releases.option.repositories");
  const actionT = useI18n("common.action");
  const form = useFormContext();
  const repositories = form.values.options[property] as ReleasesRepository[];
  const storedHiddenSuggestions = form.values.options.hiddenDockerSuggestions;
  let hiddenSourceTokens: string[] = [];
  if (Array.isArray(storedHiddenSuggestions)) {
    hiddenSourceTokens = storedHiddenSuggestions.filter(
      (entry): entry is string => typeof entry === "string" && /^[a-f0-9]{64}$/.test(entry),
    );
  }
  const { openModal: openEditModal } = useModalAction(RepositoryEditModal);
  const { openModal: openImportModal } = useModalAction(RepositoryImportModal);
  const versionFilterPrecisionOptions = useMemo(
    () => [tRepository("versionFilter.precision.options.none"), "#", "#.#", "#.#.#", "#.#.#.#", "#.#.#.#.#"],
    [tRepository],
  );
  const { data: session } = useSession();
  const isAdmin = session?.user.permissions.includes("admin") ?? false;

  const providerOptions = useMemo(
    () => releaseProviderKinds.map((provider) => ({ value: provider, label: getReleaseProviderName(provider) })),
    [],
  );

  const onRepositorySave = useCallback(
    (repository: ReleasesRepository, index: number): FormValidation => {
      form.setFieldValue(`options.${property}.${index}.provider`, repository.provider);
      form.setFieldValue(`options.${property}.${index}.identifier`, repository.identifier);
      form.setFieldValue(`options.${property}.${index}.name`, repository.name);
      form.setFieldValue(`options.${property}.${index}.versionFilter`, repository.versionFilter);
      form.setFieldValue(`options.${property}.${index}.excludePrereleases`, repository.excludePrereleases);
      form.setFieldValue(`options.${property}.${index}.iconUrl`, repository.iconUrl);
      form.setFieldValue(`options.${property}.${index}.providerUrl`, repository.providerUrl);
      form.setFieldValue(`options.${property}.${index}.integrationIds`, repository.integrationIds);

      const formValidation = form.validate();
      const fieldErrors: FormErrors = Object.entries(formValidation.errors).reduce((acc, [key, value]) => {
        if (key.startsWith(`options.${property}.${index}.`)) {
          acc[key] = value;
        }
        return acc;
      }, {} as FormErrors);

      return {
        hasErrors: Object.keys(fieldErrors).length > 0,
        errors: fieldErrors,
      };
    },
    [form, property],
  );

  const addNewRepository = () => {
    const repository: ReleasesRepository = {
      id: createId(),
      identifier: "",
    };

    form.setValues((previous) => {
      const previousValues = previous.options?.[property] as ReleasesRepository[];
      return {
        ...previous,
        options: {
          ...previous.options,
          [property]: [...previousValues, repository],
        },
      };
    });

    const index = repositories.length;

    openEditModal({
      fieldPath: `options.${property}.${index}`,
      repository,
      onRepositorySave: (saved) => onRepositorySave(saved, index),
      onRepositoryCancel: () => onRepositoryRemove(index),
      versionFilterPrecisionOptions,
      providerOptions,
      attachedIntegrationIds: [...new Set(form.values.integrationIds)],
    });
  };

  const onRepositoryRemove = (index: number) => {
    form.setValues((previous) => {
      const previousValues = previous.options?.[property] as ReleasesRepository[];
      return {
        ...previous,
        options: {
          ...previous.options,
          [property]: previousValues.filter((_, i) => i !== index),
        },
      };
    });
  };

  return (
    <Fieldset legend={t("label")}>
      <Stack gap="5">
        <Group grow>
          <Button leftSection={<IconPlus />} onClick={addNewRepository}>
            {tRepository("addRepository.label")}
          </Button>
          <Tooltip label={tRepository("importRepositories.onlyAdminCanImport")} disabled={isAdmin} withArrow>
            <Button
              disabled={!isAdmin}
              leftSection={<IconBrandDocker stroke={1.25} />}
              onClick={() =>
                openImportModal({
                  repositories,
                  hiddenSourceTokens,
                  versionFilterPrecisionOptions,
                  onConfirm: (selectedRepositories, nextHiddenSourceTokens) => {
                    form.setValues((previous) => {
                      const previousValues = previous.options?.[property] as ReleasesRepository[];
                      return {
                        ...previous,
                        options: {
                          ...previous.options,
                          [property]: [...previousValues, ...selectedRepositories],
                          hiddenDockerSuggestions: nextHiddenSourceTokens,
                        },
                      };
                    });
                  },
                  isAdmin,
                })
              }
            >
              {tRepository("importRepositories.label")}
            </Button>
          </Tooltip>
        </Group>
        <Divider my="sm" />

        {repositories.map((repository, index) => {
          const providerName = repository.provider ? getReleaseProviderName(repository.provider) : "";
          return (
            <Stack key={repository.id} gap={5}>
              <Group align="center" gap="xs">
                <Image
                  src={
                    repository.iconUrl ?? (repository.provider ? getReleaseProviderIconUrl(repository.provider) : null)
                  }
                  style={{
                    height: "1.2em",
                    width: "1.2em",
                  }}
                />

                <Text c="dimmed" size="xs">
                  {providerName}
                </Text>

                <Group justify="space-between" align="center" style={{ flex: 1 }} gap={5}>
                  <Text size="sm" style={{ flex: 1, whiteSpace: "nowrap" }}>
                    {/* eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing */}
                    {repository.name || repository.identifier}
                  </Text>
                </Group>

                <Button
                  onClick={() =>
                    openEditModal({
                      fieldPath: `options.${property}.${index}`,
                      repository,
                      onRepositorySave: (saved) => onRepositorySave(saved, index),
                      versionFilterPrecisionOptions,
                      providerOptions,
                      attachedIntegrationIds: [...new Set(form.values.integrationIds)],
                    })
                  }
                  variant="light"
                  leftSection={<IconEdit size="var(--mantine-font-size-sm)" />}
                  size="xs"
                >
                  {actionT("edit")}
                </Button>

                <ActionIcon
                  variant="transparent"
                  color="red"
                  aria-label={actionT("deleteNamed", { name: repository.name || repository.identifier })}
                  onClick={() => onRepositoryRemove(index)}
                >
                  <IconTrash size="var(--mantine-font-size-sm)" />
                </ActionIcon>
              </Group>
              {Object.keys(form.errors).filter((key) => key.startsWith(`options.${property}.${index}.`)).length > 0 && (
                <Group align="center" justify="center" gap="xs" bg="red.1">
                  <IconTriangleFilled size="var(--mantine-font-size-sm)" color="var(--mantine-color-red-filled)" />
                  <Text size="sm" c="red">
                    {tRepository("invalid")}
                  </Text>
                </Group>
              )}
              <Divider my="sm" size="xs" mt={5} mb={5} />
            </Stack>
          );
        })}
      </Stack>
      {itemId && <ProviderTokensSection itemId={itemId} repositories={repositories} />}
    </Fieldset>
  );
};

const providersWithAuth: ReleaseProviderKind[] = [
  "github",
  "gitHubContainerRegistry",
  "dockerHub",
  "gitlab",
  "npm",
  "codeberg",
];

const ProviderTokensSection = ({ itemId, repositories }: { itemId: string; repositories: ReleasesRepository[] }) => {
  const tRepository = useI18n("widget.releases.option.repositories");
  const utils = clientApi.useUtils();
  const { data: configuredKinds = [], refetch } = clientApi.widget.secrets.getConfiguredKinds.useQuery({ itemId });
  const setSecret = clientApi.widget.secrets.setSecret.useMutation({
    onSuccess: () => {
      void refetch();
      void utils.widget.releases.getLatest.invalidate();
    },
    onError: () => {
      showErrorNotification({
        title: tRepository("tokens.label"),
        message: tRepository("tokens.notConfigured"),
      });
    },
  });
  const deleteSecret = clientApi.widget.secrets.deleteSecret.useMutation({
    onSuccess: () => {
      void refetch();
      void utils.widget.releases.getLatest.invalidate();
    },
    onError: () => {
      showErrorNotification({
        title: tRepository("tokens.label"),
        message: tRepository("tokens.notConfigured"),
      });
    },
  });

  const authProviders = useMemo(() => {
    const usedProviders = repositories.map((r) => r.provider).filter((p): p is ReleaseProviderKind => p !== undefined);
    const configuredProviders = configuredKinds.filter((k): k is ReleaseProviderKind =>
      providersWithAuth.includes(k as ReleaseProviderKind),
    );
    return [...new Set([...usedProviders, ...configuredProviders])].filter((p) => providersWithAuth.includes(p));
  }, [repositories, configuredKinds]);

  if (authProviders.length === 0) return null;

  return (
    <>
      <Divider my="sm" label={tRepository("tokens.label")} labelPosition="center" />
      <Stack gap="xs">
        {authProviders.map((provider) => (
          <ProviderTokenInput
            key={provider}
            provider={provider}
            hasToken={configuredKinds.includes(provider)}
            onSave={async (value) => {
              await setSecret.mutateAsync({ itemId, kind: provider, value });
            }}
            onDelete={async () => {
              await deleteSecret.mutateAsync({ itemId, kind: provider });
            }}
          />
        ))}
      </Stack>
    </>
  );
};

const ProviderTokenInput = ({
  provider,
  hasToken,
  onSave,
  onDelete,
}: {
  provider: ReleaseProviderKind;
  hasToken: boolean;
  onSave: (value: string) => Promise<void>;
  onDelete: () => Promise<void>;
}) => {
  const tRepository = useI18n("widget.releases.option.repositories");
  const actionT = useI18n("common.action");
  const [value, setValue] = useState("");
  const [editing, setEditing] = useState(false);
  const [saving, setSaving] = useState(false);

  const handleSave = async () => {
    if (!value.trim()) return;
    setSaving(true);
    try {
      await onSave(value.trim());
      setValue("");
      setEditing(false);
    } finally {
      setSaving(false);
    }
  };

  const handleDelete = async () => {
    setSaving(true);
    try {
      await onDelete();
      setValue("");
      setEditing(false);
    } finally {
      setSaving(false);
    }
  };

  return (
    <Group gap="xs" align="end">
      <PasswordInput
        label={`${getReleaseProviderName(provider)} ${tRepository("tokens.token")}`}
        placeholder={hasToken ? tRepository("tokens.configured") : tRepository("tokens.notConfigured")}
        value={value}
        onChange={(e) => {
          setValue(e.currentTarget.value);
          setEditing(true);
        }}
        style={{ flex: 1 }}
        size="xs"
        leftSection={<IconKey size="var(--mantine-font-size-sm)" />}
      />
      {editing && value.trim() && (
        <Button size="xs" onClick={handleSave} loading={saving}>
          {actionT("save")}
        </Button>
      )}
      {hasToken && !editing && (
        <ActionIcon
          variant="light"
          color="red"
          size="sm"
          aria-label={actionT("deleteNamed", {
            name: `${getReleaseProviderName(provider)} ${tRepository("tokens.token")}`,
          })}
          onClick={handleDelete}
          loading={saving}
        >
          <IconTrash size="var(--mantine-font-size-sm)" />
        </ActionIcon>
      )}
    </Group>
  );
};

const formatVersionFilterRegex = (versionFilter: ReleasesVersionFilter | undefined) => {
  if (!versionFilter) return undefined;

  const escapedPrefix = versionFilter.prefix ? escapeForRegEx(versionFilter.prefix) : "";
  const precision = "[0-9]+\\.".repeat(versionFilter.precision).slice(0, -2);
  const escapedSuffix = versionFilter.suffix ? escapeForRegEx(versionFilter.suffix) : "";

  return `^${escapedPrefix}${precision}${escapedSuffix}$`;
};

const formatIdentifierName = (identifier: string) => {
  const unformattedName = identifier.split("/").pop();
  return unformattedName?.replace(/[-_]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (char) => char.toUpperCase()) ?? "";
};

interface RepositoryEditProps {
  fieldPath: string;
  repository: ReleasesRepository;
  onRepositorySave: (repository: ReleasesRepository) => FormValidation;
  onRepositoryCancel?: () => void;
  versionFilterPrecisionOptions: string[];
  providerOptions: { value: ReleaseProviderKind; label: string }[];
  attachedIntegrationIds: string[];
}

const RepositoryEditModal = createModal<RepositoryEditProps>(({ innerProps, actions }) => {
  const tRepository = useI18n("widget.releases.option.repositories");
  const tIntegrationSelect = useI18n("widget.integrationSelect");
  const actionT = useI18n("common.action");
  const [loading, setLoading] = useState(false);
  const { data: serviceVersionIntegrations = [] } = clientApi.integration.allOfGivenCategory.useQuery({
    category: "serviceVersion",
  });
  const integrationOptions = useMemo(
    () =>
      serviceVersionIntegrations
        .filter((integration) => innerProps.attachedIntegrationIds.includes(integration.id))
        .map(({ id, name, url, kind }): IntegrationSelectOption => ({ id, name, url, kind })),
    [serviceVersionIntegrations, innerProps.attachedIntegrationIds],
  );
  const [tempRepository, setTempRepository] = useState(() => ({ ...innerProps.repository }));
  const [formErrors, setFormErrors] = useState<FormErrors>({});
  const handleConfirm = useCallback(() => {
    setLoading(true);

    const validation = innerProps.onRepositorySave(tempRepository);
    setFormErrors(validation.errors);
    if (!validation.hasErrors) {
      actions.closeModal();
    }

    setLoading(false);
  }, [innerProps, tempRepository, actions]);

  const handleCancel = useCallback(() => {
    if (innerProps.onRepositoryCancel) {
      innerProps.onRepositoryCancel();
    }

    actions.closeModal();
  }, [innerProps, actions]);

  const handleChange = useCallback((changedValue: Partial<ReleasesRepository>) => {
    setTempRepository((prev) => ({ ...prev, ...changedValue }));
  }, []);

  return (
    <Stack>
      <Group align="start" wrap="nowrap" grow preventGrowOverflow={false}>
        <div style={{ flex: 0.3 }}>
          <Select
            withAsterisk
            label={tRepository("provider.label")}
            data={innerProps.providerOptions}
            value={tempRepository.provider ?? null}
            error={formErrors[`${innerProps.fieldPath}.provider`] as string}
            onChange={(value) => {
              handleChange({ provider: value ? (value as ReleaseProviderKind) : undefined });
            }}
          />
        </div>

        <TextInput
          withAsterisk
          label={tRepository("identifier.label")}
          value={tempRepository.identifier}
          onChange={(event) => {
            const name =
              tempRepository.name === undefined ||
              formatIdentifierName(tempRepository.identifier) === tempRepository.name
                ? formatIdentifierName(event.currentTarget.value)
                : tempRepository.name;

            handleChange({
              identifier: event.currentTarget.value,
              name,
            });
          }}
          error={formErrors[`${innerProps.fieldPath}.identifier`]}
          style={{ flex: 0.7 }}
        />
      </Group>

      <TextInput
        label={tRepository("providerUrl.label")}
        placeholder={tempRepository.provider ? getReleaseProviderDefaultUrl(tempRepository.provider) : undefined}
        value={tempRepository.providerUrl ?? ""}
        onChange={(event) => {
          handleChange({ providerUrl: event.currentTarget.value || undefined });
        }}
        error={formErrors[`${innerProps.fieldPath}.providerUrl`]}
      />

      <Group align="center" wrap="nowrap" grow preventGrowOverflow={false}>
        <TextInput
          label={tRepository("name.label")}
          value={tempRepository.name ?? ""}
          onChange={(event) => handleChange({ name: event.currentTarget.value })}
          error={formErrors[`${innerProps.fieldPath}.name`]}
          style={{ flex: 0.3 }}
        />

        <div style={{ flex: 0.7 }}>
          <IconPicker
            withAsterisk={false}
            value={tempRepository.iconUrl ?? ""}
            suggestedSearch={tempRepository.name || tempRepository.identifier}
            onChange={(url) => {
              if (url === "") {
                handleChange({ iconUrl: undefined });
              } else {
                handleChange({ iconUrl: url });
              }
            }}
            error={formErrors[`${innerProps.fieldPath}.iconUrl`] as string}
          />
        </div>
      </Group>

      {tempRepository.provider && ["github", "codeberg"].includes(tempRepository.provider) && (
        <Checkbox
          label={tRepository("excludePrereleases.label")}
          description={tRepository("excludePrereleases.description")}
          checked={tempRepository.excludePrereleases ?? false}
          onChange={(event) => handleChange({ excludePrereleases: event.currentTarget.checked })}
        />
      )}

      <Fieldset legend={tRepository("versionFilter.label")}>
        <Group justify="stretch" align="center" grow>
          <TextInput
            label={tRepository("versionFilter.prefix.label")}
            value={tempRepository.versionFilter?.prefix ?? ""}
            onChange={(event) => {
              handleChange({
                versionFilter: {
                  ...(tempRepository.versionFilter ?? { precision: 0 }),
                  prefix: event.currentTarget.value,
                },
              });
            }}
            error={formErrors[`${innerProps.fieldPath}.versionFilter.prefix`]}
            disabled={!tempRepository.versionFilter}
          />
          <Select
            label={tRepository("versionFilter.precision.label")}
            data={Object.entries(innerProps.versionFilterPrecisionOptions).map(([key, value]) => ({
              value: key,
              label: value,
            }))}
            value={tempRepository.versionFilter?.precision.toString() ?? "0"}
            onChange={(value) => {
              const precision = value ? parseInt(value) : 0;
              handleChange({
                versionFilter:
                  isNaN(precision) || precision <= 0
                    ? undefined
                    : {
                        ...tempRepository.versionFilter,
                        precision,
                      },
              });
            }}
            error={formErrors[`${innerProps.fieldPath}.versionFilter.precision`]}
          />
          <TextInput
            label={tRepository("versionFilter.suffix.label")}
            value={tempRepository.versionFilter?.suffix ?? ""}
            onChange={(event) => {
              handleChange({
                versionFilter: {
                  ...(tempRepository.versionFilter ?? { precision: 0 }),
                  suffix: event.currentTarget.value,
                },
              });
            }}
            error={formErrors[`${innerProps.fieldPath}.versionFilter.suffix`]}
            disabled={!tempRepository.versionFilter}
          />
        </Group>

        <Text size="xs" c="dimmed">
          {tRepository("versionFilter.regex.label")}:{" "}
          {formatVersionFilterRegex(tempRepository.versionFilter) ??
            tRepository("versionFilter.precision.options.none")}
        </Text>
      </Fieldset>

      {innerProps.attachedIntegrationIds.length === 0 ? (
        <Input.Wrapper label={tRepository("integrations.label")}>
          <Text size="sm" c="dimmed">
            {tIntegrationSelect("configureIntegrationFirst")}
          </Text>
        </Input.Wrapper>
      ) : (
        <WidgetIntegrationSelect
          label={tRepository("integrations.label")}
          data={integrationOptions}
          value={tempRepository.integrationIds ?? []}
          onChange={(integrationIds) =>
            handleChange({ integrationIds: integrationIds.length > 0 ? integrationIds : undefined })
          }
        />
      )}

      <Divider my={"sm"} />
      <Group justify="flex-end">
        <Button variant="default" onClick={handleCancel} color="gray.5">
          {actionT("cancel")}
        </Button>

        <Button data-autofocus onClick={handleConfirm} loading={loading}>
          {actionT("confirm")}
        </Button>
      </Group>
    </Stack>
  );
}).withOptions({
  defaultTitle(t) {
    return t("widget.releases.option.repositories.editForm.title");
  },
  size: "xl",
});

interface ReleasesRepositoryImport extends ReleasesRepository {
  alreadyImported: boolean;
  sourceToken: string;
}

interface ImportRepositorySelectProps {
  repository: ReleasesRepositoryImport;
  checked: boolean;
  versionFilterPrecisionOptions: string[];
  disabled: boolean;
  onImageSelectionChanged?: (isSelected: boolean) => void;
  onVisibilityChanged?: () => void;
  hidden?: boolean;
}

const ImportRepositorySelect = ({
  repository,
  checked,
  versionFilterPrecisionOptions,
  disabled = false,
  onImageSelectionChanged = undefined,
  onVisibilityChanged,
  hidden = false,
}: ImportRepositorySelectProps) => {
  const tRepository = useI18n("widget.releases.option.repositories");
  const actionT = useI18n("common.action");
  const provider = repository.provider;
  let visibilityLabel = actionT("hide");
  let VisibilityIcon = IconEyeOff;
  if (hidden) {
    visibilityLabel = actionT("show");
    VisibilityIcon = IconEye;
  }

  return (
    <Group gap="xl" justify="space-between">
      <Group gap="md" align="center">
        <Checkbox
          checked={checked}
          disabled={disabled}
          readOnly={disabled}
          onChange={() => {
            if (onImageSelectionChanged) {
              onImageSelectionChanged(!checked);
            }
          }}
          label={
            <Group align="center">
              <Image
                src={repository.iconUrl}
                style={{
                  height: "1.2em",
                  width: "1.2em",
                }}
              />
              <Text>{repository.identifier}</Text>
            </Group>
          }
        />

        {repository.versionFilter && (
          <Group gap={5}>
            <Text c="dimmed" size="xs">
              {tRepository("versionFilter.label")}:
            </Text>

            <Code>{repository.versionFilter.prefix}</Code>
            <Code color="var(--mantine-primary-color-light)" fw={700}>
              {versionFilterPrecisionOptions[repository.versionFilter.precision]}
            </Code>
            <Code>{repository.versionFilter.suffix}</Code>
          </Group>
        )}
      </Group>

      <Tooltip label={tRepository("noProvider.tooltip")} disabled={provider !== undefined} withArrow>
        <Group>
          {provider ? (
            <MaskedImage
              color="dimmed"
              imageUrl={getReleaseProviderIconUrl(provider)}
              style={{
                height: "1em",
                width: "1em",
              }}
            />
          ) : (
            <IconAlertTriangleFilled />
          )}

          <Text ff="monospace" c="dimmed" size="sm">
            {provider ? getReleaseProviderName(provider) : tRepository("noProvider.label")}
          </Text>
        </Group>
      </Tooltip>
      {onVisibilityChanged && (
        <Button
          size="compact-xs"
          variant="subtle"
          color="gray"
          leftSection={<VisibilityIcon size="1em" />}
          aria-label={`${visibilityLabel}: ${repository.identifier}`}
          onClick={onVisibilityChanged}
        >
          {visibilityLabel}
        </Button>
      )}
    </Group>
  );
};

interface RepositoryImportProps {
  repositories: ReleasesRepository[];
  hiddenSourceTokens: string[];
  versionFilterPrecisionOptions: string[];
  onConfirm: (selectedRepositories: ReleasesRepositoryImport[], hiddenSourceTokens: string[]) => void;
  isAdmin: boolean;
}

const RepositoryImportModal = createModal<RepositoryImportProps>(({ innerProps, actions }) => {
  const tRepository = useI18n("widget.releases.option.repositories");
  const tCommon = useI18n("common");
  const actionT = useI18n("common.action");
  const [loading, setLoading] = useState(false);
  const [selectedSourceTokens, setSelectedSourceTokens] = useState<string[]>([]);
  const [hiddenSourceTokens, setHiddenSourceTokens] = useState(innerProps.hiddenSourceTokens);
  const hiddenSources = useMemo(() => new Set(hiddenSourceTokens), [hiddenSourceTokens]);
  const selectedSources = useMemo(() => new Set(selectedSourceTokens), [selectedSourceTokens]);

  const docker = clientApi.docker.getContainers.useQuery(undefined, {
    refetchOnMount: false,
    enabled: innerProps.isAdmin,
  });

  const importRepositories: ReleasesRepositoryImport[] = useMemo(() => {
    if (!docker.data) return [];
    const imported = new Set(innerProps.repositories.map((item) => `${item.provider}:${item.identifier}`));
    const seen = new Set<string>();
    return docker.data.containers.reduce<ReleasesRepositoryImport[]>((acc, container) => {
      const source = getReleaseSourceFromDockerImage(container.image);
      if (!source || !container.releaseSourceToken) return acc;
      const { provider, identifier, version } = source;
      const key = `${provider}:${identifier}`;
      if (seen.has(key)) return acc;
      seen.add(key);

      acc.push({
        id: createId(),
        provider,
        identifier,
        iconUrl: container.iconUrl ?? undefined,
        name: formatIdentifierName(identifier),
        versionFilter: version ? parseImageVersionToVersionFilter(version) : undefined,
        alreadyImported: imported.has(key),
        sourceToken: container.releaseSourceToken,
      });
      return acc;
    }, []);
  }, [docker.data, innerProps.repositories]);

  const visibleRepositories = useMemo(
    () => importRepositories.filter((repository) => !hiddenSources.has(repository.sourceToken)),
    [importRepositories, hiddenSources],
  );
  const availableRepositories = useMemo(
    () => visibleRepositories.filter((repository) => !repository.alreadyImported),
    [visibleRepositories],
  );
  const selectedRepositories = useMemo(
    () => availableRepositories.filter((repository) => selectedSources.has(repository.sourceToken)),
    [availableRepositories, selectedSources],
  );
  const hiddenRepositories = useMemo(
    () => importRepositories.filter((repository) => hiddenSources.has(repository.sourceToken)),
    [importRepositories, hiddenSources],
  );
  const setSourceHidden = (key: string, hidden: boolean) => {
    if (hidden) {
      setHiddenSourceTokens((previous) => [...new Set([...previous, key])]);
      setSelectedSourceTokens((previous) => previous.filter((selected) => selected !== key));
      return;
    }
    setHiddenSourceTokens((previous) => previous.filter((source) => source !== key));
  };
  const hasHiddenChanges =
    hiddenSourceTokens.length !== innerProps.hiddenSourceTokens.length ||
    hiddenSourceTokens.some((key) => !innerProps.hiddenSourceTokens.includes(key));

  const handleConfirm = useCallback(() => {
    setLoading(true);

    innerProps.onConfirm(selectedRepositories, hiddenSourceTokens);

    setLoading(false);
    actions.closeModal();
  }, [innerProps, selectedRepositories, hiddenSourceTokens, actions]);

  const allImagesImported = useMemo(
    () => visibleRepositories.every((repository) => repository.alreadyImported),
    [visibleRepositories],
  );

  const anyImagesImported = useMemo(
    () => visibleRepositories.some((repository) => repository.alreadyImported),
    [visibleRepositories],
  );
  let initialSection = "";
  if (anyImagesImported) initialSection = "alreadyImported";
  if (!allImagesImported) initialSection = "foundImages";

  return (
    <Stack>
      {docker.isPending ? (
        <Stack justify="center" align="center">
          <Loader size="xl" />
          <Title order={3}>{tRepository("importRepositories.loading")}</Title>
        </Stack>
      ) : visibleRepositories.length === 0 && hiddenSourceTokens.length === 0 ? (
        <Stack justify="center" align="center">
          <IconBrandDocker stroke={1} size={128} />
          <Title order={3}>{tRepository("importRepositories.noImagesFound")}</Title>
        </Stack>
      ) : (
        <Stack>
          {visibleRepositories.length > 0 && (
            <Accordion defaultValue={initialSection}>
              <Accordion.Item value="foundImages">
                <Accordion.Control disabled={allImagesImported} icon={<IconZoomScan />}>
                  <Group>
                    {tRepository("importRepositories.listFoundImages")}
                    {allImagesImported && (
                      <Text c="dimmed" size="sm">
                        {tRepository("importRepositories.allImagesAlreadyImported")}
                      </Text>
                    )}
                  </Group>
                </Accordion.Control>
                <Accordion.Panel>
                  {!allImagesImported && (
                    <Stack justify="center" gap="xs">
                      <Group>
                        <Button
                          leftSection={<IconCopyCheckFilled size="1em" />}
                          onClick={() =>
                            setSelectedSourceTokens(availableRepositories.map((repository) => repository.sourceToken))
                          }
                          size="xs"
                        >
                          {tRepository("importRepositories.selectAll")}
                        </Button>
                        <Button
                          leftSection={<IconCopy size="1em" />}
                          onClick={() => setSelectedSourceTokens([])}
                          size="xs"
                          variant="default"
                          color="gray.5"
                        >
                          {tRepository("importRepositories.deselectAll")}
                        </Button>
                      </Group>

                      <Divider />

                      {availableRepositories.map((repository) => (
                        <ImportRepositorySelect
                          key={repository.id}
                          repository={repository}
                          checked={selectedSources.has(repository.sourceToken)}
                          versionFilterPrecisionOptions={innerProps.versionFilterPrecisionOptions}
                          disabled={false}
                          onImageSelectionChanged={(isSelected) => {
                            const key = repository.sourceToken;
                            if (isSelected) {
                              setSelectedSourceTokens((previous) => [...previous, key]);
                              return;
                            }
                            setSelectedSourceTokens((previous) => previous.filter((selected) => selected !== key));
                          }}
                          onVisibilityChanged={() => setSourceHidden(repository.sourceToken, true)}
                        />
                      ))}
                    </Stack>
                  )}
                </Accordion.Panel>
              </Accordion.Item>
              <Accordion.Item value="alreadyImported">
                <Accordion.Control disabled={!anyImagesImported} icon={<IconPackageImport />}>
                  {tRepository("importRepositories.listAlreadyImportedImages")}
                </Accordion.Control>
                <Accordion.Panel>
                  {anyImagesImported && (
                    <Stack justify="center" gap="xs">
                      {visibleRepositories
                        .filter((repository) => repository.alreadyImported)
                        .map((repository) => (
                          <ImportRepositorySelect
                            key={repository.id}
                            repository={repository}
                            versionFilterPrecisionOptions={innerProps.versionFilterPrecisionOptions}
                            checked
                            disabled
                            onVisibilityChanged={() => setSourceHidden(repository.sourceToken, true)}
                          />
                        ))}
                    </Stack>
                  )}
                </Accordion.Panel>
              </Accordion.Item>
            </Accordion>
          )}
        </Stack>
      )}

      {hiddenSourceTokens.length > 0 && (
        <Accordion defaultValue="hidden">
          <Accordion.Item value="hidden">
            <Accordion.Control icon={<IconEyeOff />}>
              {tCommon("hidden")} ({hiddenSourceTokens.length})
            </Accordion.Control>
            <Accordion.Panel>
              <Stack gap="xs">
                <Group justify="flex-end">
                  <Button size="xs" variant="subtle" onClick={() => setHiddenSourceTokens([])}>
                    {actionT("showAll")}
                  </Button>
                </Group>
                {hiddenRepositories.map((repository) => (
                  <ImportRepositorySelect
                    key={repository.sourceToken}
                    repository={repository}
                    checked={false}
                    disabled
                    hidden
                    versionFilterPrecisionOptions={innerProps.versionFilterPrecisionOptions}
                    onVisibilityChanged={() => setSourceHidden(repository.sourceToken, false)}
                  />
                ))}
              </Stack>
            </Accordion.Panel>
          </Accordion.Item>
        </Accordion>
      )}

      <Group justify="flex-end">
        <Button variant="default" onClick={actions.closeModal} color="gray.5">
          {actionT("cancel")}
        </Button>

        <Button
          onClick={handleConfirm}
          loading={loading}
          disabled={selectedRepositories.length === 0 && !hasHiddenChanges}
        >
          {actionT("confirm")}
        </Button>
      </Group>
    </Stack>
  );
}).withOptions({
  defaultTitle(t) {
    return t("widget.releases.option.repositories.importForm.title");
  },
  size: "xl",
});

const parseImageVersionToVersionFilter = (imageVersion: string): ReleasesVersionFilter | undefined => {
  const version = /(?<=\D|^)\d+(?:\.\d+)*(?![\d.])/.exec(imageVersion)?.[0];

  if (!version) return undefined;

  const [prefix, suffix] = imageVersion.split(version);

  return {
    prefix,
    precision: version.split(".").length,
    suffix,
  };
};