refactor: use bundler resources

examples/astro-solid/astro.config.js

@@ -20,9 +20,6 @@ export default defineConfig({
       vite_linaria({
         displayName: true,
         classNameSlug: (hash, title, args) => `${args.dir}_${title}_${hash}`,
-        babelOptions: {
-          presets: ['solid'],
-        },
       }),
       vite_inspect(),
     ],

packages/babel/src/cache.ts

@@ -0,0 +1,13 @@
+import type Module from './module';
+import type { ITransformFileResult } from './types';
+
+export class TransformCacheCollection {
+  constructor(
+    public readonly resolveCache: Map<string, string> = new Map(),
+    public readonly codeCache: Map<
+      string,
+      Map<string, ITransformFileResult>
+    > = new Map(),
+    public readonly evalCache: Map<string, Module> = new Map()
+  ) {}
+}

packages/babel/src/evaluators/index.ts

@@ -2,27 +2,20 @@
  * This file is an entry point for module evaluation for getting lazy dependencies.
  */
 
+import type { TransformCacheCollection } from '../cache';
 import Module from '../module';
 import loadLinariaOptions from '../transform-stages/helpers/loadLinariaOptions';
-import type { Options, CodeCache } from '../types';
+import type { Options } from '../types';
 
 export default function evaluate(
-  resolveCache: Map<string, string>,
-  codeCache: CodeCache,
-  evalCache: Map<string, Module>,
+  cache: TransformCacheCollection,
   code: string[],
   options: Pick<Options, 'filename' | 'pluginOptions'>
 ) {
   const filename = options?.filename ?? 'unknown';
   const pluginOptions = loadLinariaOptions(options.pluginOptions);
 
-  const m = new Module(
-    filename ?? 'unknown',
-    pluginOptions,
-    resolveCache,
-    codeCache,
-    evalCache
-  );
+  const m = new Module(filename ?? 'unknown', pluginOptions, cache);
 
   m.dependencies = [];
   m.evaluate(code);

packages/babel/src/index.ts

@@ -29,6 +29,7 @@ export { default as getVisitorKeys } from './utils/getVisitorKeys';
 export type { VisitorKeys } from './utils/getVisitorKeys';
 export { default as peek } from './utils/peek';
 export { default as processTemplateExpression } from './utils/processTemplateExpression';
+export { TransformCacheCollection } from './cache';
 
 function isEnabled(caller?: TransformCaller & { evaluate?: true }) {
   return caller?.name !== 'linaria' || caller.evaluate === true;

packages/babel/src/module.ts

@@ -24,8 +24,9 @@ import type { BaseProcessor } from '@linaria/tags';
 import type { StrictOptions } from '@linaria/utils';
 import { getFileIdx } from '@linaria/utils';
 
+import { TransformCacheCollection } from './cache';
 import * as process from './process';
-import type { CodeCache } from './types';
+import type { ITransformFileResult } from './types';
 
 // Supported node builtins based on the modules polyfilled by webpack
 // `true` means module is polyfilled, `false` means module is empty
@@ -121,12 +122,16 @@ class Module {
 
   debug: CustomDebug;
 
+  resolveCache: Map<string, string>;
+
+  codeCache: Map<string, Map<string, ITransformFileResult>>;
+
+  evalCache: Map<string, Module>;
+
   constructor(
     filename: string,
     options: StrictOptions,
-    private resolveCache: Map<string, string>,
-    private codeCache: CodeCache,
-    private evalCache: Map<string, Module>,
+    { codeCache, evalCache, resolveCache } = new TransformCacheCollection(),
     private debuggerDepth = 0,
     private parentModule?: Module
   ) {
@@ -140,6 +145,10 @@ class Module {
     this.transform = null;
     this.debug = createCustomDebug('module', this.idx);
 
+    this.resolveCache = resolveCache;
+    this.codeCache = codeCache;
+    this.evalCache = evalCache;
+
     Object.defineProperties(this, {
       id: {
         value: filename,
@@ -338,9 +347,11 @@ class Module {
         m = new Module(
           filename,
           this.options,
-          this.resolveCache,
-          this.codeCache,
-          this.evalCache,
+          {
+            codeCache: this.codeCache,
+            evalCache: this.evalCache,
+            resolveCache: this.resolveCache,
+          },
           this.debuggerDepth + 1,
           this
         );

packages/babel/src/plugins/babel-transform.ts

@@ -3,40 +3,34 @@ import type { NodePath } from '@babel/traverse';
 
 import { debug } from '@linaria/logger';
 import type { StrictOptions } from '@linaria/utils';
-import { removeWithRelated, syncResolve } from '@linaria/utils';
+import { removeWithRelated, syncAcquire } from '@linaria/utils';
 
 import type { Core } from '../babel';
-import type Module from '../module';
+import { TransformCacheCollection } from '../cache';
 import { prepareForEvalSync } from '../transform-stages/1-prepare-for-eval';
 import evalStage from '../transform-stages/2-eval';
-import type { CodeCache, IPluginState } from '../types';
+import type { IPluginState } from '../types';
+import { createEntryPoint } from '../utils/createEntryPoint';
 import processTemplateExpression from '../utils/processTemplateExpression';
 import withLinariaMetadata from '../utils/withLinariaMetadata';
 
 export default function collector(
   babel: Core,
   options: StrictOptions
 ): PluginObj<IPluginState> {
-  const codeCache: CodeCache = new Map();
-  const resolveCache = new Map<string, string>();
-  const evalCache = new Map<string, Module>();
+  const cache = new TransformCacheCollection();
 
   return {
     name: '@linaria/babel/babel-transform',
     pre(file: BabelFile) {
       debug('babel-transform:start', file.opts.filename);
 
-      const entryPoint = {
-        name: file.opts.filename!,
-        code: file.code,
-        only: ['__linariaPreval'],
-      };
+      const entryPoint = createEntryPoint(file.opts.filename!, file.code);
 
       const prepareStageResults = prepareForEvalSync(
         babel,
-        resolveCache,
-        codeCache,
-        syncResolve,
+        cache,
+        syncAcquire,
         entryPoint,
         {
           root: file.opts.root ?? undefined,
@@ -52,9 +46,7 @@ export default function collector(
       }
 
       const evalStageResult = evalStage(
-        resolveCache,
-        codeCache,
-        evalCache,
+        cache,
         prepareStageResults.map((r) => r.code),
         {
           filename: file.opts.filename!,

packages/babel/src/transform-stages/1-prepare-for-eval.ts

@@ -1,4 +1,3 @@
-import { readFileSync } from 'fs';
 import { dirname, extname } from 'path';
 
 import type { BabelFileResult, TransformOptions } from '@babel/core';
@@ -8,8 +7,13 @@ import type { EvalRule, Evaluator } from '@linaria/utils';
 import { buildOptions, getFileIdx, loadBabelOptions } from '@linaria/utils';
 
 import type { Core } from '../babel';
+import type { TransformCacheCollection } from '../cache';
 import type Module from '../module';
-import type { CodeCache, ITransformFileResult, Options } from '../types';
+import type {
+  ExternalAcquireResult,
+  ITransformFileResult,
+  Options,
+} from '../types';
 import withLinariaMetadata from '../utils/withLinariaMetadata';
 
 import cachedParseSync from './helpers/cachedParseSync';
@@ -172,26 +176,22 @@ function prepareCode(
   return [...result, preevalStageResult.metadata];
 }
 
+type ProcessQueueItemResult = {
+  imports: Map<string, string[]> | null;
+  name: string;
+  results: ITransformFileResult[];
+};
+
 function processQueueItem(
   babel: Core,
-  item: {
-    name: string;
-    code: string;
-    only: string[];
-  } | null,
-  codeCache: CodeCache,
+  item: FileInQueue | null,
+  cache: TransformCacheCollection,
   options: Pick<Options, 'root' | 'pluginOptions' | 'inputSourceMap'>
-):
-  | {
-      imports: Map<string, string[]> | null;
-      name: string;
-      results: ITransformFileResult[];
-    }
-  | undefined {
+): ProcessQueueItemResult | undefined {
   if (!item) {
     return undefined;
   }
-
+  const { codeCache } = cache;
   const pluginOptions = loadLinariaOptions(options.pluginOptions);
 
   const results = new Set<ITransformFileResult>();
@@ -272,14 +272,17 @@ function processQueueItem(
 
 export function prepareForEvalSync(
   babel: Core,
-  resolveCache: Map<string, string>,
-  codeCache: CodeCache,
-  resolve: (what: string, importer: string, stack: string[]) => string,
+  cache: TransformCacheCollection,
+  acquire: (
+    what: string,
+    importer: string,
+    stack: string[]
+  ) => ExternalAcquireResult,
   resolvedFile: FileInQueue,
   options: Pick<Options, 'root' | 'pluginOptions' | 'inputSourceMap'>,
   stack: string[] = []
 ): ITransformFileResult[] | undefined {
-  const processed = processQueueItem(babel, resolvedFile, codeCache, options);
+  const processed = processQueueItem(babel, resolvedFile, cache, options);
   if (!processed) return undefined;
 
   const { imports, name, results } = processed;
@@ -290,28 +293,24 @@ export function prepareForEvalSync(
 
   imports?.forEach((importsOnly, importedFile) => {
     try {
-      const resolved = resolve(importedFile, name, stack);
-      log('stage-1:sync-resolve', `✅ ${importedFile} -> ${resolved}`);
-      resolveCache.set(
+      const { id, code } = acquire(importedFile, name, stack);
+      log('stage-1:sync-acquire', `✅ ${importedFile} -> ${id}`);
+      cache.resolveCache.set(
         `${name} -> ${importedFile}`,
-        `${resolved}\0${importsOnly.join(',')}`
+        `${id}\0${importsOnly.join(',')}`
       );
-      const fileContent = readFileSync(resolved, 'utf8');
       queue.push({
-        name: resolved,
+        name: id,
         only: importsOnly,
-        code: fileContent,
+        code,
       });
     } catch (err) {
-      log('stage-1:sync-resolve', `❌ cannot resolve ${importedFile}: %O`, err);
+      log('stage-1:sync-acquire', `❌ cannot acquire ${importedFile}: %O`, err);
     }
   });
 
   queue.forEach((item) => {
-    prepareForEvalSync(babel, resolveCache, codeCache, resolve, item, options, [
-      name,
-      ...stack,
-    ]);
+    prepareForEvalSync(babel, cache, acquire, item, options, [name, ...stack]);
   });
 
   return Array.from(results);
@@ -325,13 +324,12 @@ const mutexes = new Map<string, Promise<void>>();
  */
 export default async function prepareForEval(
   babel: Core,
-  resolveCache: Map<string, string>,
-  codeCache: CodeCache,
-  resolve: (
+  cache: TransformCacheCollection,
+  acquire: (
     what: string,
     importer: string,
     stack: string[]
-  ) => Promise<string | null>,
+  ) => Promise<ExternalAcquireResult | null>,
   file: Promise<FileInQueue>,
   options: Pick<Options, 'root' | 'pluginOptions' | 'inputSourceMap'>,
   stack: string[] = []
@@ -342,7 +340,7 @@ export default async function prepareForEval(
     await mutex;
   }
 
-  const processed = processQueueItem(babel, resolvedFile, codeCache, options);
+  const processed = processQueueItem(babel, resolvedFile, cache, options);
   if (!processed) return undefined;
 
   const { imports, name, results } = processed;
@@ -352,16 +350,17 @@ export default async function prepareForEval(
   const promises: Promise<ITransformFileResult[] | undefined>[] = [];
 
   imports?.forEach((importsOnly, importedFile) => {
-    const promise = resolve(importedFile, name, stack).then(
+    const promise = acquire(importedFile, name, stack).then(
       (resolved) => {
         if (resolved === null) {
-          log('stage-1:resolve', `✅ ${importedFile} is ignored`);
+          log('stage-1:acquire', `✅ ${importedFile} is ignored`);
           return null;
         }
+        const { code, id } = resolved;
 
-        log('stage-1:async-resolve', `✅ ${importedFile} -> ${resolved}`);
+        log('stage-1:acquire', `✅ ${importedFile} -> ${id}`);
         const resolveCacheKey = `${name} -> ${importedFile}`;
-        const cached = resolveCache.get(resolveCacheKey);
+        const cached = cache.resolveCache.get(resolveCacheKey);
         const importsOnlySet = new Set(importsOnly);
         if (cached) {
           const [, cachedOnly] = cached.split('\0');
@@ -370,37 +369,24 @@ export default async function prepareForEval(
           });
         }
 
-        resolveCache.set(
+        cache.resolveCache.set(
           resolveCacheKey,
-          `${resolved}\0${[...importsOnlySet].join(',')}`
+          `${id}\0${[...importsOnlySet].join(',')}`
         );
-        const fileContent = readFileSync(resolved, 'utf8');
         return {
-          name: resolved,
+          name: id,
           only: importsOnly,
-          code: fileContent,
+          code,
         };
       },
       (err: unknown) => {
-        log(
-          'stage-1:async-resolve',
-          `❌ cannot resolve ${importedFile}: %O`,
-          err
-        );
+        log('stage-1:acquire', `❌ cannot resolve ${importedFile}: %O`, err);
         return null;
       }
     );
 
     promises.push(
-      prepareForEval(
-        babel,
-        resolveCache,
-        codeCache,
-        resolve,
-        promise,
-        options,
-        [name, ...stack]
-      )
+      prepareForEval(babel, cache, acquire, promise, options, [name, ...stack])
     );
   });