npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

@stimulus_reflex/futurism

v1.4.2

Published

Lazy-load Rails partials via CableReady

Downloads

478

Readme

Futurism

Twitter follow

All Contributors

Lazy-load Rails partials via CableReady

:rotating_light: BREAKING CHANGE: With v1.0, futurism has been transferred to the stimulusreflex organization. Please update your npm package to @stimulus_reflex/futurism accordingly :rotating_light:

Table of Contents

Facts

  • only one dependency: CableReady
  • bundle size (without CableReady) is around ~2.46kB

Browser Support

  • Chrome v67+ (v54+ via Polyfill)
  • Firefox v63+
  • Edge v79+
  • Safari v10.1+ via Polyfill
  • iOS Safari & Chrome v10.3+ via Polyfill

Caniuse

Usage

with a helper in your template

<%= futurize @posts, extends: :div do %>
  <!-- placeholder -->
<% end %>

custom <futurism-element>s (in the form of a <div> or a <tr is="futurism-table-row"> are rendered. Those custom elements have an IntersectionObserver attached that will send a signed global id to an ActionCable channel (FuturismChannel) which will then replace the placeholders with the actual resource partial.

With that method, you could lazy load every class that has to_partial_path defined (ActiveModel has by default).

You can pass the placeholder as a block:

<%= futurize @posts, extends: :tr do %>
  <td class="placeholder"></td>
<% end %>

aa601dec1930151f71dbf0d6b02b61c9

You can also omit the placeholder, which falls back to eager loading.

API

Currently there are two ways to call futurize, designed to wrap render's behavior:

Resource

You can pass a single ActiveRecord or an ActiveRecord::Relation to futurize, just as you would call render:

<%= futurize @posts, extends: :tr do %>
  <td class="placeholder"></td>
<% end %>

Partial Path

Remember that you can override the partial path in you models, like so:

class Post < ApplicationRecord
  def to_partial_path
    "home/post"
  end
end

That way you get maximal flexibility when just specifying a single resource.

Explicit Partial

Call futurize with a partial keyword:

<%= futurize partial: "items/card", locals: {card: @card}, extends: :div do %>
  <div class="spinner"></div>
<% end %>

You can also use the shorthand syntax:

<%= futurize "items/card", card: @card, extends: :div do %>
  <div class="spinner"></div>
<% end %>

Collections

Collection rendering is also possible:

<%= futurize partial: "items/card", collection: @cards, extends: :div do %>
  <div class="spinner"></div>
<% end %>

Specifying Controller to Render

You can also pass in the controller that will be used to render the partial.

<%= futurize partial: "items/card", collection: @cards, controller: MyController, extends: :div do %>
  <div class="spinner"></div>
<% end %>

By default (i.e. not passing in a value), futurize will use ApplicationController, but you may override by setting the Futurism default controller in an initializer, for example config/initializers/futurism.rb.

Futurism.default_controller = "MyController" # to avoid the controller from trying to autoload at boot, provide as a string

HTML Options

You can pass a hash of attribute/value pairs which will be mixed into the HTML markup for the placeholder element. This is important for layouts that require elements to have dimensionality. For example, many scripts calculate size based on element height and width. This option ensures that your elements have integrity, even if they are gone before you see them.

<%= futurize @posts, extends: :tr, html_options: {style: "width: 50px; height: 50px;"} do %>
  <td class="placeholder"></td>
<% end %>

This will output the following:

<tr style="width: 50px; height: 50px;">
  <td class="placeholder"></td>
</tr>

Eager Loading

It may sound surprising to support eager loading in a lazy loading library :joy:, but there's a quite simple use case:

Suppose you have some hidden interactive portion of your page, like a tab or dropdown. You don't want its content to block the initial page load, but once that is done, you occasionally don't want to wait for the element to become visible and trigger the IntersectionObserver, you want to lazy load its contents right after it's added to the DOM.

Futurism makes that dead simple:

<%= futurize 'some_tab', eager: true, extends: :tr do %>
  <div class="placeholder"</td>
<% end %>

Bypassing

In some rare cases, e.g. when combined with CableReady's async updates_for mechanism, you'll want to bypass futurism entirely and fall back to native rendering. You can do this by passing an unless option:

<%= futurize 'some_tab', unless: bypass_futurism?, extends: :tr do %>
  <div class="placeholder"</td>
<% end %>

Internally, this works the same as bypassing futurism in tests

Broadcast Partials Individually

Futurism's default behavior is to broadcast partials as they are generated in batches:

On the client side, IntersectionObserver events are triggered in a debounced fashion, so several renders are performed on the server for each of those events. By default, futurism will group those to a single broadcast call (to save server CPU time).

For collections, however, you can opt into individual broadcasts by specifying broadcast_each: true in your helper usage:

<%= futurize @posts, broadcast_each: true, extends: :tr do %>
  <div class="placeholder"</td>
<% end %>

Contextual Placeholder Arguments

For individual models or arbitrary collections, you can pass record and index to the placeholder block as arguments:

<%= futurize @post, extends: :div do |post| %>
  <div><%= post.title %></div>
<% end %>
<%= futurize @posts, extends: :tr do |post, index| %>
  <td><%= index + 1 %></td><td><%= post.title %></td>
<% end %>
<%= futurize partial: "users/user", collection: users, extends: "tr" do |user, index| %>
  <td><%= index + 1 %></td><td><%= user.name %></td>
<% end >

Events

Once your futurize element has been rendered, the futurism:appeared custom event will be called.

Instrumentation

Futurism includes support for instrumenting rendering events.

To enable ActiveSupport notifications, use the instrumentation option:

Futurism.instrumentation = true

Then subscribe to the render.futurism event:

ActiveSupport::Notifications.subscribe("render.futurism") do |*args|
  event = ActiveSupport::Notifications::Event.new(*args)
  event.name                 # => "render.futurism"
  event.payload[:channel]    # => "Futurism::Channel" # ActionCable channel to broadcast
  event.payload[:controller] # => "posts"             # The controller that invokes `futurize` call
  event.payload[:action]     # => "show"              # The action that invokes `futurize` call
  event.payload[:partial]    # => "posts/card"        # The partial that was rendered
end

This is useful for performance monitoring, specifically for tracking the source of futurize calls.

Installation

Add this line to your application's Gemfile:

gem 'futurism'

And then execute:

$ bundle

To copy over the javascript files to your application, run

$ bin/rails futurism:install

! Note that the installer will run yarn add @stimulus_reflex/futurism for you !

Manual Installation

After bundle, install the Javascript library:

There are a few ways to install the Futurism JavaScript client, depending on your application setup.

ESBuild / Webpacker

yarn add @stimulus_reflex/futurism

Import maps:

# config/importmap.rb
# ...
pin '@stimulus_reflex/futurism', to: 'futurism.min.js', preload: true

Rails Asset pipeline (Sprockets):

<!-- app/views/layouts/application.html.erb -->
<%= javascript_include_tag "futurism.umd.min.js", "data-turbo-track": "reload" %>

In your app/javascript/channels/index.js, add the following

import * as Futurism from '@stimulus_reflex/futurism'

import consumer from './consumer'

Futurism.initializeElements()
Futurism.createSubscription(consumer)

Authentication

For authentication, you can rely on ActionCable identifiers, for example, if you use Devise:

module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = env["warden"].user || reject_unauthorized_connection
    end
  end
end

The Stimulus Reflex Docs have an excellent section about all sorts of authentication.

Testing

In Rails system tests there is a chance that flaky errors will occur due to Capybara not waiting for the placeholder elements to be replaced. To overcome this, add the flag

Futurism.skip_in_test = true

to an initializer, for example config/initializers/futurism.rb.

Gotchas

ActiveStorage URLs aren't correct in development

Out of the box, Rails will prefix generated urls with http://example.org rather than http://localhost, much like ActionMailer. To amend this, add

  # config/environments/development.rb
  config.action_controller.default_url_options = {host: "localhost", port: 3000}

  # config/environments/production.rb
  config.action_controller.default_url_options = {host: "mysite.com"}

to your environments.

Choosing the parent for Futurism::Channel

By default Futurism::CHannel will inherit from ApplicationCable::Channel, you can change this by setting

Futurism.configure do |config|
  config.parent_channel = "CustomFuturismChannel"
end

in config/initializers.

Contributing

Get local environment setup

Below are a set of instructions that may help you get a local development environment working

# Get the gem/npm package source locally
git clone futurism
cd futurism/javascript
yarn install # install all of the npm package's dependencies
yarn link # set the local machine's futurism npm package's lookup to this local path

# Setup a sample project, use the information below directly or use your own project
git clone https://github.com/leastbad/stimulus_reflex_harness.git
cd stimulus_reflex_harness
git checkout futurism
# Edit Gemfile to point point to local gem (e.g. `gem "futurism", path: "../futurism"`)
# yarn link @stimulus_reflex/futurism


# Do your work, Submit PR, Profit!


# To stop using your local version of futurism
# change your Gemfile back to the published (e.g. `gem "futurism"`)
cd path/to/futurism/javascript
# Stop using the local npm package
yarn unlink

# Instruct your project to reinstall the published version of the npm package
cd path/to/project
yarn install --force

📦 Releasing

  1. Make sure that you run yarn and bundle to pick up the latest.
  2. Bump version number at lib/futurism/version.rb. Pre-release versions use .preN
  3. Run rake build and yarn build
  4. Commit and push changes to github git commit -m "Bump version to x.x.x"
  5. Run rake release
  6. Run yarn publish --no-git-tag-version
  7. Yarn will prompt you for the new version. Pre-release versions use -preN
  8. Commit and push changes to GitHub
  9. Create a new release on GitHub (here) and generate the changelog for the stable release for it

License

The gem is available as open source under the terms of the MIT License.

Contributors ✨

Thanks goes to these wonderful people (emoji key):

This project follows the all-contributors specification. Contributions of any kind welcome!