@teacss/rsbuild 0.9.3 → 0.10.2

package/README.md

@@ -1,65 +1,42 @@
 # @teacss/rsbuild
 
-Native Rsbuild integration for TeaCSS.
+The Rsbuild plugin for TeaCSS. An Rspack loader calls the Rust engine (`@teacss/engine`) in process and replaces the CSS entry's `@teacss;` with the generated CSS. It needs Node.js 26 or later and Rsbuild 1 or later.
+
+## Install
+
+```sh
+npm install --save-dev @teacss/rsbuild @rsbuild/core
+```
+
+## Use
 
 ```ts
+// rsbuild.config.ts
 import { defineConfig } from "@rsbuild/core";
 import { pluginTeacss } from "@teacss/rsbuild";
 
-export default defineConfig({
-  plugins: [pluginTeacss()],
-});
+export default defineConfig({ plugins: [pluginTeacss()] });
 ```
 
+Configuration lives in a CSS entry. Create `index.css` at the project root:
+
 ```css
-@presets "standard";
-@source "./src/**/*.{ts,tsx}";
+@presets "standard,icons,official";
+@source "./src/**/*.{js,jsx,ts,tsx,html}";
 @teacss;
 ```
 
-The plugin generates utilities, transforms TeaCSS directives, tracks positive
-`@source` roots, and can optimize output with Lightning CSS. Stable source
-roots let new matching files trigger rebuilds; negative patterns are not watch
-roots. Explicit sources may include directories skipped by default discovery.
-The resolved source graph includes directives from unconditional local CSS
-imports, with paths relative to the declaring file. Entries without `@source`
-use default discovery, excluding dependencies and build output. The `contents`
-option replaces content scanning even when the entry declares its own preset;
-an empty array scans no content.
-
-An entry may keep all its configuration in imported CSS. Its utilities and
-`@apply` share that resolved configuration. Ordinary CSS imports preserve
-programmatic configuration, and imported safelists augment it.
-
-A custom entry `test` is combined with the directive transform matcher, so
-entries such as `.pcss` still reach TeaCSS.
-
-Tooling that compiles an entry outside a build, such as a Storybook setup or a
-test, uses `generateEntryCss` with `makeReadSources`:
+Import the entry from a script, not through a CSS `@import`:
 
 ```ts
-import { generateEntryCss, makeReadSources } from "@teacss/rsbuild";
-
-const { css } = await generateEntryCss(entryCss, {
-  base: root,
-  entryFile,
-  readSources: makeReadSources(root),
-});
+// src/index.ts
+import "../index.css";
 ```
 
-The returned CSS is not optimized.
-
-The optimizer preserves native `:dir()` selectors. The plugin also excludes
-their language-based rewrite in Rsbuild's CSS loader and inherited minimizer
-defaults, so explicit and nested `dir` values stay correct. Other browser
-targets and transformations are unchanged; directional styles require native
-`:dir()` support. Custom host CSS options must preserve this exclusion.
+The generated CSS covers the files `@source` matches, so it does not depend on the order Rspack builds modules in.
 
-Calculated Bézier x coordinates are guarded before both adapter optimization
-and Rsbuild's native Lightning CSS processing, including imported CSS, CSS
-Modules and PostCSS output. The internal loader preserves and composes source
-maps. Literal x coordinates, y overshoot, feature queries and custom-property
-definitions remain unchanged. See the
-[easing audit](../../docs/knowledge/steps-and-cubic-bezier-easing.md#authored-css-exposure).
+## Documentation
 
-Pre-1.0. No PostCSS plugin is required beside this adapter.
+- [Build integrations](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/references/integrations.md) and [their options](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/references/integrations.md#options), including the Rsbuild-only `test`
+- [The CSS entry](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/references/setup.md#css-entry)
+- [The TeaCSS skill](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/SKILL.md) for syntax, presets and tooling

package/dist/fonts.d.ts

@@ -0,0 +1,6 @@
+import type { Rspack } from "@rsbuild/core";
+type Sources = Pick<typeof Rspack.sources, "RawSource" | "ReplaceSource">;
+/** Moves every bundled font of each CSS asset to `teacss-fonts/teacss-<digest>.woff2` and points its `url()` there. */
+export declare function emitBundledFonts(compilation: Rspack.Compilation, sources: Sources): void;
+export {};
+//# sourceMappingURL=fonts.d.ts.map

package/dist/fonts.js

@@ -0,0 +1,26 @@
+import { posix } from "node:path";
+import { BUNDLED_FONT_URL, extractBundledFonts } from "@teacss/engine";
+/** Moves every bundled font of each CSS asset to `teacss-fonts/teacss-<digest>.woff2` and points its `url()` there. */
+export function emitBundledFonts(compilation, sources) {
+    for (const { name, source } of compilation.getAssets()) {
+        if (!name.endsWith(".css"))
+            continue;
+        const css = source.source().toString();
+        const { fonts } = extractBundledFonts(css, (digest, bytes) => {
+            const fileName = `teacss-fonts/teacss-${digest}.woff2`;
+            if (!compilation.getAsset(fileName))
+                compilation.emitAsset(fileName, new sources.RawSource(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)), { immutable: true });
+            return `./${posix.relative(posix.dirname(name), fileName)}`;
+        });
+        if (fonts.length === 0)
+            continue;
+        // Replacing each `url()` in place keeps the asset's source map (`output.sourceMap.css`); a new RawSource drops it.
+        const paths = new Map(fonts.map(({ digest, path }) => [digest, path]));
+        const replaced = new sources.ReplaceSource(source);
+        for (const match of css.matchAll(BUNDLED_FONT_URL)) {
+            replaced.replace(match.index, match.index + match[0].length - 1, `url(${JSON.stringify(paths.get(match[2] ?? ""))})`);
+        }
+        compilation.updateAsset(name, replaced);
+    }
+}
+//# sourceMappingURL=fonts.js.map

package/dist/index.d.ts

@@ -1,90 +1,9 @@
-import { RsbuildPlugin } from "@rsbuild/core";
-import { UserConfig } from "@teacss/core";
-import { Targets } from "lightningcss";
-//#region src/plugin.d.ts
-interface TeacssGenerateOptions {
-  /** Project root to scan + resolve config from. @default process.cwd() */
-  cwd?: string;
-  /** Path to the CSS entry, or a directory to discover it from. Ignored when `config` is given. */
-  configPath?: string;
-  /** Inline config — skips file loading (useful for tests / programmatic use). */
-  config?: UserConfig;
-  /** Inline source contents to extract utilities from — skips the filesystem scan. */
-  contents?: string[];
-  /** Globs ignored during the filesystem scan. */
-  ignore?: string[];
-}
-interface TeacssPluginOptions extends TeacssGenerateOptions {
-  /**
-   * Optimize the output with lightningcss (minify + vendor prefixing).
-   * `true`/`false` toggles it; `{ minify }` overrides just minification.
-   * @default in production, only when Rspack's own lightningcss loader or CSS
-   * minifier is off or `targets` is set (otherwise they optimize this output);
-   * skip in development.
-   */
-  optimize?: boolean | {
-    minify?: boolean;
-  };
-  /** lightningcss targets override. @default derived from the environment's browserslist. */
-  targets?: Targets;
-  /** Which CSS entry carries the `@teacss` directive. @default /index\.css$/ */
-  test?: RegExp;
-  /**
-   * Inline `@apply` (plus `@screen` / `theme()` / `icon()`) in `.css` files —
-   * `@apply p:4 rd:2x;` inside a rule becomes the resolved declarations,
-   * conditioned tokens (`@apply p:4@hover`) become host-scoped rules. A lexical
-   * guard skips config and transformer setup for ordinary CSS. `false` disables
-   * it; `{ test }` narrows the scope (default: all CSS).
-   * @default enabled, scope = all `.css`
-   */
-  apply?: boolean | {
+import type { RsbuildPlugin } from "@rsbuild/core";
+import { type ShellOptions } from "@teacss/engine";
+export type { ShellOptions } from "@teacss/engine";
+export interface PluginTeacssOptions extends ShellOptions {
+    /** Modules the loader sees; `node_modules` is always excluded. */
     test?: RegExp;
-  };
-}
-/** Build a `readSources` that scans `@source` include/exclude globs relative to the entry dir; the runtime reads the files. */
-export declare function makeReadSources(base: string, ignore?: string[]): (includes: string[], excludes: string[]) => Promise<{
-  files: string[];
-  sources?: string[];
-}>;
-interface GenerateEntryCssOptions {
-  /** Entry file directory — base for `@presets` relative specifiers and `@source` globs. */
-  base: string;
-  /** Entry filename, when known, so local `@import` cycles include the root identity. */
-  entryFile?: string;
-  /** Scan content for include/exclude globs; `sources` may be omitted so the runtime reads the files. Omit when `contents` is given. */
-  readSources?: (includes: string[], excludes: string[]) => Promise<{
-    files: string[];
-    sources?: string[];
-  }>;
-  /** Inline content (tests / programmatic use) — skips `readSources`. */
-  contents?: string[];
 }
-/**
- * The entry-CSS-driven build: parse the entry's directives, generate, and splice
- * the layers back in (replace `@teacss`, strip consumed directives, hoist
- * `@import`). Returns the final (unoptimized) CSS, the scanned files, and the
- * utility count. Optimization (lightningcss) is the caller's step.
- */
-export declare function generateEntryCss(entryCss: string, options: GenerateEntryCssOptions): Promise<{
-  css: string;
-  files: string[];
-  matched: number;
-  unknown: string[];
-  hasPreset: boolean;
-}>;
-/**
- * Rsbuild plugin: replace the `@teacss` directive in a CSS entry with generated
- * utilities, optimized with lightningcss, and inline `@apply` in any `.css`.
- * PostCSS-free.
- *
- * - Leaves production optimization (minify + prefix) to Rspack's lightningcss
- *   loader and minimizer; runs its own pass only when those are off or
- *   `optimize`/`targets` asks for it. Development emits the raw layers.
- * - Registers scanned files as build dependencies, so editing content re-runs
- *   generation in watch/dev mode.
- * - `@apply` (+ `@screen`/`theme()`/`icon()`) is inlined in every `.css`
- *   (fast-bailed), configurable via `apply`.
- */
-export declare function pluginTeacss(options?: TeacssPluginOptions): RsbuildPlugin;
-//#endregion
-export type { GenerateEntryCssOptions, TeacssGenerateOptions, TeacssPluginOptions };
+export declare function pluginTeacss(options?: PluginTeacssOptions): RsbuildPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1 +1,35 @@
-import{createRequire as e}from"node:module";import{statSync as t}from"node:fs";import{dirname as n,isAbsolute as r,posix as i,resolve as a}from"node:path";import o from"node:process";import{fileURLToPath as s}from"node:url";import{enableNodeCompileCache as c}from"@teacss/runtime/internal/compile-cache";import{DEFAULT_SOURCE_IGNORE as l,generateSources as u}from"@teacss/runtime/source-generation";import{bundledAssetName as d,collectBundledAssets as f}from"@teacss/runtime/internal/bundled-assets";var p=class{apply(e){e.hooks.thisCompilation.tap(`teacss-fonts`,t=>{t.hooks.processAssets.tap({name:`teacss-fonts`,stage:e.webpack.Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS},()=>{let{RawSource:n,ReplaceSource:r}=e.webpack.sources;for(let{name:e,source:a}of t.getAssets()){if(!e.endsWith(`.css`))continue;let o=f(a.source().toString());if(!o.length)continue;let s=new r(a);for(let{start:r,end:a,asset:c}of o){let o=`teacss-fonts/${d(c)}`;t.getAsset(o)||t.emitAsset(o,new n(Buffer.from(c.bytes)),{immutable:!0}),s.replace(r,a-1,`url(${JSON.stringify(`./${i.relative(i.dirname(e),o)}`)})`)}t.updateAsset(e,s)}})})}};c();const m=/\.(css|postcss|sass|scss|less|stylus|styl)(\?|$)/,h=(e,t=0)=>e<<16|t<<8,g={safari:h(14),chrome:h(90),firefox:h(88),edge:h(90)};function _(e,t){e.lastIndex=0;let n=e.test(t);return e.lastIndex=0,n}function ee(e){return/@(presets?|primary|neutral|success|warning|failure|general|focused|custom|source|shortcut|safelist)\b/.test(e)||e.includes(`@apply`)||e.includes(`--at-apply`)||e.includes(`@screen`)||e.includes(`theme(`)||e.includes(`icon(`)}function v(e,n,r,i){let a=t(e,{throwIfNoEntry:!1});a?a.isDirectory()?i(e):n(e):r(e)}const y=/[*?[\]{}()]/;function b(e,t){let r=t;for(;y.test(r);)r=n(r);return a(e,r)}async function x(e,t,n){let{scanSourceFiles:r}=await import(`@teacss/config/internal/source-scan`);return r(t,{cwd:e,expandDirectories:!0,ignore:n})}async function te(e,t,r,i=[]){let{cwd:a=o.cwd(),contents:s}=e,c=r??(await import(`@teacss/runtime`)).defaultFilesystemGlobs,d=i[0]?n(i[0]):a,f=t.config.content?.filesystem,p=f??c,m=e.ignore??(f===void 0?l:[]),h=s?[]:await x(d,p,m),g=await u(t,h,s);return{css:g.getLayers()||``,utilities:g.matched.size,files:h}}function ne(e,t=[]){return async(n,r)=>{let{scanSourceFiles:i}=await import(`@teacss/config/internal/source-scan`);return{files:await i(n,{cwd:e,expandDirectories:!0,ignore:[...r,...t]})}}}const S={icons:`@teacss/preset-icons`,official:`@teacss/preset-official`,standard:`@teacss/preset-standard`};function C(t,n){try{return n.resolve(t)}catch(r){let i;try{i=n.resolve(`teacss/package.json`)}catch{throw r}return e(i).resolve(t)}}function re(e){return e.filter(e=>!e.startsWith(`.`)&&!r(e))}function ie(t,n){let r=e(a(n,`_`));return t.map(e=>{let t=Object.hasOwn(S,e)?S[e]:void 0;return t?C(t,r):r.resolve(e)})}function ae(e,t){return e.length===t.length&&e.every((e,n)=>e===t[n])}async function w(e,t){return oe(e,t,await j(e,t.base,t.entryFile))}async function T(e,n){let r=[];for(let i of e.sources){let e;try{e=t(i,{throwIfNoEntry:!1})}catch{return}if(e&&n!==void 0&&Math.max(e.mtimeMs,e.ctimeMs)>=n)return;r.push(e?`${e.mtimeMs}:${e.ctimeMs}:${e.size}:${e.ino}`:`missing`)}let{probeSourceDeclarations:i}=await import(`@teacss/config/internal/source-scan`),a=await i(e.declarations,n!==void 0);return JSON.stringify([r,a.signature])}async function E(e){let t=e.config.content?.filesystem,n=t??(await import(`@teacss/runtime`)).defaultFilesystemGlobs;return{includes:n.filter(e=>!e.startsWith(`!`)),excludes:[...n.filter(e=>e.startsWith(`!`)).map(e=>e.slice(1)),...t===void 0?l:[]]}}async function oe(e,t,n){let{spliceEntry:r}=await import(`@teacss/directives`),{includes:i,excludes:a}=await E(n.generator),{files:o,sources:s}=t.contents?{files:[],sources:t.contents}:t.readSources?await t.readSources(i,a):{files:[],sources:[]},c=await u(n.generator,o,s);return{css:r(e,c.getLayers()||``),files:o,matched:c.matched.size,unknown:n.unknown,hasPreset:n.hasPreset}}async function se(e,{minify:t=!0,targets:n,browserslist:r}={}){let{transform:i,browserslistToTargets:a,Features:o}=await import(`lightningcss`),{prepareEasingStylesheet:s}=await import(`@teacss/directives/internal/easing`),c=n??(r?.length?a(r):g),l=O(s(e)),u=i({filename:`teacss.css`,code:Buffer.from(l.css),minify:t,errorRecovery:!0,targets:c,exclude:o.DirSelector});return{css:l.restore(u.code.toString()),skipped:u.warnings?.length??0}}const D=/(^|[;{])((?:\s|\/\*[\s\S]*?\*\/)*)all((?:\s|\/\*[\s\S]*?\*\/)*):((?:\s|\/\*[\s\S]*?\*\/)*)(?=(?:var|env)\()/gi;function O(e){let t=`--teacss-optimized-all`;for(;e.includes(t);)t+=`-x`;return{css:e.replace(D,(e,n,r,i,a)=>`${n}${r}${t}${i}:${a}`),restore:e=>e.replaceAll(t,`all`)}}function k(e,t){return typeof e==`boolean`||e==null?(e??!0)&&t:e.css!==!1&&(e.css===`always`||t)}async function A(e,t,n=[]){let{cwd:r=o.cwd(),configPath:i,config:a}=e,{createGenerator:s}=await import(`@teacss/core`),c=t??(await import(`@teacss/config`)).createRecoveryConfigLoader(),l=a?{config:a,sources:[]}:await c(r,i);return{generator:await s(n.length?{...l.config,safelist:[...l.config.safelist??[],...n]}:l.config,{engine:`auto`}),sources:l.sources}}async function j(e,t,n){let[{resolveEntryConfig:r},{sourceDeclarationStateOf:i},{createGenerator:a}]=await Promise.all([import(`@teacss/config`),import(`@teacss/config/internal/source-scan`),import(`@teacss/core`)]),o=await r(e,t,n),{config:s,sources:c,unknown:l}=o;return{generator:await a(s,{engine:`auto`}),sources:c,unknown:l,declarations:i(o),hasPreset:!!s.presets?.length,hasEntryConfig:!!(s.presets?.length||s.content||s.shortcuts||Object.keys(s.theme??{}).length||l.length),safelist:(s.safelist??[]).filter(e=>typeof e==`string`)}}async function ce(e,t,n){let[{transformDirectives:r},{default:i}]=await Promise.all([import(`@teacss/directives`),import(`magic-string`)]),a=new i(e);return await r(a,n,{},t),a.toString()}function M(e={}){let{optimize:r,targets:i,test:c=/index\.css$/,apply:l,...u}=e,d=l!==!1,f=typeof l==`object`&&l.test||m;return{name:`teacss`,setup(e){e.modifyRspackConfig(e=>{e.plugins??=[],e.plugins.push(new p)}),e.modifyRsbuildConfig((e,{mergeRsbuildConfig:t})=>t({tools:{lightningcssLoader:{exclude:{dirSelector:!0}}}},e)),e.modifyBundlerChain({order:`post`,handler(e,{CHAIN_ID:t,environment:n}){let r=n.config;if(r.tools.lightningcssLoader===!1&&!k(r.output.minify,r.mode===`production`))return;let i=s(new URL(import.meta.url.endsWith(`.ts`)?`./easing-loader.ts`:`./easing-loader.js`,import.meta.url)),a=[...e.module.rules.values()];for(let e of a){if(a.push(...e.rules.values(),...e.oneOfs.values()),!e.uses.has(t.USE.CSS))continue;let n=e.uses.has(`teacss-easing`),r=e.uses.has(t.USE.LIGHTNINGCSS)?t.USE.LIGHTNINGCSS:t.USE.CSS;e.use(`teacss-easing`).loader(i).after(r),n||e.use(t.USE.CSS).tap(e=>{let t=e;return{...t,importLoaders:(t.importLoaders??0)+1}})}}});let l,h=()=>l??=import(`@teacss/config`).then(({createRecoveryConfigLoader:e})=>e()),g=new Map,y=new Map,x=new Map,S=e=>{let t=g.get(e);if(t)return t;let n=h().then(e=>A(u,e));return g.set(e,n),n};e.onBeforeEnvironmentCompile(({environment:e})=>{g.delete(e.name),y.delete(e.name)}),e.transform({test:d?[m,c]:c},async({code:s,environment:l,addDependency:p,addMissingDependency:m,addContextDependency:C,resourcePath:w})=>{let D=w||``,O=_(c,D),M=d&&ee(s),N=M&&_(f,D);if(!O&&!N)return s;let{parseEntry:le,scanTopLevelAtRules:ue,diagnoseEntry:de}=await import(`@teacss/config`),P=O?le(s):void 0,F=P?.hasTeacss===!0;if(!F&&!N)return s;let I=!!(P&&(de(s).length||P.rolePalettes||P.presets.length>0||P.sources.length>0||P.custom.length>0||P.shortcuts.length>0)),fe=F&&ue(s).some(e=>e.name===`import`&&e.terminator===`;`),L=I||fe,R=n(w||`${u.cwd??o.cwd()}/index.css`),z=w||a(R,`index.css`);for(let e of P?.sources??[])e.exclude||v(b(R,e.glob),p,m,C);let B=re(P?.presets??[]),V,H,U,W;if(F){if(L)V=(async()=>{let e=x.get(l.name);if(e?.id===z&&e.code===s&&e.signature!==void 0&&await T(e.state)===e.signature)return W=e.signature,e.state})().then(async e=>{if(e)return H=e;let t=Date.now(),r=await j(s,R,z),i=!I&&!r.hasEntryConfig;if(i){let e=await A(u,await h(),r.safelist);r={...r,generator:e.generator,sources:[...r.sources,...e.sources],hasPreset:!!e.generator.config.presets.length,scanBase:e.sources[0]?n(e.sources[0]):u.cwd??o.cwd()}}return H={...r,sources:Array.from(new Set([z,...r.sources]))},i||(W=await T(H,t)),H}).catch(async t=>{let{getConfigSourcesFromError:n}=await import(`@teacss/config`),r=n(t);for(let e of r)v(e,p,m,C);let i=x.get(l.name);if(!i||i.id!==z)throw t;let a=Array.from(new Set([...i.state.sources,...r]));return e.logger.warn(`@teacss/rsbuild: keeping the last valid config for ${z} while its preset graph is invalid`),a.length===i.state.sources.length?i.state:{...i.state,sources:a}}),y.set(l.name,V),d?g.set(l.name,V):g.delete(l.name);else if(P.safelist.length>0){let{expandClassGroups:e,splitClassTokens:t}=await import(`@teacss/core`),n=P.safelist.flatMap(n=>t(e(n))),r=h().then(e=>A(u,e,n));g.set(l.name,r),y.delete(l.name),x.delete(l.name)}else g.delete(l.name),y.delete(l.name),x.delete(l.name)}let G=()=>{H&&U&&V&&y.get(l.name)===V&&x.set(l.name,{id:z,code:s,signature:W,packagePresetDependencies:U,packagePresetSpecifiers:B,state:H})},K=s,q;if(M&&(F||N)){try{q=await S(l.name)}catch(e){if(!V){let{getConfigSourcesFromError:t}=await import(`@teacss/config`);for(let n of t(e))v(n,p,m,C)}throw e}for(let e of q.sources)v(e,p,m,C);K=await ce(s,D,q.generator)}if(!F)return K===s?s:{code:K};let J,Y,X,Z=[],pe=!0,Q=[];if(L){let n=V?await V:await j(K,R,z),r=n.scanBase??R;for(let e of(await E(n.generator)).includes)v(b(r,e),p,m,C);({css:J,files:X,matched:Y,unknown:Z,hasPreset:pe}=await oe(K,{base:R,contents:u.contents,readSources:ne(r,u.ignore)},n));try{U=ie(B,R)}catch(n){let r=x.get(l.name);if(!(r?.id===z&&ae(r.packagePresetSpecifiers,B)&&r.packagePresetDependencies.some(e=>!t(e,{throwIfNoEntry:!1}))))throw n;U=r.packagePresetDependencies,e.logger.warn(`@teacss/rsbuild: keeping the last valid package preset dependencies for ${z} while package entries are unavailable`)}Q=Array.from(new Set([...U,...n.sources]))}else{q??=await S(l.name);let e=await te(u,q.generator,void 0,q.sources),{spliceEntry:t}=await import(`@teacss/directives`);J=t(K,e.css),Y=e.utilities,X=e.files,Q=q.sources}pe||e.logger.warn(`@teacss/rsbuild: ${w||`entry`} declares no @presets — no utilities generated. Add one, e.g. \`@presets "standard";\``),Z.length&&e.logger.warn(`@teacss/rsbuild: ${Z.length} @custom var(s) not registered (unknown namespace / illegal color step): ${Z.join(`, `)}`);for(let e of X)p(e);for(let e of Q)v(e,p,m,C);let $=(l.config.mode??o.env.NODE_ENV)===`production`,me=i===void 0&&l.config.tools?.lightningcssLoader!==!1&&k(l.config.output.minify,$);if(!(r??($&&!me)))return e.logger.info(`@teacss/rsbuild: ${Y} utilities (${$?`optimized by Rspack`:`dev, unoptimized`}) → ${(J.length/1024).toFixed(1)}KB`),G(),{code:J};let he=typeof r==`object`&&r.minify!==void 0?r.minify:k(l.config.output.minify,$),{css:ge,skipped:_e}=await se(J,{minify:he,targets:i,browserslist:l.browserslist});return e.logger.info(`@teacss/rsbuild: ${Y} utilities${_e?`, ${_e} skipped`:``} → ${(ge.length/1024).toFixed(1)}KB`),G(),{code:ge}})}}}export{w as generateEntryCss,ne as makeReadSources,M as pluginTeacss};
+import { fileURLToPath } from "node:url";
+import { createProject } from "@teacss/engine";
+import { emitBundledFonts } from "./fonts.js";
+const DEFAULT_TEST = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|html|md|mdx|css)$/;
+const NODE_MODULES = /[\\/]node_modules[\\/]/;
+const LOADER = fileURLToPath(new URL("./loader.js", import.meta.url));
+/** Rsbuild's `output.minify` rule for CSS: on in production unless turned off, "always" in every mode. */
+function rspackMinifiesCss(minify, isProd) {
+    if (typeof minify === "boolean" || minify == null)
+        return (minify ?? true) && isProd;
+    return minify.css !== false && (minify.css === "always" || isProd);
+}
+export function pluginTeacss(options = {}) {
+    const { test = DEFAULT_TEST, ...shell } = options;
+    return {
+        name: "teacss",
+        setup(api) {
+            let project;
+            api.modifyBundlerChain((chain, { environment }) => {
+                const isProd = environment.config.mode === "production";
+                project ??= createProject({ root: api.context.rootPath, envMode: api.context.action === "dev" ? "dev" : "build", ...shell });
+                const loaderOptions = { project, minify: shell.minify ?? (isProd && !rspackMinifiesCss(environment.config.output.minify, isProd)) };
+                chain.module.rule("teacss").test(test).exclude.add(NODE_MODULES).end().enforce("pre").use("teacss").loader(LOADER).options(loaderOptions);
+            });
+            api.processAssets({ stage: "pre-process" }, ({ compilation, sources }) => emitBundledFonts(compilation, sources));
+            const dispose = () => {
+                project?.dispose();
+                project = undefined;
+            };
+            api.onCloseBuild(dispose);
+            api.onCloseDevServer(dispose);
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/loader.d.ts

@@ -0,0 +1,15 @@
+import type { Rspack } from "@rsbuild/core";
+import { type Project } from "@teacss/engine";
+export interface LoaderOptions {
+    project: Project;
+    /** Passed to `engine.generate`; false when Rspack's lightningcss minimizer will minify the asset. */
+    minify: boolean;
+}
+/**
+ * v10.2 §3.3: a stylesheet's top-level `@teacss;` becomes the generated CSS of the project's `@source`
+ * files (read from disk, so the result does not depend on module build order) and of
+ * `inline.content.inline`, and the entry directives are dropped; the rest of the stylesheet goes through `project.transform` like any other.
+ * Tokens only a module outside `@source` registered are left out: Rspack may build it after the entry.
+ */
+export default function teacssLoader(this: Rspack.LoaderContext<LoaderOptions>, source: string): void;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { isCssId, parseEntry, replaceEntryWithMap } from "@teacss/engine";
+/**
+ * v10.2 §3.3: a stylesheet's top-level `@teacss;` becomes the generated CSS of the project's `@source`
+ * files (read from disk, so the result does not depend on module build order) and of
+ * `inline.content.inline`, and the entry directives are dropped; the rest of the stylesheet goes through `project.transform` like any other.
+ * Tokens only a module outside `@source` registered are left out: Rspack may build it after the entry.
+ */
+export default function teacssLoader(source) {
+    const { project, minify } = this.getOptions();
+    const id = this.resourcePath;
+    if (isCssId(id) && parseEntry(source, id).hasTeacss) {
+        project.reload();
+        const { engine } = project;
+        for (const path of project.info.unreadableDirectories)
+            this.emitWarning(new Error(`cannot read ${path} (E_IO)`));
+        const files = project.info.sourceFiles;
+        engine.updateModules(files, files.map((file) => readFileSync(file, "utf8")));
+        for (const file of project.watchFiles())
+            this.addDependency(file);
+        for (const file of engine.missingImports())
+            this.addMissingDependency(file);
+        for (const { dir } of project.sourceDirectories())
+            this.addContextDependency(dir);
+        const sourceTokens = new Set([...files.flatMap((file) => engine.moduleTokens(file) ?? []), ...project.inlineTokens()]);
+        const tokens = engine.allTokens().filter((token) => sourceTokens.has(token));
+        const result = engine.generate({ kind: "tokens", tokens }, { minify, css: true });
+        project.reportUnmatched(result, { tokens, warn: (message) => this.emitWarning(new Error(message)) });
+        const { code, map } = project.transform(id, source);
+        const entry = replaceEntryWithMap(code, () => result.css, { id, original: source, map });
+        this.callback(null, entry?.code ?? code, entry ? { ...entry.map, file: id } : undefined);
+        return;
+    }
+    const { code, map } = project.transform(id, source);
+    this.callback(null, code, map ? { ...map, file: map.file ?? id } : undefined);
+}
+//# sourceMappingURL=loader.js.map

package/package.json

@@ -1,49 +1,56 @@
 {
   "name": "@teacss/rsbuild",
-  "version": "0.9.3",
-  "description": "Rsbuild integration for TeaCSS — generate utilities and optimize with lightningcss, no PostCSS.",
-  "homepage": "https://css.teasim.com",
-  "funding": "https://github.com/sponsors/billgo",
+  "version": "0.10.2",
+  "description": "Rsbuild plugin for TeaCSS: an Rspack loader that calls the Rust engine (@teacss/engine) directly",
   "license": "MIT",
-  "author": "Billgo <hi@billgo.me>",
-  "sideEffects": false,
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/teacss/teacss-rs.git",
+    "directory": "packages/rsbuild"
+  },
+  "homepage": "https://github.com/teacss/teacss-rs/tree/master/packages/rsbuild#readme",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.ts",
+  "imports": {
+    "#src/*": "./dist/*"
+  },
   "files": [
-    "dist",
-    "README.md"
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
   ],
-  "scripts": {
-    "build": "bunx tsdown --config tsdown.config.mts",
-    "dev": "tsdown --watch"
+  "sideEffects": false,
+  "engines": {
+    "node": ">=26"
+  },
+  "peerDependencies": {
+    "@rsbuild/core": ">=1"
   },
   "dependencies": {
-    "@jridgewell/remapping": "^2.3.5",
-    "@teacss/config": "0.9.3",
-    "@teacss/core": "0.9.3",
-    "@teacss/directives": "0.9.3",
-    "@teacss/engine": "0.9.3",
-    "@teacss/runtime": "0.9.3",
-    "lightningcss": "^1.33.0",
-    "magic-string": "^1.2.3"
+    "@teacss/engine": "0.10.2"
   },
   "devDependencies": {
-    "@rsbuild/core": "^2.2.3",
-    "@teacss/preset-official": "0.9.3",
-    "@teacss/preset-standard": "0.9.3",
-    "consola": "^3.4.2"
+    "@rsbuild/core": "2.2.14",
+    "@types/node": "^22.20.5",
+    "typescript": "^5.9.3"
   },
-  "peerDependencies": {
-    "@rsbuild/core": "^2"
-  },
-  "engines": {
-    "node": ">=22.12.0"
+  "scripts": {
+    "build:ts": "node -e \"for (const d of ['build','dist']) require('fs').rmSync(d,{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.test.json",
+    "build": "npm run build:ts",
+    "check:types": "tsc -p tests/consumer/tsconfig.json --noEmit",
+    "test": "npm run build:ts && npm run check:types && node --test \"build/tests/**/*.test.js\""
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
 }

package/dist/easing-loader.d.ts

@@ -1,10 +0,0 @@
-import { EncodedSourceMap } from "@jridgewell/remapping";
-//#region src/easing-loader.d.ts
-interface LoaderContext {
-  resourcePath: string;
-  sourceMap?: boolean;
-  callback(error: Error | null, code: string, map?: EncodedSourceMap | string, additionalData?: unknown): void;
-}
-/** Preserve calculated easing ranges before Rsbuild's native CSS optimizer. */
-export default function easingLoader(this: LoaderContext, source: string, inputMap?: EncodedSourceMap | string, additionalData?: unknown): void;
-//#endregion

package/dist/easing-loader.js

@@ -1 +0,0 @@
-import e from"@jridgewell/remapping";import{prepareEasingCss as t}from"@teacss/directives/internal/easing";import n from"magic-string";function r(r,i,a){let o=new n(r);if(t(o),!o.hasChanged()){this.callback(null,r,i,a);return}let s;if(this.sourceMap){let t=o.generateMap({hires:!0,includeContent:!0,source:this.resourcePath});s=i?e([t,i],()=>null):t}let c=a&&typeof a==`object`&&`ast`in a?{...a,ast:void 0}:a;this.callback(null,o.toString(),s,c)}export{r as default};