daisyui 2.0.2 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 784f97cabf197c081daba3827d5d7cc67a4bfe68b1be95fd038cecaae9da127c
-  data.tar.gz: e1cc4be0135efdf03ed592a8c0d73e2b12d81c4cee47dacd7008ac34aa8bdbbe
+  metadata.gz: 75952f05719457c52d7085643cfeebc3b0dd2f72e4ddfc768d1ba7468431c161
+  data.tar.gz: 9029feca27ce0d586ad608c23170afcb7bafc1f17998af22793a2b39ce8c1ce3
 SHA512:
-  metadata.gz: d6331604dbf5bdd7b419dfcbb5494cf7569a1709b3d9b17dd7fe08d56d1e3fed14b16c4d1925534a4efdce23e4e85347901b5687580f466e02aa9081f5ca646f
-  data.tar.gz: 002c0ad206f54764209eb6ae752c852a91369adb97c84910fe39daf19ca993842b773f6f60ad27da12cc88d25e6d7df8cc6415018408a541c99533d214432193
+  metadata.gz: 206f1d5f22c5ac7d41df14f1984fedfa70056b5128aa97ff3affb1bb5607cb6cfe1e7c92899c469b70e763976f5fa1c300fa9dcd18f3c10fd9dd10e41734af98
+  data.tar.gz: b65a346205a5fe198a858b3de5e191f20ee909fbe86c565e3d8aee87680ac9a1c2bf5ee681d6fdf698700063e271534ad766ac1afecfdf63ceb43557d03922b5

data/CHANGELOG.md

@@ -1,5 +1,78 @@
 ## [Unreleased]
 
+### Tailwind sources for only the components an app uses
+
+`bundle exec daisyui-tailwind app -o app/assets/stylesheets/generated/daisyui.css`
+writes the Tailwind sources for the DaisyUI components an app's Ruby and
+templates reference, plus the components those render (Dropdown renders
+Button and Menu): one `@source inline("…")` per component, for the Tailwind
+entry to `@import`. See the README's "Tailwind sources".
+
+- Smaller: pointing `@source` at the whole gem hands Tailwind every class of
+  every component and ClassMerge's catalogue of Tailwind utilities. On an app
+  using 33 of the 77 components the gem's share of the CSS went from 210 KB to
+  126 KB (32 → 19 KB gzipped).
+- More complete: Tailwind v4 drops Ruby comments when it scans a `.rb` file
+  and cannot see a Symbol component class (`self.component_class = :navbar`),
+  so a whole-gem scan generated no `.navbar`, `.card` or `.drawer` rule, nor
+  the rules daisyUI nests under them (`indicator-item`, `stack-top`), unless
+  the app spelled the class out itself. The generated sources carry them.
+- No path in the output, so it is the same on every machine; `--output`
+  rewrites the file only when its content changes, so a CSS watcher does not
+  loop on it.
+- `--format json` gives a build script the components, their classes and
+  their absolute files. From Ruby, `DaisyUI::Tailwind.sources(scan: ["app"])`
+  returns the CSS (`format: :json` for the JSON), and
+  `DaisyUI::Tailwind.used_components(scan: ["app"])` the component names.
+- `--responsive sm,md,lg` adds breakpoint variants of each component class and
+  modifier, for apps that render `responsive:` modifiers (off by default: it
+  multiplies the CSS). `--prefix` matches `DaisyUI.configuration.prefix`,
+  which `DaisyUI::Tailwind.sources` uses by default.
+- The manifest behind it, `data/daisyui/tailwind_manifest.json`, lists every
+  component's class, daisyUI name, file, the components it renders and its
+  classes. It is built from the components (`rake tailwind:manifest`) and a
+  spec fails when it is stale. It lives in the gem's data dir, not `lib/`:
+  an app that keeps scanning the gem's `lib/` builds the same CSS as before.
+
+## [2.1.0] - 2026-10-15
+
+### DaisyUI finalizes itself at boot: class merging in any Ractor (#58)
+
+At boot DaisyUI now freezes its configuration and every component's
+registries, so a non-main Ractor can read them. `DaisyUI::ClassMerge.merge`
+then works in any Ractor; each Ractor builds its own merger and LRU.
+
+- Automatic: `DaisyUI.configure` finalizes at its end, and the Rails engine
+  finalizes again in `after_initialize`, with no app code. A Rails-less app
+  that never calls `configure` calls `DaisyUI.finalize!` at the end of boot.
+- **The configuration is frozen after `DaisyUI.configure` (and, in a Rails
+  app, after boot).** Writing to `DaisyUI.configuration` directly now raises
+  `FrozenError`, e.g. `DaisyUI.configuration.unknown_modifiers = :ignore` in a
+  spec: use `DaisyUI.configure { |config| config.unknown_modifiers = :ignore }`.
+  `DaisyUI.configure` can be called again at any time: it yields a writable
+  copy and publishes it once that is finalized, so no reader ever meets a
+  half-changed configuration, and a block that raises changes nothing. A
+  Ractor that already built its merger rebuilds it from the new
+  configuration.
+- Finalizing never raises. A configured value that cannot be made shareable
+  is kept as it is, unfrozen, and the configuration is then readable on the
+  main Ractor only: a callable `unknown_modifiers` or a raw `class_merge`
+  validator that closes over app state (such as
+  `->(error) { Appsignal.report_error(error) }` in an initializer), or an
+  object that holds a logger.
+- Component registries (`register_modifiers`, `register_flags`,
+  `self.component_class =`) are frozen as they are written, so a component
+  that loads after boot (lazy loading in development) is readable from any
+  Ractor too. Writers now replace them instead of mutating them, and
+  mutating one in place raises `FrozenError`.
+- Thread safety: the Tailwind class groups behind `ClassMerge` were built
+  with an unguarded `||=` (8 threads built them 8 times); they are now built
+  once per Ractor.
+- Rendering components inside a Ractor waits on Phlex
+  ([yippee-fun/phlex#1055](https://github.com/yippee-fun/phlex/pull/1055)).
+
+## [2.0.2] - 2026-10-11
+
 ### Unknown modifiers are reported (#54)
 
 A positional or responsive modifier a component does not know used to render
@@ -32,6 +105,30 @@ end
   (`DaisyUI::Chat#bubble has no modifier :primray`).
 - Keyword booleans are not validated: unknown keywords stay HTML attributes.
 
+### Changed
+
+- The gem ships minified Stimulus controllers with linked sourcemaps, and the
+  importmap pins them without preloading, so with the lazy registration the
+  README shows (`lazyLoadControllersFrom`) a page that never uses one never
+  fetches it. `daisy_dropdown_controller` 6.1 KB → 2.8 KB (2.4 → 1.3 KB gzipped),
+  `daisy_tooltip_controller` 8.8 KB → 5.2 KB (2.4 → 1.8 KB gzipped). The
+  `daisy_ui/controllers/*` specifiers and the bundler import paths are unchanged.
+
+### Fixed
+
+- Modifiers added with `config.modifiers.add(component: X)` now apply to
+  subclasses of `X` too; the closest class wins.
+
+## [2.0.1] - 2026-10-09
+
+### Fixed
+
+- Button renders the `disabled` attribute on `button`/`input` elements when given
+  `:disabled` or `disabled: true`, so a disabled submit button no longer submits
+  its form from the keyboard (#52).
+
+## [2.0.0] - 2026-09-30
+
 ### Upgrading to 2.0
 
 Components now merge their classes: when two classes conflict, the later one
@@ -73,6 +170,35 @@ wins. `Button(:sm, class: "btn-lg")` renders `btn btn-lg` (1.x rendered
   app components subclassing `DaisyUI::Base` can do the same.
   `config.modifiers.add` takes `group:` to join one.
 
+### Changed
+
+- Maintainers cut releases with `bin/release` (`list`, `--dry-run`, `patch`/`minor`/`major`/`X.Y.Z`), which checks the lockfiles for gems that do not accept the new version yet and then drives `rake release`.
+
+## [1.3.1] - 2026-08-31
+
+### Fixed
+
+- Popover tooltips no longer clip arrows that extend beyond the tooltip card.
+
+## [1.3.0] - 2026-08-30
+
+### Added
+
+- `Tooltip` `:popover` modifier for collision-aware tooltips. It renders real
+  tooltip content in the browser top layer, opens on hover or focus, flips and
+  shifts within the visual viewport, follows scroll/resize while open, and
+  exposes `role="tooltip"`/`aria-describedby` semantics. The bundled
+  `daisy-tooltip` Stimulus controller is auto-pinned for importmap-rails apps
+  and supports a custom controller identifier via `stimulus:`.
+
+## [1.2.1] - 2026-07-03
+
+- No changes to the gem; this release shipped documentation-site and deploy changes only.
+
+## [1.2.0] - 2026-06-26
+
+### Added
+
 - Aura component (DaisyUI 5.6) with style variants (dual, rainbow, holo, gold, silver, glow) and sizes
 - Megamenu component (DaisyUI 5.6) with wide, full, vertical modifiers, sizes, and active_indicator sub-component
 - OTP component (DaisyUI 5.6) for one-time password inputs with configurable digit count, joined modifier, sizes, and color variants
@@ -90,34 +216,27 @@ wins. `Button(:sm, class: "btn-lg")` renders `btn btn-lg` (1.x rendered
   positioning fallback (Safari < 26, Firefox < 147) and optional roving
   keyboard navigation. The default `:popover` dropdown remains zero-JS, and the
   gem stays a plain Phlex library when Rails is absent.
-- `Tooltip` `:popover` modifier for collision-aware tooltips. It renders real
-  tooltip content in the browser top layer, opens on hover or focus, flips and
-  shifts within the visual viewport, follows scroll/resize while open, and
-  exposes `role="tooltip"`/`aria-describedby` semantics. The bundled
-  `daisy-tooltip` Stimulus controller is auto-pinned for importmap-rails apps
-  and supports a custom controller identifier via `stimulus:`.
 
 ### Changed
 
-- The gem ships minified Stimulus controllers with linked sourcemaps, and the
-  importmap pins them without preloading, so with the lazy registration the
-  README shows (`lazyLoadControllersFrom`) a page that never uses one never
-  fetches it. `daisy_dropdown_controller` 6.1 KB → 2.8 KB (2.4 → 1.3 KB gzipped),
-  `daisy_tooltip_controller` 8.8 KB → 5.2 KB (2.4 → 1.8 KB gzipped). The
-  `daisy_ui/controllers/*` specifiers and the bundler import paths are unchanged.
-- Maintainers cut releases with `bin/release` (`list`, `--dry-run`, `patch`/`minor`/`major`/`X.Y.Z`), which checks the lockfiles for gems that do not accept the new version yet and then drives `rake release`.
-
 - Range component: added range-vertical modifier for vertical orientation (DaisyUI 5.6)
 - Tooltip component: added alignment modifiers (tooltip-start, tooltip-center, tooltip-end) and tooltip-content sub-component (DaisyUI 5.6)
 
-### Fixed
+## [1.1.1] - 2026-04-05
 
-- Modifiers added with `config.modifiers.add(component: X)` now apply to
-  subclasses of `X` too; the closest class wins.
-- Popover tooltips no longer clip arrows that extend beyond the tooltip card.
-- Button renders the `disabled` attribute on `button`/`input` elements when given
-  `:disabled` or `disabled: true`, so a disabled submit button no longer submits
-  its form from the keyboard (#52).
+### Changed
+
+- The gem packages only `exe/`, `lib/`, `CHANGELOG.md`, `LICENSE.txt` and
+  `README.md`, listed with `git ls-files` (#14).
+
+## [1.1.0] - 2026-04-05
+
+### Changed
+
+- Components aligned with DaisyUI 5 (#13): new `Hover3d` and `TextRotate`
+  components; `Link` sets the `link` class; `MenuItem` uses
+  `menu-disabled`/`menu-active`/`menu-focus`; Button's `no_animation` and
+  `glass`, Mask's `parallelogram` shapes and Menu's color modifiers are removed.
 
 ## [0.1.0] - 2024-08-02
 

data/README.md

@@ -92,33 +92,130 @@ Consider not including DaisyUI in ApplicationComponent if:
 
 In this scenario, including both DaisyUI and your own component library in `ApplicationComponent` will lead to naming conflicts.
 
-3. Update your `tailwind.config.js` file to include DaisyUI component styles:
+3. Tell Tailwind which classes the gem renders: see [Tailwind sources](#tailwind-sources).
 
-```js
-const execSync = require("child_process").execSync;
-const outputDaisyUI = execSync("bundle show daisyui", { encoding: "utf-8" });
-const daisyUIPath = outputDaisyUI.trim() + "/**/*.rb";
-module.exports = {
-  content: [
-    // ... other paths
-    daisyUIPath,
-  ],
-};
+## Tailwind sources
+
+The gem renders daisyUI class names from Ruby, so Tailwind has to be told
+which ones to generate CSS for. Give it the classes of just the components your
+app uses: `daisyui-tailwind` finds the components your Ruby and templates
+reference, adds the components those render (Dropdown renders Button and Menu,
+Menu renders MenuItem), and writes one `@source inline(...)` per component for
+your Tailwind entry to import.
+
+```sh
+bundle exec daisyui-tailwind app -o app/assets/stylesheets/generated/daisyui.css
 ```
 
-4. Update your tailwind.config.js file to detect TailwindCSS classes in Ruby files.
+```css
+/* app/assets/stylesheets/application.tailwind.css */
+@import "tailwindcss";
+@plugin "daisyui";
+
+@source "../../views";                  /* your own classes, as before */
+@import "./generated/daisyui.css";      /* the DaisyUI components you use */
+```
+
+Run it before Tailwind in your CSS build (it rewrites the file only when its
+content changes, so a watcher does not loop on it). The output names no path,
+so it is the same on every machine: commit it, or generate it on every build.
+
+**From a Node build script**, spawn the command, or read JSON:
 
 ```js
-module.exports = {
-  content: [
-    // ... other paths
-    //
-    // Note the "rb" extension at the end
-    "./app/views/**/*.{erb,haml,html,slim,rb}",
-  ],
-};
+// build-css.js (bun)
+Bun.spawnSync(["bundle", "exec", "daisyui-tailwind", "app", "-o", "app/assets/stylesheets/generated/daisyui.css"])
+
+// or per bundle, as JSON: { components, classes, files, shared, daisyui }
+const out = Bun.spawnSync(["bundle", "exec", "daisyui-tailwind", "app/views/admin", "--format", "json"])
+const { components, classes, files } = JSON.parse(out.stdout.toString())
 ```
 
+**From Ruby** (a rake task, a build script):
+
+```ruby
+DaisyUI::Tailwind.used_components(scan: ["app"])         # => ["Button", "Menu", "MenuItem", ...]
+DaisyUI::Tailwind.sources(scan: ["app"])                  # => the CSS partial
+DaisyUI::Tailwind.sources(components: %w[Navbar], format: :json)
+```
+
+| Option | |
+|---|---|
+| `PATH...` | Directories (every `.rb`, `.erb`, `.haml`, `.slim` below) or files to scan. A path that does not exist is an error. |
+| `-c, --component Button,Navbar` | Components to include whether or not a path references them (repeatable). |
+| `-f, --format css\|json` | `css` (default) is the partial to import; `json` is for build scripts. |
+| `-o, --output FILE` | Write to FILE instead of stdout, only when its content changes. |
+| `--responsive sm,md,lg` | Add those breakpoint variants of each component class and modifier, for apps that render `responsive:` modifiers. Off by default: they multiply each component's CSS (sm,md,lg made the sample below 3.7 times larger). |
+| `--prefix d-` | Prefix the classes the way an app that sets `DaisyUI.configuration.prefix` renders them. `DaisyUI::Tailwind.sources` uses the configured prefix by default. |
+
+What counts as a use: a kit call with or without parentheses (`Button(:primary)`,
+`Badge :primary do`, `Button variant do`, `Hero do`), an instance (`Card.new`)
+or the constant (`DaisyUI::Navbar`, `class AppNavbar < DaisyUI::Navbar`).
+Comments do not count (`#` lines in Ruby, `<%# %>` in ERB, `-#` in HAML, `/` in
+Slim), nor does a name starting a sentence in a string ("Join thousands of…").
+Matching is textual and errs on the side of including a component: a false hit
+costs a little CSS, a miss would leave a component unstyled. A gem that renders DaisyUI components for you (phlex-forms wraps
+Input, Select, Range...) is scanned like your app:
+`daisyui-tailwind app "$(bundle info phlex-forms --path)/lib"`; the classes it
+writes in its own Ruby still need its own `@source`. Classes your code builds
+by interpolation (`"badge-#{color}"`) are invisible to Tailwind either way:
+spell them out.
+
+**The size win.** Measured on [cosmos](https://github.com/zoolutions/cosmos)
+(33 of the gem's 77 components), the CSS the gem's classes add to a bundle
+(Tailwind 4.3.2, daisyUI 5.6.13, minified):
+
+| Sources | CSS | gzip |
+|---|---|---|
+| `@source` the gem's whole `lib/` | 210.1 KB | 31.9 KB |
+| `daisyui-tailwind` | 125.7 KB | 19.1 KB |
+| `daisyui-tailwind --responsive sm,md,lg` | 466.5 KB | 64.3 KB |
+
+It is also more complete. Tailwind v4 drops Ruby comments when it scans a `.rb`
+file and cannot see a Symbol component class (`self.component_class = :navbar`),
+so the whole-gem scan generated no `.navbar`, `.card`, `.drawer`... rule (the app
+only got them by spelling the class itself) and none of the sub-rules daisyUI
+nests under them (`indicator-item`, `stack-top`). The manifest carries both.
+
+**Scanning the whole gem still works** as it did:
+
+```css
+/* bundle info daisyui --path, resolved by your build script */
+@source "/path/to/gems/daisyui-x.y.z/lib";
+```
+
+### The manifest
+
+The command reads `data/daisyui/tailwind_manifest.json` in the gem, built from
+the components themselves and checked in (`bundle exec rake tailwind:manifest`
+in this repo). It sits outside `lib/`, so an `@source` on the gem's `lib/` or
+its `**/*.rb` never sees it. A build script in another
+language can read it directly from `$(bundle info daisyui --path)`:
+
+```json
+{
+  "schema": 1,
+  "shared": { "files": ["lib/daisy_ui/base.rb"], "classes": ["bg-primary", "skeleton", "..."] },
+  "components": {
+    "Dropdown": {
+      "class": "DaisyUI::Dropdown",
+      "name": "dropdown",
+      "files": ["lib/daisy_ui/dropdown.rb"],
+      "depends_on": ["Button", "Menu"],
+      "modifiers": ["dropdown-end", "dropdown-top", "..."],
+      "classes": ["dropdown", "dropdown-content", "dropdown-end", "..."]
+    }
+  }
+}
+```
+
+- `name`: the daisyUI component class (`null` where it depends on the modifiers, as for Label).
+- `files`: relative to the gem root, for a literal `@source` instead of `inline()`.
+- `depends_on`: the components it renders; resolve them transitively.
+- `modifiers`: the classes `responsive:` can prefix (with `name`).
+- `classes`: everything it can render: `name`, the modifiers and the class words in its Ruby. Words that are not classes cost nothing.
+- `shared`: base.rb's classes, which every component can render (`:skeleton`, the colour modifiers). Include them with any component.
+
 ## Class merging
 
 Components merge their classes so the last conflicting class wins, for Tailwind
@@ -209,6 +306,45 @@ end
 Keyword arguments are not validated: `Toggle(primray: true)` renders a
 `primray` attribute, because unknown keywords are HTML attributes.
 
+## Threads, fibers and Ractors
+
+Components and `DaisyUI::ClassMerge` are safe to share between threads (Puma)
+and fibers (Falcon). For Ractors, DaisyUI finalizes itself at boot: it freezes
+the configuration and every component's registries, so
+`DaisyUI::ClassMerge.merge` runs in any Ractor (as long as the configuration
+is shareable, see below), each Ractor with a merger of its own.
+`DaisyUI.configure` finalizes at its end and the Rails engine
+finalizes again once the app has booted, so there is nothing to call. A
+Rails-less app that never calls `configure` calls `DaisyUI.finalize!` at the
+end of boot.
+
+After that the configuration is frozen: writing to `DaisyUI.configuration`
+directly raises `FrozenError`. `DaisyUI.configure` keeps working at any time:
+it yields a writable copy and publishes it once that is finalized, and a
+Ractor that already built its merger rebuilds it from the new configuration.
+A test that changes a setting goes through it too:
+
+```ruby
+around do |example|
+  DaisyUI.configure { |config| config.unknown_modifiers = :ignore }
+  example.run
+ensure
+  DaisyUI.configure { |config| config.unknown_modifiers = :raise }
+end
+```
+
+Finalizing never raises. A configured value that cannot be made shareable is
+kept as it is, and the configuration is then readable on the main Ractor only:
+a callable `unknown_modifiers` or a raw `class_merge` validator that closes
+over app state (`->(error) { Appsignal.report_error(error) }` in an
+initializer), or an object that holds a logger. A lambda is shareable when it
+captures no local variables and is defined inside a module, or made with
+`Ractor.shareable_lambda` on Ruby 4.0. A component that loads after boot (lazy
+loading in development) freezes its registries as it writes them, so any
+Ractor can read it; a Ractor that already built its merger picks up its groups
+after the next `configure`. Rendering components inside a Ractor waits on Phlex
+([yippee-fun/phlex#1055](https://github.com/yippee-fun/phlex/pull/1055)).
+
 # Compatibility Notes
 
 ## @tailwindcss/forms plugin