mime.ex

defmodule MIME do
  @moduledoc """
  Maps MIME types to its file extensions and vice versa.

  MIME types can be extended in your application configuration
  as follows:

      config :mime, :types, %{
        "application/vnd.api+json" => ["json-api"]
      }

  Note that defining a new type will completely override all
  previous extensions. You can use `MIME.extensions/1` to get
  the existing extension to keep when redefining.

  You can also customize the extensions for suffixes. For example,
  the mime type "application/custom+gzip" returns the extension
  `".gz"` because the suffix "gzip" maps to `["gz"]`:

      config :mime, :suffixes, %{
        "gzip" => ["gz"]
      }

  After adding the configuration, MIME needs to be recompiled
  if you are using an Elixir version earlier than v1.15. In such
  cases, it can be done with:

      $ mix deps.clean mime --build

  """

  types = %{
    "application/atom+xml" => ["atom"],
    "application/epub+zip" => ["epub"],
    "application/gzip" => ["gz"],
    "application/java-archive" => ["jar"],
    "application/javascript" => ["js"],
    "application/json" => ["json"],
    "application/json-patch+json" => ["json-patch"],
    "application/ld+json" => ["jsonld"],
    "application/manifest+json" => ["webmanifest"],
    "application/msword" => ["doc"],
    "application/octet-stream" => ["bin"],
    "application/ogg" => ["ogx"],
    "application/pdf" => ["pdf"],
    "application/postscript" => ["ps", "eps", "ai"],
    "application/rss+xml" => ["rss"],
    "application/rtf" => ["rtf"],
    "application/vnd.amazon.ebook" => ["azw"],
    "application/vnd.api+json" => ["json-api"],
    "application/vnd.apple.installer+xml" => ["mpkg"],
    "application/vnd.etsi.asic-e+zip" => ["asice", "sce"],
    "application/vnd.etsi.asic-s+zip" => ["asics", "scs"],
    "application/vnd.mozilla.xul+xml" => ["xul"],
    "application/vnd.ms-excel" => ["xls"],
    "application/vnd.ms-fontobject" => ["eot"],
    "application/vnd.ms-powerpoint" => ["ppt"],
    "application/vnd.oasis.opendocument.presentation" => ["odp"],
    "application/vnd.oasis.opendocument.spreadsheet" => ["ods"],
    "application/vnd.oasis.opendocument.text" => ["odt"],
    "application/vnd.openxmlformats-officedocument.presentationml.presentation" => ["pptx"],
    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" => ["xlsx"],
    "application/vnd.openxmlformats-officedocument.wordprocessingml.document" => ["docx"],
    "application/vnd.rar" => ["rar"],
    "application/vnd.visio" => ["vsd"],
    "application/wasm" => ["wasm"],
    "application/x-7z-compressed" => ["7z"],
    "application/x-abiword" => ["abw"],
    "application/x-bzip" => ["bz"],
    "application/x-bzip2" => ["bz2"],
    "application/x-cdf" => ["cda"],
    "application/x-csh" => ["csh"],
    "application/x-freearc" => ["arc"],
    "application/x-httpd-php" => ["php"],
    "application/x-msaccess" => ["mdb"],
    "application/x-sh" => ["sh"],
    "application/x-shockwave-flash" => ["swf"],
    "application/x-tar" => ["tar"],
    "application/xhtml+xml" => ["xhtml"],
    "application/xml" => ["xml"],
    "application/zip" => ["zip"],
    "application/zstd" => ["zst"],
    "audio/3gpp" => ["3gp"],
    "audio/3gpp2" => ["3g2"],
    "audio/aac" => ["aac"],
    "audio/matroska" => ["mka"],
    "audio/midi" => ["mid", "midi"],
    "audio/mpeg" => ["mp3"],
    "audio/mp4" => ["m4a"],
    "audio/ogg" => ["oga"],
    "audio/opus" => ["opus"],
    "audio/wav" => ["wav"],
    "audio/webm" => ["weba"],
    "audio/x-matroska" => ["mka"],
    "font/otf" => ["otf"],
    "font/ttf" => ["ttf"],
    "font/woff" => ["woff"],
    "font/woff2" => ["woff2"],
    "image/apng" => ["apng"],
    "image/avif" => ["avif"],
    "image/bmp" => ["bmp"],
    "image/gif" => ["gif"],
    "image/heic" => ["heic"],
    "image/heif" => ["heif"],
    "image/jp2" => ["jp2"],
    "image/jpeg" => ["jpg", "jpeg"],
    "image/jxl" => ["jxl"],
    "image/png" => ["png"],
    "image/svg+xml" => ["svg", "svgz"],
    "image/tiff" => ["tiff", "tif"],
    "image/vnd.adobe.photoshop" => ["psd"],
    "image/vnd.microsoft.icon" => ["ico"],
    "image/webp" => ["webp"],
    "text/calendar" => ["ics"],
    "text/css" => ["css"],
    "text/csv" => ["csv"],
    "text/html" => ["html", "htm"],
    "text/javascript" => ["js", "mjs"],
    "text/markdown" => ["md", "markdown"],
    "text/plain" => ["txt", "text"],
    "text/xml" => ["xml"],
    "video/3gpp" => ["3gp"],
    "video/3gpp2" => ["3g2"],
    "video/matroska" => ["mkv"],
    "video/matroska-3d" => ["mk3d"],
    "video/mp2t" => ["ts"],
    "video/mp4" => ["mp4"],
    "video/mpeg" => ["mpeg", "mpg"],
    "video/ogg" => ["ogv"],
    "video/quicktime" => ["mov"],
    "video/webm" => ["webm"],
    "video/x-matroska" => ["mkv"],
    "video/x-matroska-3d" => ["mk3d"],
    "video/x-ms-wmv" => ["wmv"],
    "video/x-msvideo" => ["avi"]
  }

  require Application
  custom_types = Application.compile_env(:mime, :types, %{})

  to_exts = fn map ->
    for {media, exts} <- map, ext <- exts, reduce: %{} do
      acc -> Map.update(acc, ext, media, &[media | List.wrap(&1)])
    end
  end

  all_types = Map.merge(types, custom_types)

  default_exts = %{
    "3g2" => "video/3gpp2",
    "3gp" => "video/3gpp",
    "js" => "text/javascript",
    "mk3d" => "video/matroska-3d",
    "mka" => "audio/matroska",
    "mkv" => "video/matroska",
    "xml" => "text/xml"
  }

  custom_exts = Application.compile_env(:mime, :extensions, %{})
  all_exts = Map.merge(to_exts.(all_types), Map.merge(default_exts, custom_exts))

  # https://www.iana.org/assignments/media-type-structured-suffix/media-type-structured-suffix.xhtml
  default_suffixes = %{
    "gzip" => ["gz"],
    "json" => ["json"],
    "xml" => ["xml"],
    "zip" => ["zip"],
    "zstd" => ["zst"]
  }

  custom_suffixes = Application.compile_env(:mime, :suffixes, %{})
  suffixes = Map.merge(default_suffixes, custom_suffixes)

  @doc """
  Returns the custom types compiled into the MIME module.
  """
  def compiled_custom_types do
    unquote(Macro.escape(custom_types))
  end

  @doc """
  Returns a mapping of all known types to their extensions,
  including custom types compiled into the MIME module.

  ## Examples

      known_types()
      #=> %{"application/json" => ["json"], ...}

  """
  @doc since: "2.1.0"
  @spec known_types() :: %{required(String.t()) => [String.t()]}
  def known_types do
    unquote(Macro.escape(all_types))
  end

  @doc """
  Returns the extensions associated with a given MIME type.

  ## Examples

      iex> MIME.extensions("text/html")
      ["html", "htm"]

      iex> MIME.extensions("application/json")
      ["json"]

      iex> MIME.extensions("application/vnd.custom+xml")
      ["xml"]

      iex> MIME.extensions("foo/bar")
      []

  """
  @spec extensions(String.t()) :: [String.t()]
  def extensions(type) do
    mime =
      type
      |> strip_params()
      |> downcase("")

    mime_to_ext(mime) || suffix(mime) || []
  end

  defp suffix(type) do
    case String.split(type, "+") do
      [_type_subtype_without_suffix, suffix] -> suffix_to_ext(suffix)
      _ -> nil
    end
  end

  @default_type "application/octet-stream"

  @doc """
  Returns the MIME type associated with a file extension.

  If no MIME type is known for `file_extension`,
  `#{inspect(@default_type)}` is returned.

  ## Examples

      iex> MIME.type("html")
      "text/html"

      iex> MIME.type("foobarbaz")
      #{inspect(@default_type)}

  """
  @spec type(String.t()) :: String.t()
  def type(file_extension) do
    ext_to_mime(file_extension) || @default_type
  end

  @doc """
  Returns whether an extension has a MIME type registered.

  ## Examples

      iex> MIME.has_type?("html")
      true

      iex> MIME.has_type?("foobarbaz")
      false

  """
  @spec has_type?(String.t()) :: boolean
  def has_type?(file_extension) do
    is_binary(ext_to_mime(file_extension))
  end

  @doc """
  Guesses the MIME type based on the path's extension. See `type/1`.

  ## Examples

      iex> MIME.from_path("index.html")
      "text/html"

  """
  @spec from_path(Path.t()) :: String.t()
  def from_path(path) do
    case Path.extname(path) do
      "." <> ext -> type(downcase(ext, ""))
      _ -> @default_type
    end
  end

  defp strip_params(string) do
    string |> :binary.split(";") |> hd()
  end

  defp downcase(<<h, t::binary>>, acc) when h in ?A..?Z,
    do: downcase(t, <<acc::binary, h + 32>>)

  defp downcase(<<h, t::binary>>, acc), do: downcase(t, <<acc::binary, h>>)
  defp downcase(<<>>, acc), do: acc

  @spec ext_to_mime(String.t()) :: String.t() | nil
  defp ext_to_mime(type)

  for {ext, mimes} <- all_exts do
    case mimes do
      [first | _] ->
        raise """
        extension .#{ext} currently maps to different mime-types: #{inspect(mimes)}

        You must tell us which mime-type is preferred by defining the :extensions \
        configuration. For example:

            config :mime, :extensions, %{
              #{inspect(ext)} => #{inspect(first)}
            }

        """

      mime ->
        defp ext_to_mime(unquote(ext)), do: unquote(mime)
    end
  end

  defp ext_to_mime(_ext), do: nil

  @spec mime_to_ext(String.t()) :: list(String.t()) | nil
  defp mime_to_ext(type)

  for {type, exts} <- all_types do
    defp mime_to_ext(unquote(type)), do: unquote(List.wrap(exts))
  end

  defp mime_to_ext(_type), do: nil

  @spec suffix_to_ext(String.t()) :: list(String.t()) | nil
  defp suffix_to_ext(suffix)

  for {suffix, exts} <- suffixes do
    defp suffix_to_ext(unquote(suffix)), do: unquote(List.wrap(exts))
  end

  defp suffix_to_ext(_suffix), do: nil
end