Class: Importmap::Map

Inherits:
Object
  • Object
show all
Defined in:
lib/importmap/map.rb

Defined Under Namespace

Classes: InvalidFile, MappedDir, MappedFile

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Map

Returns a new instance of Map.



8
9
10
11
 
# File 'lib/importmap/map.rb', line 8

def initialize
  @packages, @directories = {}, {}
  @cache = {}
end

Instance Attribute Details

#directories ⇒ Object (readonly)

Returns the value of attribute directories.



4
5
6
 
# File 'lib/importmap/map.rb', line 4

def directories
  @directories
end

#packages ⇒ Object (readonly)

Returns the value of attribute packages.



4
5
6
 
# File 'lib/importmap/map.rb', line 4

def packages
  @packages
end

Instance Method Details

#cache_sweeper(watches: nil) ⇒ Object

Returns an instance of ActiveSupport::EventedFileUpdateChecker configured to clear the cache of the map when the directories passed on initialization via ‘watches:` have changes. This is used in development and test to ensure the map caches are reset when javascript files are changed.



75
76
77
78
79
80
81
82
83
84
 
# File 'lib/importmap/map.rb', line 75

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

#digest(resolver:) ⇒ Object

Returns a SHA1 digest of the import map json that can be used as a part of a page etag to ensure that a html cache is invalidated when the import map is changed.

Example:

class ApplicationController < ActionController::Base
  etag { Rails.application.importmap.digest(resolver: helpers) if request.format&.html? }
end



68
69
70
 
# File 'lib/importmap/map.rb', line 68

def digest(resolver:)
  Digest::SHA1.hexdigest(to_json(resolver: resolver).to_s)
end

#draw(path = nil, &block) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/importmap/map.rb', line 13

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

#pin(name, to: nil, preload: true) ⇒ Object 



28
29
30
31
 
# File 'lib/importmap/map.rb', line 28

def pin(name, to: nil, preload: true)
  clear_cache
  @packages[name] = MappedFile.new(name: name, path: to || "#{name}.js", preload: preload)
end

#pin_all_from(dir, under: nil, to: nil, preload: true) ⇒ Object 



33
34
35
36
 
# File 'lib/importmap/map.rb', line 33

def pin_all_from(dir, under: nil, to: nil, preload: true)
  clear_cache
  @directories[dir] = MappedDir.new(dir: dir, under: under, path: to, preload: preload)
end

#preloaded_module_paths(resolver:, entry_point: "application", cache_key: :preloaded_module_paths) ⇒ Object

Returns an array of all the resolved module paths of the pinned packages. The ‘resolver` must respond to `path_to_asset`, such as `ActionController::Base.helpers` or `ApplicationController.helpers`. You’ll want to use the resolver that has been configured for the ‘asset_host` you want these resolved paths to use. In case you need to resolve for different asset hosts, you can pass in a custom `cache_key` to vary the cache used by this method for the different cases.



43
44
45
46
47
 
# File 'lib/importmap/map.rb', line 43

def preloaded_module_paths(resolver:, entry_point: "application", cache_key: :preloaded_module_paths)
  cache_as(cache_key) do
    resolve_asset_paths(expanded_preloading_packages_and_directories(entry_point: entry_point), resolver: resolver).values
  end
end

#to_json(resolver:, cache_key: :json) ⇒ Object

Returns a JSON hash (as a string) of all the resolved module paths of the pinned packages in the import map format. The ‘resolver` must respond to `path_to_asset`, such as `ActionController::Base.helpers` or `ApplicationController.helpers`. You’ll want to use the resolver that has been configured for the ‘asset_host` you want these resolved paths to use. In case you need to resolve for different asset hosts, you can pass in a custom `cache_key` to vary the cache used by this method for the different cases.



54
55
56
57
58
 
# File 'lib/importmap/map.rb', line 54

def to_json(resolver:, cache_key: :json)
  cache_as(cache_key) do
    JSON.pretty_generate({ "imports" => resolve_asset_paths(expanded_packages_and_directories, resolver: resolver) })
  end
end