class Importmap::Map

# File lib/importmap/map.rb, line 14
def initialize
  @integrity = false
  @packages, @directories = {}, {}
  @cache = {}
end

# File lib/importmap/map.rb, line 185
def cache_sweeper(watches: nil)
  if watches
    @cache_sweeper =
      Rails.application.config.file_watcher.new([], Array(watches).collect { |dir| [ dir.to_s, "js"] }.to_h) do
        clear_cache
      end
  else
    @cache_sweeper
  end
end

# File lib/importmap/map.rb, line 178
def digest(resolver:)
  Digest::SHA1.hexdigest(to_json(resolver: resolver).to_s)
end

# File lib/importmap/map.rb, line 20
def draw(path = nil, &block)
  if path && File.exist?(path)
    begin
      instance_eval(File.read(path), path.to_s)
    rescue StandardError => e
      Rails.logger.error "Unable to parse import map from #{path}: #{e.message}"
      raise InvalidFile, "Unable to parse import map from #{path}: #{e.message}"
    end
  elsif block_given?
    instance_eval(&block)
  end

  self
end

# File lib/importmap/map.rb, line 67
def enable_integrity!
  clear_cache
  @integrity = true
end

# File lib/importmap/map.rb, line 72
def pin(name, to: nil, preload: true, integrity: true)
  clear_cache
  @packages[name] = MappedFile.new(name: name, path: to || "#{name}.js", preload: preload, integrity: integrity)
end

# File lib/importmap/map.rb, line 77
def pin_all_from(dir, under: nil, to: nil, preload: true, integrity: true)
  clear_cache
  @directories[dir] = MappedDir.new(dir: dir, under: under, path: to, preload: preload, integrity: integrity)
end

# File lib/importmap/map.rb, line 137
def preloaded_module_packages(resolver:, entry_point: "application", cache_key: :preloaded_module_packages)
  cache_as(cache_key) do
    expanded_preloading_packages_and_directories(entry_point:).filter_map do |_, package|
      resolved_path = resolve_asset_path(package.path, resolver: resolver)
      next unless resolved_path

      resolved_integrity = resolve_integrity_value(package.integrity, package.path, resolver: resolver)

      package = MappedFile.new(
        name: package.name,
        path: package.path,
        preload: package.preload,
        integrity: resolved_integrity
      )

      [resolved_path, package]
    end.to_h
  end
end

# File lib/importmap/map.rb, line 87
def preloaded_module_paths(resolver:, entry_point: "application", cache_key: :preloaded_module_paths)
  preloaded_module_packages(resolver: resolver, entry_point: entry_point, cache_key: cache_key).keys
end

# File lib/importmap/map.rb, line 162
def to_json(resolver:, cache_key: :json)
  cache_as(cache_key) do
    packages = expanded_packages_and_directories
    map = build_import_map(packages, resolver: resolver)
    JSON.pretty_generate(map)
  end
end

# File lib/importmap/map.rb, line 316
def absolute_root_of(path)
  (pathname = Pathname.new(path)).absolute? ? pathname : Rails.root.join(path)
end

# File lib/importmap/map.rb, line 235
def build_import_map(packages, resolver:)
  map = { "imports" => resolve_asset_paths(packages, resolver: resolver) }
  integrity = build_integrity_hash(packages, resolver: resolver)
  map["integrity"] = integrity unless integrity.empty?
  map
end

# File lib/importmap/map.rb, line 242
def build_integrity_hash(packages, resolver:)
  packages.filter_map do |name, mapping|
    next unless mapping.integrity

    resolved_path = resolve_asset_path(mapping.path, resolver: resolver)
    next unless resolved_path

    integrity_value = resolve_integrity_value(mapping.integrity, mapping.path, resolver: resolver)
    next unless integrity_value

    [resolved_path, integrity_value]
  end.to_h
end

# File lib/importmap/map.rb, line 200
def cache_as(name)
  if result = @cache[name.to_s]
    result
  else
    @cache[name.to_s] = yield
  end
end

# File lib/importmap/map.rb, line 208
def clear_cache
  @cache.clear
end

# File lib/importmap/map.rb, line 275
def expand_directories_into(paths)
  @directories.values.each do |mapping|
    if (absolute_path = absolute_root_of(mapping.dir)).exist?
      find_javascript_files_in_tree(absolute_path).each do |filename|
        module_filename = filename.relative_path_from(absolute_path)
        module_name     = module_name_from(module_filename, mapping)
        module_path     = module_path_from(module_filename, mapping)

        paths[module_name] = MappedFile.new(
          name: module_name,
          path: module_path,
          preload: mapping.preload,
          integrity: mapping.integrity
        )
      end
    end
  end
end

# File lib/importmap/map.rb, line 271
def expanded_packages_and_directories
  @packages.dup.tap { |expanded| expand_directories_into expanded }
end

# File lib/importmap/map.rb, line 267
def expanded_preloading_packages_and_directories(entry_point:)
  expanded_packages_and_directories.select { |name, mapping| mapping.preload.in?([true, false]) ? mapping.preload : (Array(mapping.preload) & Array(entry_point)).any? }
end

# File lib/importmap/map.rb, line 312
def find_javascript_files_in_tree(path)
  Dir[path.join("**/*.js{,m}")].sort.collect { |file| Pathname.new(file) }.select(&:file?)
end

# File lib/importmap/map.rb, line 294
def module_name_from(filename, mapping)
  # Regex explanation:
  # (?:\/|^) # Matches either / OR the start of the string
  # index   # Matches the word index
  # $       # Matches the end of the string
  #
  # Sample matches
  # index
  # folder/index
  index_regex = /(?:\/|^)index$/

  [ mapping.under, filename.to_s.chomp(filename.extname).remove(index_regex).presence ].compact.join("/")
end

# File lib/importmap/map.rb, line 308
def module_path_from(filename, mapping)
  [ mapping.path || mapping.under, filename.to_s ].compact.reject(&:empty?).join("/")
end

# File lib/importmap/map.rb, line 212
def rescuable_asset_error?(error)
  Rails.application.config.importmap.rescuable_asset_errors.any? { |e| error.is_a?(e) }
end

# File lib/importmap/map.rb, line 222
def resolve_asset_path(path, resolver:)
  begin
    resolver.path_to_asset(path)
  rescue => e
    if rescuable_asset_error?(e)
      Rails.logger.warn "Importmap skipped missing path: #{path}"
      nil
    else
      raise e
    end
  end
end

# File lib/importmap/map.rb, line 216
def resolve_asset_paths(paths, resolver:)
  paths.transform_values do |mapping|
    resolve_asset_path(mapping.path, resolver:)
  end.compact
end

# File lib/importmap/map.rb, line 256
def resolve_integrity_value(integrity, path, resolver:)
  return unless @integrity

  case integrity
  when true
    resolver.asset_integrity(path) if resolver.respond_to?(:asset_integrity)
  when String
    integrity
  end
end