fastcomments-jekyll 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bbac3e1304d9a1a11836ab18c647a3af98b76c462dac4facd8455e0a4429a574
+  data.tar.gz: fc1b60e6e89f8a356032296b1787ef6c18384ee9d461a71b1727f1d4295d682b
+SHA512:
+  metadata.gz: f512271ee861ec296f97ab0004b1e45962fcc36f426d031d7c9ee5c7fdf703a41f4234d635e7557af941a5a1be08ac7f338d51c8e8273c3d5a3a6292670b03e3
+  data.tar.gz: 6e007a7a756c966587894535bc553c0dcae674fb34f3d17f726127593aced746acce011e116a9a63e5f671c788a2ea25184f13430227520dfb351cbbccd727cd

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## 1.0.0
+
+Initial release. Liquid tags for embedding FastComments widgets into Jekyll sites:
+
+- `fastcomments` - live commenting widget
+- `fastcomments_comment_count` - comment count for a page
+- `fastcomments_comment_count_bulk` - comment counts for many pages on one list/index page
+- `fastcomments_live_chat` - live chat widget
+- `fastcomments_collab_chat` - collaborative inline commenting (text annotations)
+- `fastcomments_image_chat` - image annotation comments
+- `fastcomments_recent_comments` - recent comments across the site
+- `fastcomments_recent_discussions` - recently active discussion threads
+- `fastcomments_reviews_summary` - star-rating reviews summary
+- `fastcomments_top_pages` - most-discussed pages
+- `fastcomments_user_activity_feed` - per-user activity feed

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FastComments
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# fastcomments-jekyll
+
+A fast, full-featured live commenting widget for [Jekyll](https://jekyllrb.com), powered by [FastComments](https://fastcomments.com).
+
+Adds Liquid tags like `{% raw %}{% fastcomments %}{% endraw %}` that you drop straight into your templates and posts.
+
+## Live Demo
+
+Try every widget live at <https://fastcomments.com/commenting-system-for-jekyll>.
+
+## Live Showcase
+
+To see every tag running locally against the public `demo` tenant, clone the repo and run:
+
+```bash
+cd example
+bundle install
+bundle exec jekyll serve
+```
+
+Each widget has its own page under `example/` that you can copy straight into your own Jekyll site.
+
+## Install
+
+[![Gem](https://img.shields.io/gem/v/fastcomments-jekyll?logo=rubygems&label=gem&color=e9573f)](https://rubygems.org/gems/fastcomments-jekyll)
+
+Add the gem to the `:jekyll_plugins` group in your site's `Gemfile`:
+
+```ruby
+group :jekyll_plugins do
+  gem "fastcomments-jekyll"
+end
+```
+
+Then:
+
+```bash
+bundle install
+```
+
+(Compatible with Jekyll 3.7+ and 4.x.)
+
+## Quick Start
+
+Set your tenant id once in `_config.yml`:
+
+```yaml
+fastcomments:
+  tenant_id: demo
+```
+
+Then add a tag wherever you want the widget, in a layout, a post, or a page:
+
+```liquid
+{% raw %}{% fastcomments %}{% endraw %}
+```
+
+That's it. Replace `demo` with your FastComments tenant id (find it under
+[Settings > API/SSO](https://fastcomments.com/auth/my-account/api)).
+
+## Tags
+
+| Tag | Description |
+| --- | --- |
+| `fastcomments` | Live commenting with replies, voting, moderation, and realtime updates |
+| `fastcomments_comment_count` | Comment count for the current page |
+| `fastcomments_comment_count_bulk` | Comment counts for many pages on one list/index page |
+| `fastcomments_live_chat` | Realtime streaming chat widget |
+| `fastcomments_collab_chat` | Collaborative inline commenting (text annotations) |
+| `fastcomments_image_chat` | Image annotation comments |
+| `fastcomments_recent_comments` | Recent comments across the site |
+| `fastcomments_recent_discussions` | Recently active discussion threads |
+| `fastcomments_reviews_summary` | Star-rating reviews summary |
+| `fastcomments_top_pages` | Most-discussed pages |
+| `fastcomments_user_activity_feed` | Per-user activity feed |
+
+### Examples
+
+```liquid
+{% raw %}{# Comment count. The widget renders its own label, e.g. "0 comments" #}
+{% fastcomments_comment_count %}
+
+{# Live chat #}
+{% fastcomments_live_chat %}
+
+{# Collab chat. Point it at a content element with a CSS selector #}
+<article id="post-body">
+  <p>Highlight me to leave a comment.</p>
+</article>
+{% fastcomments_collab_chat target="#post-body" %}
+
+{# Image chat. Point it at an image element with a CSS selector #}
+<img id="hero" src="/hero.jpg" alt="Hero image">
+{% fastcomments_image_chat target="#hero" %}
+
+{# Reviews summary #}
+{% fastcomments_reviews_summary %}
+
+{# User activity feed. Requires a user id #}
+{% fastcomments_user_activity_feed user_id="demo:demo-user" %}
+
+{# Bulk comment counts for a blog index #}
+{% for post in site.posts %}
+  <a href="{{ post.url }}">{{ post.title }}</a>
+  <span class="fast-comments-count" data-fast-comments-url-id="{{ post.url }}"></span>
+{% endfor %}
+{% fastcomments_comment_count_bulk %}{% endraw %}
+```
+
+## Configuration
+
+Config comes from three places. Later sources win:
+
+1. **Global defaults** in `_config.yml` under the `fastcomments:` key.
+2. **Page context**, derived automatically for page-scoped widgets (see below).
+3. **Tag attributes** written on the tag itself.
+
+So a `url_id` on the tag overrides the page-derived value, which overrides any global default.
+
+### Attribute syntax
+
+Attributes are `key=value` pairs in `snake_case`:
+
+```liquid
+{% raw %}{% fastcomments url_id="my-stable-id" readonly=true count=20 %}{% endraw %}
+```
+
+- **Quoted** values (`"..."` or `'...'`) are literal strings.
+- **Unquoted** `true`/`false` become booleans, and numbers become numbers.
+- **Unquoted** anything else is resolved as a Liquid variable from the page context, e.g.
+  `url_id=page.slug`. (Liquid does not expand `{% raw %}{{ ... }}{% endraw %}` inside a tag's
+  attributes, so use the bare `page.slug` form rather than `"{% raw %}{{ page.slug }}{% endraw %}"`.)
+
+Snake_case attribute and config keys are mapped automatically to the camelCase keys FastComments
+expects (`tenant_id` → `tenantId`, `url_id` → `urlId`, `page_title` → `pageTitle`,
+`has_dark_background` → `hasDarkBackground`, and so on). Any other option from the
+[widget configuration](https://docs.fastcomments.com/guide-customizations-and-configuration.html)
+passes straight through the same way.
+
+### Page-derived values
+
+For the page-scoped widgets (`fastcomments`, `fastcomments_comment_count`, `fastcomments_live_chat`,
+`fastcomments_collab_chat`, `fastcomments_image_chat`) these are filled in automatically from the
+current page unless you set them yourself:
+
+- `url_id` ← `page.url` (a stable identifier independent of the visiting domain)
+- `url` ← `site.url` + `page.url` (only when `url` is set in `_config.yml`)
+- `page_title` ← `page.title`
+
+Site-wide widgets (recent comments/discussions, top pages, reviews summary, user activity feed,
+bulk count) are not tied to a page and do not derive these.
+
+### EU data residency
+
+EU customers add `region: eu`, either globally:
+
+```yaml
+fastcomments:
+  tenant_id: your-tenant-id
+  region: eu
+```
+
+or per tag: `{% raw %}{% fastcomments region="eu" %}{% endraw %}`. Widgets then load from the EU CDN.
+
+## Links
+
+- [FastComments Documentation](https://docs.fastcomments.com)
+- [Customization & Configuration](https://docs.fastcomments.com/guide-customizations-and-configuration.html)
+- [Jekyll Documentation](https://jekyllrb.com/docs/)
+
+## License
+
+MIT
+
+## Maintenance Status
+
+These components are wrappers around our core VanillaJS components. We can automatically update those components (fix bugs, add features) without publishing this library, so while it may not be published for a while that does not mean FastComments is not under active development! Feel free to check [our blog](https://blog.fastcomments.com/) for updates. Breaking API changes or features will never be shipped to the underlying core library without a version bump in this library.

data/lib/fastcomments/jekyll/attribute_parser.rb

@@ -0,0 +1,48 @@
+module FastComments
+  module Jekyll
+    # Parses a Liquid tag's markup ("k=v k='s' k=page.x") into a snake-keyed Hash.
+    module AttributeParser
+      module_function
+
+      TOKEN_RE = /([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))/.freeze
+
+      def parse(markup, context)
+        result = {}
+        return result if markup.nil?
+
+        markup.scan(TOKEN_RE) do |key, double_quoted, single_quoted, bare|
+          if !double_quoted.nil?
+            result[key] = double_quoted
+          elsif !single_quoted.nil?
+            result[key] = single_quoted
+          else
+            value = coerce(bare, context)
+            result[key] = value unless value.nil?
+          end
+        end
+
+        result
+      end
+
+      # Unquoted values coerce to Integer/Float/Boolean/nil, else resolve as a
+      # Liquid context variable (e.g. page.slug). Unresolved variables become nil.
+      def coerce(token, context)
+        case token
+        when /\A-?\d+\z/ then Integer(token, 10)
+        when /\A-?\d*\.\d+\z/ then Float(token)
+        when "true" then true
+        when "false" then false
+        when "nil", "null" then nil
+        else
+          return nil if context.nil?
+
+          begin
+            context[token]
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fastcomments/jekyll/base_tag.rb

@@ -0,0 +1,52 @@
+require "liquid"
+
+module FastComments
+  module Jekyll
+    # Shared Liquid::Tag lifecycle: parse markup -> resolve config -> render widget.
+    # Concrete tags declare a `self.spec` and inherit one of the renderer bases below.
+    class BaseTag < ::Liquid::Tag
+      def render(context)
+        attrs = AttributeParser.parse(@markup, context)
+        config = ConfigResolver.resolve(context, attrs, derive_page_context: self.class.page_scoped?)
+        render_widget(config)
+      end
+
+      def self.page_scoped?
+        spec[:page_scoped] == true
+      end
+
+      def render_widget(_config)
+        raise NotImplementedError, "#{self.class} must implement #render_widget"
+      end
+    end
+
+    class ContainerTag < BaseTag
+      def render_widget(config)
+        ContainerWidget.render(self.class.spec, config)
+      end
+    end
+
+    class SelectorTag < BaseTag
+      def render_widget(config)
+        SelectorWidget.render(self.class.spec, config)
+      end
+    end
+
+    # The user activity feed is keyed by a user id rather than a page.
+    class UserActivityTag < ContainerTag
+      def render_widget(config)
+        unless config["userId"].is_a?(String) && !config["userId"].empty?
+          raise ::Liquid::SyntaxError, "fastcomments_user_activity_feed tag requires a \"user_id\" option."
+        end
+
+        super
+      end
+    end
+
+    class BulkCountTag < BaseTag
+      def render_widget(config)
+        BulkCountWidget.render(self.class.spec, config)
+      end
+    end
+  end
+end

data/lib/fastcomments/jekyll/bulk_count_widget.rb

@@ -0,0 +1,30 @@
+module FastComments
+  module Jekyll
+    # Renders the bulk comment-count loader: sets the global config object, then
+    # lazy-loads the bulk script once. The script scans the page for elements with
+    # class "fast-comments-count" and a data-fast-comments-url-id attribute.
+    module BulkCountWidget
+      module_function
+
+      def render(spec, config)
+        clean = Util.sanitize_config(config)
+        region = clean["region"]
+        script_src = "#{Util.get_cdn_base(region)}#{spec[:script_path]}"
+
+        "<script>" \
+          "(function(){" \
+          "window.#{spec[:global_name]}=#{Util.json_for_script(clean)};" \
+          "var scriptSrc=#{Util.json_for_script(script_src)};" \
+          "var marker=#{Util.json_for_script(spec[:script_marker_attr])};" \
+          "if(!document.querySelector('script['+marker+']')){" \
+          "var s=document.createElement('script');" \
+          "s.src=scriptSrc;" \
+          "s.setAttribute(marker,'');" \
+          "document.head.appendChild(s);" \
+          "}" \
+          "})();" \
+          "</script>"
+      end
+    end
+  end
+end

data/lib/fastcomments/jekyll/config_resolver.rb

@@ -0,0 +1,62 @@
+module FastComments
+  module Jekyll
+    # Merges widget config from three sources and camelizes the result.
+    # Precedence (later wins): global _config.yml defaults < page-derived < tag attributes.
+    module ConfigResolver
+      module_function
+
+      def resolve(context, attrs, derive_page_context: false)
+        merged = {}
+
+        global_config(context).each { |key, value| merged[key.to_s] = value }
+
+        if derive_page_context
+          derive(context).each { |key, value| merged[key] = value unless value.nil? }
+        end
+
+        attrs.each { |key, value| merged[key.to_s] = value }
+
+        KeyMapper.map_keys(Util.sanitize_config(merged))
+      end
+
+      def global_config(context)
+        site = site(context)
+        return {} unless site
+
+        config = site.config["fastcomments"]
+        config.is_a?(Hash) ? config : {}
+      end
+
+      def derive(context)
+        page = page(context)
+        # Real Jekyll exposes `page` as a Liquid::Drop (Jekyll::Drops::DocumentDrop),
+        # not a Hash; both answer page["url"]/page["title"], so guard on [] not Hash.
+        return {} unless page.respond_to?(:[])
+
+        derived = {}
+        derived["url_id"] = page["url"] if page["url"]
+
+        site = site(context)
+        site_url = site ? site.config["url"] : nil
+        derived["url"] = "#{site_url}#{page["url"]}" if site_url && !site_url.to_s.empty? && page["url"]
+
+        derived["page_title"] = page["title"] if page["title"]
+        derived
+      end
+
+      def site(context)
+        registers = context.registers
+        site = registers && registers[:site]
+        site if site.respond_to?(:config)
+      rescue StandardError
+        nil
+      end
+
+      def page(context)
+        context["page"]
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/fastcomments/jekyll/container_widget.rb

@@ -0,0 +1,54 @@
+module FastComments
+  module Jekyll
+    # Renders a container widget (a div/span placeholder + a self-contained loader
+    # script). Port of renderContainerWidget from fastcomments-11ty.
+    module ContainerWidget
+      module_function
+
+      def render(spec, config)
+        clean = Util.sanitize_config(config)
+        region = clean["region"]
+        container_id = Util.make_container_id(spec[:container_id_prefix])
+        script_src = "#{Util.get_cdn_base(region)}#{spec[:script_path]}"
+
+        global_name = spec[:global_name]
+        label = spec[:error_label] || global_name
+        slow_warn = "FastComments #{label} script did not load within 5s; continuing to retry every 1s."
+
+        init_body =
+          if spec[:use_callback]
+            failure = Util.json_for_script("FastComments #{label} Load Failure")
+            "if(window.#{global_name}){window.#{global_name}(el,config,function(error){" \
+              "if(error){console.error(#{failure},error);}});}else{schedule();}"
+          else
+            "if(window.#{global_name}){window.#{global_name}(el,config);}else{schedule();}"
+          end
+
+        tag = spec[:container_tag]
+
+        "<#{tag} id=\"#{Util.escape_attr(container_id)}\"></#{tag}>" \
+          "<script>" \
+          "(function(){" \
+          "var containerId=#{Util.json_for_script(container_id)};" \
+          "var config=#{Util.json_for_script(clean)};" \
+          "var scriptSrc=#{Util.json_for_script(script_src)};" \
+          "var marker=#{Util.json_for_script(spec[:script_marker_attr])};" \
+          "var startedAt=Date.now();" \
+          "var warned=false;" \
+          "function schedule(){var elapsed=Date.now()-startedAt;" \
+          "if(elapsed>=5000&&!warned){warned=true;console.warn(#{Util.json_for_script(slow_warn)});}" \
+          "setTimeout(init,elapsed<5000?50:1000);}" \
+          "function init(){var el=document.getElementById(containerId);#{init_body}}" \
+          "if(!document.querySelector('script['+marker+']')){" \
+          "var s=document.createElement('script');" \
+          "s.src=scriptSrc;" \
+          "s.setAttribute(marker,'');" \
+          "document.head.appendChild(s);" \
+          "}" \
+          "init();" \
+          "})();" \
+          "</script>"
+      end
+    end
+  end
+end

data/lib/fastcomments/jekyll/key_mapper.rb

@@ -0,0 +1,22 @@
+module FastComments
+  module Jekyll
+    # Maps snake_case tag/_config keys to the camelCase keys FastComments expects.
+    module KeyMapper
+      module_function
+
+      def to_camel(key)
+        str = key.to_s
+        return str unless str.include?("_")
+
+        parts = str.split("_")
+        head = parts.shift
+        head + parts.map { |part| part.empty? ? "" : part[0].upcase + part[1..] }.join
+      end
+
+      # Camelize top-level keys only; nested values (e.g. translations) pass through verbatim.
+      def map_keys(hash)
+        hash.each_with_object({}) { |(key, value), out| out[to_camel(key)] = value }
+      end
+    end
+  end
+end

data/lib/fastcomments/jekyll/selector_widget.rb

@@ -0,0 +1,49 @@
+module FastComments
+  module Jekyll
+    # Renders a selector widget that attaches to an existing element via a CSS
+    # selector (collab chat, image chat). Port of renderSelectorWidget.
+    module SelectorWidget
+      module_function
+
+      def render(spec, config)
+        clean = Util.sanitize_config(config)
+        target = clean["target"]
+
+        unless target.is_a?(String) && !target.empty?
+          raise Liquid::SyntaxError,
+                "#{spec[:shortcode_name]} tag requires a \"target\" option (CSS selector for the target element)."
+        end
+
+        clean = clean.reject { |key, _| key == "target" }
+        region = clean["region"]
+        script_src = "#{Util.get_cdn_base(region)}#{spec[:script_path]}"
+
+        global_name = spec[:global_name]
+        slow_warn = "FastComments #{spec[:shortcode_name]} script did not load within 5s; continuing to retry every 1s."
+
+        "<script>" \
+          "(function(){" \
+          "var target=#{Util.json_for_script(target)};" \
+          "var config=#{Util.json_for_script(clean)};" \
+          "var scriptSrc=#{Util.json_for_script(script_src)};" \
+          "var marker=#{Util.json_for_script(spec[:script_marker_attr])};" \
+          "var startedAt=Date.now();" \
+          "var warned=false;" \
+          "function schedule(){var elapsed=Date.now()-startedAt;" \
+          "if(elapsed>=5000&&!warned){warned=true;console.warn(#{Util.json_for_script(slow_warn)});}" \
+          "setTimeout(init,elapsed<5000?50:1000);}" \
+          "function init(){if(window.#{global_name}){var el=document.querySelector(target);" \
+          "if(el){window.#{global_name}(el,config);}}else{schedule();}}" \
+          "if(!document.querySelector('script['+marker+']')){" \
+          "var s=document.createElement('script');" \
+          "s.src=scriptSrc;" \
+          "s.setAttribute(marker,'');" \
+          "document.head.appendChild(s);" \
+          "}" \
+          "init();" \
+          "})();" \
+          "</script>"
+      end
+    end
+  end
+end

data/lib/fastcomments/jekyll/tags.rb

@@ -0,0 +1,131 @@
+require "liquid"
+
+module FastComments
+  module Jekyll
+    class FastCommentsTag < ContainerTag
+      def self.spec
+        {
+          container_tag: "div", container_id_prefix: "fc",
+          script_path: "/js/embed-v2.min.js", script_marker_attr: "data-fc-embed",
+          global_name: "FastCommentsUI", page_scoped: true
+        }
+      end
+    end
+
+    class CommentCountTag < ContainerTag
+      def self.spec
+        {
+          container_tag: "span", container_id_prefix: "fc-count",
+          script_path: "/js/widget-comment-count.min.js", script_marker_attr: "data-fc-count",
+          global_name: "FastCommentsCommentCount", page_scoped: true
+        }
+      end
+    end
+
+    class LiveChatTag < ContainerTag
+      def self.spec
+        {
+          container_tag: "div", container_id_prefix: "fc-live-chat",
+          script_path: "/js/embed-live-chat.min.js", script_marker_attr: "data-fc-live-chat",
+          global_name: "FastCommentsLiveChat", page_scoped: true
+        }
+      end
+    end
+
+    class CollabChatTag < SelectorTag
+      def self.spec
+        {
+          script_path: "/js/embed-collab-chat.min.js", script_marker_attr: "data-fc-collab-chat",
+          global_name: "FastCommentsCollabChat", shortcode_name: "fastcomments_collab_chat",
+          page_scoped: true
+        }
+      end
+    end
+
+    class ImageChatTag < SelectorTag
+      def self.spec
+        {
+          script_path: "/js/embed-image-chat.min.js", script_marker_attr: "data-fc-image-chat",
+          global_name: "FastCommentsImageChat", shortcode_name: "fastcomments_image_chat",
+          page_scoped: true
+        }
+      end
+    end
+
+    class RecentCommentsTag < ContainerTag
+      def self.spec
+        {
+          container_tag: "div", container_id_prefix: "fc-recent-comments",
+          script_path: "/js/widget-recent-comments-v2.min.js",
+          script_marker_attr: "data-fc-recent-comments-v2",
+          global_name: "FastCommentsRecentCommentsV2"
+        }
+      end
+    end
+
+    class RecentDiscussionsTag < ContainerTag
+      def self.spec
+        {
+          container_tag: "div", container_id_prefix: "fc-recent-discussions",
+          script_path: "/js/widget-recent-discussions-v2.min.js",
+          script_marker_attr: "data-fc-recent-discussions-v2",
+          global_name: "FastCommentsRecentDiscussionsV2"
+        }
+      end
+    end
+
+    class ReviewsSummaryTag < ContainerTag
+      def self.spec
+        {
+          container_tag: "div", container_id_prefix: "fc-rs",
+          script_path: "/js/embed-reviews-summary.min.js", script_marker_attr: "data-fc-reviews-summary",
+          global_name: "FastCommentsReviewsSummaryWidget",
+          use_callback: true, error_label: "Reviews Summary"
+        }
+      end
+    end
+
+    class TopPagesTag < ContainerTag
+      def self.spec
+        {
+          container_tag: "div", container_id_prefix: "fc-top-pages",
+          script_path: "/js/widget-top-pages-v2.min.js", script_marker_attr: "data-fc-top-pages-v2",
+          global_name: "FastCommentsTopPagesV2"
+        }
+      end
+    end
+
+    class UserActivityFeedTag < UserActivityTag
+      def self.spec
+        {
+          container_tag: "div", container_id_prefix: "fc-activity",
+          script_path: "/js/embed-user-activity.min.js", script_marker_attr: "data-fc-user-activity",
+          global_name: "FastCommentsUserActivity",
+          use_callback: true, error_label: "User Activity"
+        }
+      end
+    end
+
+    class CommentCountBulkTag < BulkCountTag
+      def self.spec
+        {
+          script_path: "/js/embed-widget-comment-count-bulk.min.js",
+          script_marker_attr: "data-fc-count-bulk",
+          global_name: "FastCommentsBulkCountConfig"
+        }
+      end
+    end
+  end
+end
+
+::Liquid::Template.register_tag("fastcomments", FastComments::Jekyll::FastCommentsTag)
+::Liquid::Template.register_tag("fastcomments_comment_count", FastComments::Jekyll::CommentCountTag)
+::Liquid::Template.register_tag("fastcomments_comment_count_bulk", FastComments::Jekyll::CommentCountBulkTag)
+::Liquid::Template.register_tag("fastcomments_live_chat", FastComments::Jekyll::LiveChatTag)
+::Liquid::Template.register_tag("fastcomments_collab_chat", FastComments::Jekyll::CollabChatTag)
+::Liquid::Template.register_tag("fastcomments_image_chat", FastComments::Jekyll::ImageChatTag)
+::Liquid::Template.register_tag("fastcomments_recent_comments", FastComments::Jekyll::RecentCommentsTag)
+::Liquid::Template.register_tag("fastcomments_recent_discussions", FastComments::Jekyll::RecentDiscussionsTag)
+::Liquid::Template.register_tag("fastcomments_reviews_summary", FastComments::Jekyll::ReviewsSummaryTag)
+::Liquid::Template.register_tag("fastcomments_top_pages", FastComments::Jekyll::TopPagesTag)
+::Liquid::Template.register_tag("fastcomments_user_activity_feed", FastComments::Jekyll::UserActivityFeedTag)

data/lib/fastcomments/jekyll/util.rb

@@ -0,0 +1,59 @@
+require "json"
+require "securerandom"
+
+module FastComments
+  module Jekyll
+    # Low-level helpers ported from the fastcomments-11ty util.ts so the emitted
+    # client JS is byte-equivalent.
+    module Util
+      module_function
+
+      ESCAPE_FOR_SCRIPT = {
+        "<" => "\\u003C",
+        ">" => "\\u003E",
+        "&" => "\\u0026",
+        "
" => "\\u2028",
+        "
" => "\\u2029"
+      }.freeze
+
+      # Escape the characters that can break out of an inline <script> body.
+      def escape_for_script(str)
+        str.to_s.gsub(/[<>&

]/) { |c| ESCAPE_FOR_SCRIPT[c] }
+      end
+
+      # Escape a value for use inside a double-quoted HTML attribute (& first).
+      def escape_attr(value)
+        value.to_s
+             .gsub("&", "&amp;")
+             .gsub('"', "&quot;")
+             .gsub("<", "&lt;")
+             .gsub(">", "&gt;")
+      end
+
+      # JSON-encode a value for safe embedding in an inline <script>.
+      def json_for_script(value)
+        escape_for_script(JSON.generate(value))
+      end
+
+      def get_cdn_base(region)
+        region.to_s == "eu" ? "https://cdn-eu.fastcomments.com" : "https://cdn.fastcomments.com"
+      end
+
+      # Drop nil values; keep scalars/arrays/hashes (mirrors the TS sanitizeConfig).
+      def sanitize_config(config)
+        return {} unless config.is_a?(Hash)
+
+        config.each_with_object({}) do |(key, value), out|
+          next if value.nil?
+
+          out[key] = value
+        end
+      end
+
+      # Container ids only need to be unique within a page.
+      def make_container_id(prefix)
+        "#{prefix}-#{SecureRandom.alphanumeric(7).downcase}"
+      end
+    end
+  end
+end

data/lib/fastcomments/version.rb

@@ -0,0 +1,5 @@
+module FastComments
+  module Jekyll
+    VERSION = "1.0.0".freeze
+  end
+end

data/lib/fastcomments-jekyll.rb

@@ -0,0 +1,10 @@
+require "fastcomments/version"
+require "fastcomments/jekyll/util"
+require "fastcomments/jekyll/key_mapper"
+require "fastcomments/jekyll/attribute_parser"
+require "fastcomments/jekyll/config_resolver"
+require "fastcomments/jekyll/container_widget"
+require "fastcomments/jekyll/selector_widget"
+require "fastcomments/jekyll/bulk_count_widget"
+require "fastcomments/jekyll/base_tag"
+require "fastcomments/jekyll/tags"

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: fastcomments-jekyll
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- FastComments
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Liquid tags for embedding FastComments widgets (comments, live chat,
+  collab/image chat, reviews summary, recent comments/discussions, top pages, and
+  user activity feed) into Jekyll sites.
+email:
+- support@fastcomments.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/fastcomments-jekyll.rb
+- lib/fastcomments/jekyll/attribute_parser.rb
+- lib/fastcomments/jekyll/base_tag.rb
+- lib/fastcomments/jekyll/bulk_count_widget.rb
+- lib/fastcomments/jekyll/config_resolver.rb
+- lib/fastcomments/jekyll/container_widget.rb
+- lib/fastcomments/jekyll/key_mapper.rb
+- lib/fastcomments/jekyll/selector_widget.rb
+- lib/fastcomments/jekyll/tags.rb
+- lib/fastcomments/jekyll/util.rb
+- lib/fastcomments/version.rb
+homepage: https://docs.fastcomments.com/guide-lib-jekyll.html
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/FastComments/fastcomments-jekyll
+  homepage_uri: https://docs.fastcomments.com/guide-lib-jekyll.html
+  changelog_uri: https://github.com/FastComments/fastcomments-jekyll/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Jekyll plugin for FastComments, a live commenting system.
+test_files: []