jekyll-simple-assets 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95843e3923fd2624c717ab799fe08f4497bd7c7d55febc86b5dd3bbf7ec9d6e7
-  data.tar.gz: 0e93ea72b7a5b06521ec61a7a8264120d1221c0e98a5a86ed426340c188f431f
+  metadata.gz: f9a88ce587480260a2b882650c270bdc2109b2e85fb0171259b19134d8860c7e
+  data.tar.gz: 89d8af9b0ccc245da99c45e43369cfb636e978d862ad80a7bf01a595f2df75f6
 SHA512:
-  metadata.gz: 4307d2592ab2f9885305b2fe23b8fdcdfe86f9e2d2edc41212ba7f1de32b756b054d7fc20273666b64120aac11bdc9256abba9d0d0372a32fa10966d0d798182
-  data.tar.gz: ebcd8ed79fb7d17969a669928fa2e90c957c7f83dbccd6942676d952cb33e00596f483a37cef191e9c1624170511af235ad1888d3a53afb2ce8b3ff64e1794ea
+  metadata.gz: d4104483ef4f80d627cab01fbc07799aae26849d4015ec03671b4cd74ed09728d39f7f2ffdcef339c2fc5a7ace21933b8218c200a34750216ac40234f3e7bb69
+  data.tar.gz: 144171dcfee48d6800d2796ed8eb14772ea82873914e5b53f616a206bfe1af28b73c6c2ba5b265edaae9de24931877f5f0a69cfd2ee5d6fce50939186a72f4fb

data/Gemfile.lock

@@ -0,0 +1,81 @@
+PATH
+  remote: .
+  specs:
+    jekyll-simple-assets (0.6.0)
+      css_parser
+      jekyll
+      terser
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    colorator (1.1.0)
+    concurrent-ruby (1.1.8)
+    css_parser (1.9.0)
+      addressable
+    em-websocket (0.5.2)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0.6.0)
+    eventmachine (1.2.7)
+    execjs (2.7.0)
+    ffi (1.15.0)
+    forwardable-extended (2.6.0)
+    http_parser.rb (0.6.0)
+    i18n (1.8.9)
+      concurrent-ruby (~> 1.0)
+    jekyll (4.2.0)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      em-websocket (~> 0.5)
+      i18n (~> 1.0)
+      jekyll-sass-converter (~> 2.0)
+      jekyll-watch (~> 2.0)
+      kramdown (~> 2.3)
+      kramdown-parser-gfm (~> 1.0)
+      liquid (~> 4.0)
+      mercenary (~> 0.4.0)
+      pathutil (~> 0.9)
+      rouge (~> 3.0)
+      safe_yaml (~> 1.0)
+      terminal-table (~> 2.0)
+    jekyll-sass-converter (2.1.0)
+      sassc (> 2.0.1, < 3.0)
+    jekyll-watch (2.2.1)
+      listen (~> 3.0)
+    kramdown (2.3.1)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    liquid (4.0.3)
+    listen (3.5.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    mercenary (0.4.0)
+    pathutil (0.16.2)
+      forwardable-extended (~> 2.6)
+    public_suffix (4.0.6)
+    rb-fsevent (0.10.4)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rexml (3.2.4)
+    rouge (3.26.0)
+    safe_yaml (1.0.5)
+    sassc (2.4.0)
+      ffi (~> 1.9)
+    terminal-table (2.0.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    terser (1.1.3)
+      execjs (>= 0.3.0, < 3)
+    unicode-display_width (1.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jekyll-simple-assets!
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -12,21 +12,22 @@ webpack.
 
 #### contenthash
 
-Returns an (md5) hash based on the contents of the path given.
+Returns a base64 encoded md5 hash based on the contents of the path given.
 
 ```liquid
 {% contenthash assets/js/app.js %}
-// 329CF90732DF0C89EF8FB0B7E9416FE3
+// Mpz5BzLfDInvj7C36UFv4w==
 ```
 
 #### asset
 
 Returns a relative url to the path given, with a hash based on the content of
 the file as a query string.
+Will link to a minified version of the file if possible.
 
 ```liquid
 {% asset assets/js/app.js %}
-// /assets/js/app.js?v=329CF90732DF0C89EF8FB0B7E9416FE3
+// /assets/js/app.js?v=Mpz5BzLfDInvj7C36UFv4w==
 ```
 
 #### bundle
@@ -58,9 +59,120 @@ Returns an md5 hash of the input string.
 {{ 'some text' | md5 }}
 ```
 
+#### uglify
+
+Minifies javascript given as an input string (uses terser, and terser settings
+even though the filter is called `uglify`
+
+```liquid
+{{ 'const foo = "bar"' | uglify }}
+```
+
 ## Content hashes
 
 How the content hashes work is by generating a placeholder string that is
 passed to the template. Once all of the sites files and pages have been
 processed and copied over, the content hashes are worked out, and the
 placeholder string in the pages output is replaced with the hash.
+
+Because of this you need to be careful with using capture tags around or trying
+to manipulate the output of the contenthash or asset tags.
+
+By default the generation of content hashes is only enabled for production
+builds (if JEKYLL_ENV is set to 'production').
+
+## Critical CSS
+
+This plugin can also be used to generate critical css stylesheets. See
+configuration for more information on doing this. To generate critical css,
+[critical](https://github.com/addyosmani/critical) must be installed.
+
+## Javascript/Typescript bundling
+
+This plugin can also be used to bundle javascript and typescript files and
+modules using esbuild. Node modules can be included just by requiring them.
+Local modules can be required under the `@simple-assets` namespace, which
+will look for js files in the `_js` and `_ts` directories.
+
+For example:
+```javascript
+// assets/js/main.js
+
+// require node_module
+var leftpad = require('left-pad');
+
+// will look for left-pad.js or left-pad.ts at _js/ or _ts/ in the
+// project root
+var rightpad = require('@simple-assets/right-pad');
+```
+
+You can also put variables in the liquid frontmatter of a js/ts file (that is
+not under `_js` or `_ts`) to configure esbuild.
+
+```liquid
+---
+bundle: false # don't bundle or run esbuild on this file
+esbuild_flags: --target=es5 # pass any flags to esbuild for this file
+---
+```
+
+To bundle javascript [esbuild](https://github.com/evanw/esbuild) must be
+installed.
+
+## Javascript minification
+
+The terser package is also included and will minify files if `terser_enabled`
+is set to true in config.yml, or if JEKYLL_ENV is set to production. Any
+options can be passed to terser under the `terser` key in config.yml
+(see configuration for example, or
+[here](https://github.com/ahorek/terser-ruby) for detailed options).
+Additionally you can set terser settings in the liquid frontmatter of a js file
+in the same manner as in config.yml, also under the `terser` key.
+
+## Configuration
+
+```
+simple_assets:
+  # If set to true generation of content hashes will be enabled, even in a non
+  # production build.
+  # default: false
+  hashing_enabled: true
+
+  # If set to true, source maps will be generated for javascript
+  # default: false
+  source_maps_enabled: true
+
+  # The length of the content hashes generated.
+  # default: 16
+  hash_length: 8
+
+  # Options for generating a critical css file using the `critical` npm module
+  critical_css:
+
+    # Array of source css files used to take the critical css from
+    css_files:
+      - assets/css/style.css
+
+    # Array of critical css files to generate
+    files:
+        # The path of the critical css file output
+      - output_file: assets/css/critical.css
+	# The path of the input page used to generate the critical css
+        # either this option or layout can be used
+        input_page_path: _drafts/webmentions-static-site.md
+        # The layout to use to generate critical css
+        # (will use the first page found with this layout)
+        layout: post
+        # If the rules should be removed from the original source css files
+        extract: true
+
+  # Options for bundling javascript/typescript with the `esbuild` npm module
+  # Set to true to enable
+  bundle: true
+
+  # Options for javascript minification with terser
+  terser:
+    # any options for terser can be put here and will be passed to it
+    output:
+      ascii_only: true
+```

data/jekyll-simple-assets.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |spec|
 	spec.required_ruby_version = ">= 2.3.0"
 	
 	spec.add_runtime_dependency "jekyll"
+	spec.add_runtime_dependency "css_parser"
+	spec.add_runtime_dependency "terser"
 	
 	spec.add_development_dependency "bundler"
 end

data/lib/jekyll-simple-assets.rb

@@ -2,9 +2,50 @@
 
 require 'digest'
 require 'pathname'
+require 'open3'
+require 'shellwords'
+
+require 'jekyll-simple-assets/content-hash'
+require 'jekyll-simple-assets/critical'
+require 'jekyll-simple-assets/esbuild'
+require 'jekyll-simple-assets/terser'
 
 module Jekyll
 	module SimpleAssets
+		def self.site (site = nil)
+			@@site = site if site
+
+			@@site
+		end
+
+		def self.config
+			@@config ||= @@site.config['simple_assets']
+		end
+
+		def self.hashing_enabled?
+			config['hashing_enabled'] || ENV['JEKYLL_ENV'] == 'production'
+		end
+
+		def self.critical_css_enabled?
+			config.key?('critical_css')
+		end
+
+		def self.esbuild_enabled?
+			config.key?('bundle') && config['bundle'] != false
+		end
+
+		def self.esbuild_config_file (file = nil)
+			@@esbuild_config_file ||= file
+		end
+
+		def self.terser_enabled?
+			config['terser_enabled'] || ENV['JEKYLL_ENV'] == 'production'
+		end
+
+		def self.source_maps_enabled?
+			config['source_maps_enabled']
+		end
+
 		module SimpleAssetsFilters
 			def md5 (input)
 				Digest::MD5.hexdigest(input)
@@ -13,13 +54,13 @@ module Jekyll
 
 		class BundleTag < Jekyll::Tags::IncludeTag
 			def tag_includes_dirs(context)
-				[ "_js", "_assets" ].freeze
+				[ "_js", "_javascript", "_assets" ].freeze
 			end
 		end
 
 		class BundleRawTag < Jekyll::Tags::IncludeTag
 			def tag_includes_dirs(context)
-				[ "_js", "_assets" ].freeze
+				[ "_js", "_javascript", "_assets" ].freeze
 			end
 
 			def render(context)
@@ -35,198 +76,105 @@ module Jekyll
 
 				return unless File.file? path
 
-				begin
-					content = File.read path
-				end
+				content = File.read path
 
 				content
 			end
 		end
+	end
+end
 
-		def self.page_assets_map
-			@@page_assets_map ||= {}
-		end
-
-		def self.asset_placeholder_map
-			@@asset_placeholder_map ||= {}
-		end
-
-		def self.asset_contenthash_map
-			@@asset_contenthash_map ||= {}
-		end
-
-		def self.get_placeholder (asset_path)
-			asset_placeholder_map[asset_path] ||= Digest::MD5.hexdigest(asset_path)
-		end
-
-		def self.relative_url (site, path)
-			"#{ site.config['baseurl'] }/#{ path }".gsub(%r{/{2,}}, '/')
-		end
-
-		class AssetTag < Liquid::Tag
-			def initialize (tag_name, text, tokens)
-				super
-				@text = text
-			end
-
-			def get_value (context, expression)
-				result = nil
-
-				unless expression.empty?
-					lookup_path = expression.split('.')
-					result = context
-					lookup_path.each do |variable|
-						result = result[variable] if result
-					end
-				end
-
-				case result
-				when 'true'
-					result = true
-				when 'false'
-					result = false
-				end
-
-				result || expression
-			end
-
-			def render (context)
-				site = context.registers[:site]
-				page = context.environments.first['page']
-
-				args = Shellwords.split(@text)
+Liquid::Template.register_tag('bundle', Jekyll::SimpleAssets::BundleTag)
+Liquid::Template.register_tag('bundle_raw', Jekyll::SimpleAssets::BundleRawTag)
 
-				page_path = context['page']['path'].sub(/^\//, '')
+Liquid::Template.register_filter(Jekyll::SimpleAssets::SimpleAssetsFilters)
 
-				asset_path = get_value(context, args[0]).sub(/^\//, '')
+Jekyll::Hooks.register :site, :post_render, priority: :low do |site, payload|
+	Jekyll::SimpleAssets::site(site)
 
-				if ENV['JEKYLL_ENV'] == 'production'
-					SimpleAssets::page_assets_map[page_path] ||= {}
-					SimpleAssets::page_assets_map[page_path][asset_path] ||= {}
-					SimpleAssets::page_assets_map[page_path][asset_path][@type] ||= []
+	potential_assets = []
 
-					placeholder = SimpleAssets::get_placeholder(asset_path)
+	potential_assets += site.pages
+	potential_assets += site.static_files
 
-					SimpleAssets::page_assets_map[page_path][asset_path][@type] << placeholder
+	potential_pages = potential_assets
 
-					"#{ @type }::#{ placeholder }"
-				else
-					SimpleAssets::relative_url(site, asset_path)
-				end
-			end
-		end
+	site.collections.each do |collection_name, collection|
+		potential_pages = potential_pages + collection.docs
+	end
 
-		class PathTag < AssetTag
-			def initialize (tag_name, text, tokens)
-				super
-				@type = 'path'
-			end
+	if Jekyll::SimpleAssets::critical_css_enabled?
+		potential_assets.each do |asset|
+			Jekyll::SimpleAssets::make_temp_css_files_for_critical(asset)
 		end
 
-		class ContentHashTag < AssetTag
-			def initialize (tag_name, text, tokens)
-				super
-				@type = 'contenthash'
-			end
+		potential_pages.each do |doc|
+			Jekyll::SimpleAssets::get_html_input_for_critical(doc, site)
 		end
 
-		def self.resolve_asset_content_hashes (asset, site)
-			asset_path = asset.path.sub("#{ site.config['source'] }/", '')
-
-			if File.extname(asset_path) == '.scss'
-				asset_path = Pathname.new(asset_path).sub_ext('.css').to_path()
-			elsif File.extname(asset_path) == '.ts'
-				asset_path = Pathname.new(asset_path).sub_ext('.js').to_path()
-			end
-
-			return unless SimpleAssets::asset_placeholder_map[asset_path]
-			return if SimpleAssets::asset_contenthash_map[asset_path]
-
-			content = ""
-
-			# Prefer reading from output if available, because in theory should
-			# be faster than from disk, but fall back to reading from disk for
-			# static assets.
-			if asset.respond_to? :output
-				content = asset.output
-			elsif File.file? asset_path
-				content = File.read asset_path
-			elsif File.file? asset.path
-				content = File.read asset.path
-			else
-				Jekyll.logger.warn "SimpleAssets", "File: #{ asset_path } not found"
-			end
+		Jekyll::SimpleAssets::generate_critical_css(site)
+	end
 
-			if content.nil?
-				Jekyll.logger.warn "SimpleAssets", "#{ asset_path } has no content"
-			end
+	if Jekyll::SimpleAssets::hashing_enabled?
+		potential_assets.each do |asset|
+			Jekyll::SimpleAssets::resolve_asset_content_hashes(asset, site)
+		end
 
-			SimpleAssets::asset_contenthash_map[asset_path] = Digest::MD5.hexdigest(content)
+		if Jekyll::SimpleAssets::critical_css_enabled?
+			Jekyll::SimpleAssets::resolve_critical_css_content_hashes(site)
 		end
 
-		def self.replace_placeholders_for_asset (doc, site)
+		potential_pages.each do |doc|
 			page_path = doc.path.sub("#{ site.config['source'] }/", '')
 
-			return unless SimpleAssets::page_assets_map[page_path]
-
-			SimpleAssets::page_assets_map[page_path].each do |asset_path, types|
-				types.each do |type, placeholders|
-					placeholders.each do |placeholder_hash|
-						unless SimpleAssets::asset_contenthash_map[asset_path]
-							Jekyll.logger.warn "SimpleAssets", "No contenthash for: #{ asset_path } not found"
-						end
-
-						replacement = SimpleAssets::asset_contenthash_map[asset_path]
-
-						if type == 'path'
-							replacement = "#{ asset_path }?v=#{ replacement }"
-
-							replacement = SimpleAssets::relative_url(site, replacement)
-						end
+			if Jekyll::SimpleAssets::page_assets_map[page_path]
+				doc.output = Jekyll::SimpleAssets::replace_placeholders_for_path(page_path, doc.output)
+			end
 
-						placeholder = "#{ type }::#{ SimpleAssets::asset_placeholder_map[asset_path] }"
+			if doc.extname =~ /^\.(j|t)s$/i and Jekyll::SimpleAssets::should_minify_file?(doc)
+				min_path, minified = Jekyll::SimpleAssets::minify_file(doc)
 
-						if placeholders.size > 1
-							doc.output = doc.output.gsub(placeholder, replacement)
-						else
-							doc.output = doc.output.sub(placeholder, replacement)
-						end
-					end
+				if min_path and Jekyll::SimpleAssets::page_assets_map[page_path]
+					minified = Jekyll::SimpleAssets::replace_placeholders_for_path(page_path, minified)
 				end
+
+				File.write(File.join(Jekyll::SimpleAssets::site.config['destination'], min_path), minified)
 			end
 		end
 	end
 end
 
-Liquid::Template.register_tag('asset', Jekyll::SimpleAssets::PathTag)
-Liquid::Template.register_tag('contenthash', Jekyll::SimpleAssets::ContentHashTag)
-Liquid::Template.register_tag('bundle', Jekyll::SimpleAssets::BundleTag)
-Liquid::Template.register_tag('bundle_raw', Jekyll::SimpleAssets::BundleRawTag)
-
-Liquid::Template.register_filter(Jekyll::SimpleAssets::SimpleAssetsFilters)
-
-if ENV['JEKYLL_ENV'] == 'production'
-	Jekyll::Hooks.register :site, :post_render do |site, payload|
-		potential_assets = []
-
-		potential_assets += site.pages
-		potential_assets += site.static_files
+Jekyll::Hooks.register :pages, :post_render do |page, payload|
+	unless Jekyll::SimpleAssets::esbuild_config_file
+		Jekyll::SimpleAssets::generate_esbuild_config_file()
+	end
 
-		potential_assets.each do |asset|
-			Jekyll::SimpleAssets::resolve_asset_content_hashes(asset, site)
+	if page.extname =~ /^\.(j|t)s$/i
+		if Jekyll::SimpleAssets::esbuild_enabled?
+			Jekyll::SimpleAssets::esbuild_bundle_file(page, payload, Jekyll::SimpleAssets::esbuild_config_file.path)
 		end
 
-		docs = []
-
-		site.pages.each do |doc|
-			Jekyll::SimpleAssets::replace_placeholders_for_asset(doc, site)
+		if Jekyll::SimpleAssets::should_minify_file?(page)
+			min_path = page.path.sub(/\.(j|t)s$/i, '.min.js')
+			File.write(File.join(Jekyll::SimpleAssets::site.config['destination'], min_path), '')
 		end
+	end
+end
 
-		site.collections.each do |collection_name, collection|
-			collection.docs.each do |doc|
-				Jekyll::SimpleAssets::replace_placeholders_for_asset(doc, site)
-			end
+Jekyll::Hooks.register :site, :post_read do |site|
+	css_pages = [];
+
+	site.pages.each do |doc|
+		if doc.extname == '.scss'
+			css_pages << doc
+			site.pages = site.pages - [ doc ]
 		end
 	end
+
+	site.pages = css_pages + site.pages
 end
 
+# Jekyll::Hooks.register :pages, :post_render do |document|
+# 	puts 'rendered:' + document.path
+# end
+

data/lib/jekyll-simple-assets/content-hash.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Jekyll
+module SimpleAssets
+
+
+def self.hash_length
+	config['hash_length'] || 16
+end
+
+def self.page_assets_map
+	@@page_assets_map ||= {}
+end
+
+def self.asset_placeholder_map
+	@@asset_placeholder_map ||= {}
+end
+
+def self.asset_contenthash_map
+	@@asset_contenthash_map ||= {}
+end
+
+def self.get_placeholder (asset_path)
+	asset_placeholder_map[asset_path] ||= Digest::MD5.base64digest(asset_path)
+end
+
+def self.relative_url (path)
+	"#{ @@site.config['baseurl'] || '' }/#{ path }".gsub(%r{/{2,}}, '/')
+end
+
+class AssetTag < Liquid::Tag
+	def initialize (tag_name, text, tokens)
+		super
+		@text = text
+	end
+
+	def get_value (context, expression)
+		result = nil
+
+		unless expression.empty?
+			lookup_path = expression.split('.')
+			result = context
+			lookup_path.each do |variable|
+				result = result[variable] if result
+			end
+		end
+
+		case result
+		when 'true'
+			result = true
+		when 'false'
+			result = false
+		end
+
+		result || expression
+	end
+
+	def render (context)
+		site = SimpleAssets::site(context.registers[:site])
+
+		page = context.environments.first['page']
+
+		args = Shellwords.split(@text)
+
+		page_path = context['page']['path'].sub(/^\//, '')
+
+		asset_path = get_value(context, args[0]).sub(/^\//, '')
+
+		if SimpleAssets::hashing_enabled?
+			SimpleAssets::page_assets_map[page_path] ||= {}
+			SimpleAssets::page_assets_map[page_path][asset_path] ||= {}
+			SimpleAssets::page_assets_map[page_path][asset_path][@type] ||= []
+
+			placeholder = SimpleAssets::get_placeholder(asset_path)
+
+			unless SimpleAssets::page_assets_map[page_path][asset_path][@type].include? placeholder
+				SimpleAssets::page_assets_map[page_path][asset_path][@type] << placeholder
+			end
+
+			"#{ @type }::#{ placeholder }"
+		else
+			if @type == 'path'
+				SimpleAssets::relative_url(asset_path)
+			else
+				placeholder[0, SimpleAssets::hash_length]
+			end
+		end
+	end
+end
+
+class PathTag < AssetTag
+	def initialize (tag_name, text, tokens)
+		super
+		@type = 'path'
+	end
+end
+
+class ContentHashTag < AssetTag
+	def initialize (tag_name, text, tokens)
+		super
+		@type = 'contenthash'
+	end
+end
+
+def self.resolve_asset_content_hashes (asset, site)
+	asset_path = asset.path.sub("#{ site.config['source'] }/", '')
+
+	if File.extname(asset_path) == '.scss'
+		asset_path = Pathname.new(asset_path).sub_ext('.css').to_path()
+	elsif File.extname(asset_path) == '.ts'
+		asset_path = Pathname.new(asset_path).sub_ext('.js').to_path()
+	end
+
+	return unless SimpleAssets::asset_placeholder_map[asset_path]
+	return if SimpleAssets::asset_contenthash_map[asset_path]
+
+	content = ""
+
+	# Prefer reading from output if available, because in theory should
+	# be faster than from disk, but fall back to reading from disk for
+	# static assets.
+	if asset.respond_to? :output
+		content = asset.output
+	elsif File.file? asset_path
+		content = File.read asset_path
+	elsif File.file? asset.path
+		content = File.read asset.path
+	else
+		Jekyll.logger.warn "SimpleAssets:", "File: #{ asset_path } not found"
+	end
+
+	if content.nil?
+		Jekyll.logger.warn "SimpleAssets:", "#{ asset_path } has no content"
+	end
+
+	base64hash = Digest::MD5.base64digest(content)
+
+	hash = base64hash[0, SimpleAssets::hash_length].gsub(/[+\/]/, '_')
+
+	SimpleAssets::asset_contenthash_map[asset_path] = hash
+end
+
+def self.replace_placeholders_for_path (page_path, input)
+	output = input
+
+	SimpleAssets::page_assets_map[page_path].each do |asset_path, types|
+		types.each do |type, placeholders|
+			placeholders.each do |placeholder_hash|
+				unless SimpleAssets::asset_contenthash_map[asset_path]
+					Jekyll.logger.warn "SimpleAssets:", "No contenthash for: #{ asset_path } not found"
+
+					next
+				end
+
+				replacement = SimpleAssets::asset_contenthash_map[asset_path]
+
+				if type == 'path'
+					min_path = asset_path.sub(/\.([^\.]*?)$/, '.min.\1')
+					url = (File.file? File.join(SimpleAssets::site.config['destination'], min_path)) ? min_path : asset_path
+
+					replacement = "#{ url }?v=#{ replacement }"
+
+					replacement = SimpleAssets::relative_url(replacement)
+				end
+
+				placeholder = "#{ type }::#{ SimpleAssets::asset_placeholder_map[asset_path] }"
+
+				output = output.gsub(placeholder, replacement)
+			end
+		end
+	end
+
+	output
+end
+
+
+end
+end
+
+Liquid::Template.register_tag('asset', Jekyll::SimpleAssets::PathTag)
+Liquid::Template.register_tag('contenthash', Jekyll::SimpleAssets::ContentHashTag)

data/lib/jekyll-simple-assets/critical.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'css_parser'
+require 'tempfile'
+
+module Jekyll
+module SimpleAssets
+
+
+def self.critical_css_source_files ()
+	@@critical_css_source_files ||= {}
+end
+
+def self.make_temp_css_files_for_critical (asset)
+	SimpleAssets::config['critical_css']['css_files'].each do |path|
+		next unless asset.path == path || asset.path == path.sub(/\.css$/, '.scss')
+
+		f = Tempfile.new([ 'css-source', '.css' ])
+		f.write asset.output
+		f.close
+
+		Jekyll.logger.debug("SimpleAssets:", "Created new temp file for css: #{ asset.path } at: #{ f.path }")
+
+		SimpleAssets::critical_css_source_files[path] = { 'file' => f, 'page' => asset }
+	end
+end
+
+def self.get_html_input_for_critical (doc, site)
+	return unless doc.respond_to? '[]'
+
+	SimpleAssets::config['critical_css']['files'].each do |file|
+		next if file['html']
+
+		page_path = doc.path.sub("#{ site.config['source'] }/", '')
+
+		next unless page_path == file['input_page_path'] || file['layout'] == doc['layout']
+
+		file['html'] = doc.output
+	end
+end
+
+def self.generate_critical_css (site)
+	css_files_str = ''
+
+	SimpleAssets::critical_css_source_files.each do |_, f|
+		css_files_str += "--css #{ f['file'].path } "
+
+		f['css'] = CssParser::Parser.new
+		f['css'].load_string! f['page'].output
+	end
+
+	SimpleAssets::config['critical_css']['files'].each do |file|
+		css_path = File.join(site.config['destination'], file['output_file'])
+
+		html = file['html']
+
+		critical_cmd = "npx critical #{ css_files_str }"
+
+		Jekyll.logger.debug("SimpleAssets:", "Running command: #{ critical_cmd }")
+
+		Open3.popen3(critical_cmd) do |stdin, stdout, stderr, wait_thr|
+			stdin.write(html)
+			stdin.close
+
+			if !wait_thr.value.success? || stderr.read != ''
+				Jekyll.logger.error("SimpleAssets:", 'Critical (css) error:')
+				stderr.each do |line|
+					Jekyll.logger.error("", line)
+				end
+			elsif stderr.read != ''
+				Jekyll.logger.error("SimpleAssets:", 'Critical (css) error:')
+				stderr.each do |line|
+					Jekyll.logger.error("", line)
+				end
+			end
+
+			critical_css_str = stdout.read
+
+			asset_path = file['output_file'].sub(/^\//, '')
+
+			base64hash = Digest::MD5.base64digest(critical_css_str)
+
+			hash = base64hash[0, SimpleAssets::hash_length].gsub(/[+\/]/, '_')
+
+			SimpleAssets::asset_contenthash_map[asset_path] = hash
+
+			IO.write(css_path, critical_css_str)
+
+			site.keep_files << asset_path
+
+			if file['extract']
+				critical_css = CssParser::Parser.new
+
+				critical_css.load_string! critical_css_str
+
+				SimpleAssets::critical_css_source_files.each do |_, f|
+					f['css'].each_rule_set do |source_rule_set, source_media_type|
+						critical_css.each_rule_set do |critical_rule_set, critical_media_type|
+							if critical_rule_set.selectors.join(',') == source_rule_set.selectors.join(',')
+								f['css'].remove_rule_set! source_rule_set, source_media_type
+								f['extract'] = true
+
+								break
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+
+	SimpleAssets::critical_css_source_files.each do |_, f|
+		leftover_css = f['css'].to_s if f['extract']
+
+		# css_parser leaves blank keyframes so fix them
+		keyframes = f['page'].output.scan(/@keyframes\s+(?:.*?)\s*{(?:\s*\S*?\s*{.*?}\s*)+}/m)
+		keyframes.each { |keyframe| leftover_css += keyframe }
+
+		f['page'].output
+	end
+end
+
+def self.resolve_critical_css_content_hashes (site)
+	SimpleAssets::critical_css_source_files.each do |_, source_file|
+		page = source_file['page']
+		page_path = page.path.sub("#{ site.config['source'] }/", '')
+
+		SimpleAssets::config['critical_css']['files'].each do |file|
+			css_path  = File.join(site.config['destination'], file['output_file'])
+			content = IO.read(css_path)
+
+			critical = SimpleAssets::replace_placeholders_for_path(page_path, content)
+
+			IO.write(css_path, critical)
+		end
+	end
+end
+
+
+end
+end

data/lib/jekyll-simple-assets/esbuild.rb

@@ -0,0 +1,92 @@
+module Jekyll
+module SimpleAssets
+
+def self.generate_esbuild_config_file ()
+	source_path = Jekyll::SimpleAssets::site.config['source']
+
+	tsconfig_path = File.join(source_path, 'jsconfig.json')
+	jsconfig_path = File.join(source_path, 'tsconfig.json')
+
+	config = {}
+
+	if File.file?(tsconfig_path)
+		config = JSON.parse(File.read(tsconfig_path))
+	elsif File.file?(jsconfig_path)
+		config = JSON.parse(File.read(jsconfig_path))
+	end
+
+	f = Tempfile.new([ 'jsconfig.esbuild.', '.json' ])
+
+	config['compilerOptions'] = {} unless config['compilerOptions']
+
+	base_url = source_path
+	if config['compilerOptions']['baseUrl']
+		base_url = File.join(source_path, config['compilerOptions']['baseUrl'])
+	end
+	config['compilerOptions']['baseUrl'] = Pathname.new(base_url).relative_path_from(Pathname.new(f.path))
+
+	config['compilerOptions']['paths'] = {} unless config['compilerOptions']['paths']
+
+	relative_path = Pathname.new(source_path).relative_path_from(Pathname.new(base_url))
+
+	config['compilerOptions']['paths']['@simple-assets/*'] = [
+		File.join(relative_path, '_js/*'),
+		File.join(relative_path, '_ts/*'),
+	]
+
+	f.write config.to_json
+	f.close
+
+	Jekyll::SimpleAssets::esbuild_config_file(f)
+
+	Jekyll.logger.debug("SimpleAssets:", "esbuild: using tsconfig #{ f.path }")
+end
+
+def self.esbuild_bundle_file (page, payload, config_path)
+	if page.data['bundle'] == false
+		return
+	end
+
+	bundle_cmd = "npx esbuild --bundle --tsconfig=#{ config_path }"
+
+	if page.data['esbuild_flags']
+		bundle_cmd += ' ' + page.data['esbuild_flags']
+	end
+
+	node_env = '--define:process.env.NODE_ENV="' + (ENV['JEKYLL_ENV'] != 'production' ? "'development'" : "'production'") + '"'
+
+	bundle_cmd += ' ' + node_env + " --sourcefile=#{ page.path[/[^\/]*$/] }"
+
+	if SimpleAssets::source_maps_enabled?
+		bundle_cmd += ' ' + '--sourcemap=inline'
+	end
+
+	dir = File.dirname(page.path)
+
+	Jekyll.logger.info("SimpleAssets:", 'bundling: ' + page.path)
+	Jekyll.logger.debug("SimpleAssets:", 'running command: ' + bundle_cmd)
+
+	Open3.popen3(bundle_cmd, :chdir => dir) do |stdin, stdout, stderr, wait_thr|
+		stdin.write(page.output)
+		stdin.close
+
+		bundled = stdout.read
+
+		if !wait_thr.value.success? || stderr.read != ''
+			Jekyll.logger.error("SimpleAssets:", 'esbuild error:')
+			stderr.each do |line|
+				Jekyll.logger.error("", line)
+			end
+		elsif stderr.read != ''
+			Jekyll.logger.error("SimpleAssets:", 'esbuild error:')
+			stderr.each do |line|
+				Jekyll.logger.error("", line)
+			end
+		end
+
+		page.output = bundled
+	end
+end
+
+end
+end

data/lib/jekyll-simple-assets/terser.rb

@@ -0,0 +1,100 @@
+require 'fileutils'
+require 'terser'
+
+module Jekyll
+
+module SimpleAssets
+	def self.symbolize_keys (hash)
+		return {} if hash.nil?
+
+		hash.inject({}) do |result, (key, value)|
+
+			new_key = case key
+				when String then key.to_sym
+				else key
+			end
+			new_value = case value
+				when Hash then symbolize_keys(value)
+				else value
+			end
+
+			if new_value.is_a?(String) and new_value.match(/^\/.*\/$/)
+				new_value = /#{ Regexp.quote(new_value[1..-2]) }/
+			end
+
+			result[new_key] = new_value
+
+			result
+		end
+	end
+
+	def self.merge_recursively(a, b)
+		a.merge(b) {|key, a_item, b_item| SimpleAssets::merge_recursively(a_item, b_item) }
+	end
+
+	def self.should_minify_file? (page)
+		return false unless page.respond_to? :output
+		return false unless SimpleAssets::terser_enabled?
+		return false if page.data['do_not_compress'] == true
+		return true
+	end
+
+	def self.minify_file (page)
+		return unless SimpleAssets::should_minify_file?(page)
+
+		site_config = symbolize_keys(SimpleAssets::site.config['simple_assets']['terser'])
+		page_config = symbolize_keys(page.data['terser'])
+
+		config = SimpleAssets::merge_recursively(site_config || {}, page_config || {})
+
+		map_path = page.path + '.map'
+		if SimpleAssets::source_maps_enabled?
+			config = SimpleAssets::merge_recursively(config, {
+				:source_map => { :filename => page.path[/[^\/]*$/], :url => true },
+			})
+
+			minified, source_map = Terser.new(config).compile_with_map(page.output)
+		else
+			minified = Terser.new(config).compile(page.output)
+		end
+
+		min_path = page.path.sub(/\.(j|t)s$/i, '.min.js')
+		Jekyll.logger.info("SimpleAssets:", 'minified: ' + min_path)
+
+		if source_map
+			File.write(File.join(SimpleAssets::site.config['destination'], map_path), source_map)
+			minified = minified.gsub(/^\/\/#\s*?source(Mapping)?URL=.*$/, '')
+			minified += "\n//# sourceMappingURL=#{ SimpleAssets::relative_url(map_path) }"
+
+			Jekyll.logger.debug("SimpleAssets:", 'created source map: ' + map_path)
+
+			SimpleAssets::site.config['keep_files'] << map_path
+		end
+
+		if SimpleAssets::page_assets_map[page.path]
+			SimpleAssets::page_assets_map[min_path] = SimpleAssets::page_assets_map[page.path]
+		end
+
+		SimpleAssets::site.config['keep_files'] << min_path
+
+		return min_path, minified
+	end
+
+	module UglifyFilter
+		def uglify (input)
+			return if input.nil?
+
+			return input.split('\n').join('\\\n') unless SimpleAssets::terser_enabled?
+
+			config = @context.registers[:site].config['simple_assets']
+
+			terser_config = SimpleAssets::symbolize_keys(config['terser'])
+
+			Terser.new(terser_config).compile(input)
+		end
+	end
+end
+
+end
+
+Liquid::Template.register_filter(Jekyll::SimpleAssets::UglifyFilter)

data/lib/jekyll-simple-assets/version.rb

@@ -2,6 +2,6 @@
 
 module Jekyll
 	module SimpleAssets
-		VERSION = "0.1.0"
+		VERSION = "0.6.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-simple-assets
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Sophie Askew
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-19 00:00:00.000000000 Z
+date: 2021-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: css_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -47,10 +75,15 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - jekyll-simple-assets.gemspec
 - lib/jekyll-simple-assets.rb
+- lib/jekyll-simple-assets/content-hash.rb
+- lib/jekyll-simple-assets/critical.rb
+- lib/jekyll-simple-assets/esbuild.rb
+- lib/jekyll-simple-assets/terser.rb
 - lib/jekyll-simple-assets/version.rb
 homepage: https://github.com/syldexiahime/jekyll-simple-assets
 licenses:
@@ -71,8 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: Some simple asset utils for jekyll