effect-start 0.13.0 → 0.14.0

package/src/{bun/BunTailwindPlugin.ts → x/tailwind/TailwindPlugin.ts}

@@ -1,18 +1,8 @@
-import type * as Tailwind from "@tailwindcss/node"
 import type { BunPlugin } from "bun"
 import * as NPath from "node:path"
+import * as Tailwind from "./compile.ts"
 
-type Compiler = Awaited<ReturnType<typeof Tailwind.compile>>
-
-export const make = (opts: {
-  /**
-   * Custom importer function to load Tailwind.
-   * By default, it imports from '@tailwindcss/node'.
-   * If you want to use a different version or a custom implementation,
-   * provide your own importer.
-   */
-  importer?: () => Promise<typeof Tailwind>
-
+export const make = (opts?: {
   /**
    * Pattern to match component and HTML files for class name extraction.
    */
@@ -33,24 +23,19 @@ export const make = (opts: {
    * Useful when we want to scan clientside code which is not imported directly on serverside.
    */
   scanPath?: string
-} = {}): BunPlugin => {
+
+  target?: "browser" | "bun" | "node"
+}): BunPlugin => {
   const {
     filesPattern = /\.(jsx?|tsx?|html|svelte|vue|astro)$/,
     cssPattern = /\.css$/,
-    importer = () =>
-      import("@tailwindcss/node").catch(err => {
-        throw new Error(
-          "Tailwind not found: install @tailwindcss/node or provide custom importer option",
-        )
-      }),
-  } = opts
+    target = "browser",
+  } = opts ?? {}
 
   return {
-    name: "Bun Tailwind.css plugin",
-    target: "browser",
+    name: "Tailwind.css plugin",
+    target,
     async setup(builder) {
-      const Tailwind = await importer()
-
       const scannedCandidates = new Set<string>()
       // (file) -> (class names)
       const classNameCandidates = new Map<string, Set<string>>()
@@ -59,21 +44,22 @@ export const make = (opts: {
       // (imported path) -> (importer paths)
       const importDescendants = new Map<string, Set<string>>()
 
-      if (opts.scanPath) {
-        const candidates = await scanFiles(opts.scanPath)
+      const prepopulateCandidates = opts?.scanPath
+        ? async () => {
+          const candidates = await scanFiles(opts.scanPath!)
 
-        candidates.forEach(candidate => scannedCandidates.add(candidate))
-      }
+          scannedCandidates.clear()
 
-      /**
-       * Track import relationships when dynamically scanning
-       * from tailwind entrypoints.
-       *
-       * As of Bun 1.3 this pathway break for Bun Full-Stack server.
-       * Better to pass scanPath explicitly.
-       * @see https://github.com/oven-sh/bun/issues/20877
-       */
-      if (!opts.scanPath) {
+          candidates.forEach(candidate => scannedCandidates.add(candidate))
+        }
+        : null
+
+      // Track import relationships when dynamically scanning
+      // from tailwind entrypoints.
+      // As of Bun 1.3 this pathway break for Bun Full-Stack server.
+      // Better to pass scanPath explicitly.
+      // @see https://github.com/oven-sh/bun/issues/20877
+      if (!prepopulateCandidates) {
         builder.onResolve({
           filter: /.*/,
         }, (args) => {
@@ -142,18 +128,18 @@ export const make = (opts: {
 
         const compiler = await Tailwind.compile(source, {
           base: NPath.dirname(args.path),
-          shouldRewriteUrls: true,
           onDependency: (path) => {},
         })
 
+        await prepopulateCandidates?.()
+
         // wait for other files to be loaded so we can collect class name candidates
         await args.defer()
 
-        const candidates = new Set<string>()
-
-        scannedCandidates.forEach(candidate => candidates.add(candidate))
+        const candidates = new Set<string>(scannedCandidates)
 
-        {
+        // when we scan a path, we don't need to track candidate tree
+        if (!prepopulateCandidates) {
           const pendingModules = [
             // get class name candidates from all modules that import this one
             ...(importAncestors.get(args.path) ?? []),
@@ -311,6 +297,10 @@ async function scanFiles(dir: string): Promise<Set<string>> {
       absolute: true,
     })
   ) {
+    if (filePath.includes("/node_modules/")) {
+      continue
+    }
+
     const contents = await Bun.file(filePath).text()
     const classNames = extractClassNames(contents)
 

package/src/x/tailwind/compile.ts

@@ -0,0 +1,243 @@
+import fsPromises from "node:fs/promises"
+import path from "node:path"
+import { pathToFileURL } from "node:url"
+import {
+  compile as _compile,
+  compileAst as _compileAst,
+  Features,
+  Polyfills,
+} from "tailwindcss"
+import * as BunEnhancedResolve from "../../bun/_BunEnhancedResolve"
+
+type AstNode = Parameters<typeof _compileAst>[0][number]
+
+export {
+  Features,
+  Polyfills,
+}
+
+export type Resolver = (
+  id: string,
+  base: string,
+) => Promise<string | false | undefined>
+
+export interface CompileOptions {
+  base: string
+  from?: string
+  onDependency: (path: string) => void
+  polyfills?: Polyfills
+
+  customCssResolver?: Resolver
+  customJsResolver?: Resolver
+}
+
+function createCompileOptions({
+  base,
+  from,
+  polyfills,
+  onDependency,
+
+  customCssResolver,
+  customJsResolver,
+}: CompileOptions) {
+  return {
+    base,
+    polyfills,
+    from,
+    async loadModule(id: string, base: string) {
+      return loadModule(id, base, onDependency, customJsResolver)
+    },
+    async loadStylesheet(id: string, sheetBase: string) {
+      let sheet = await loadStylesheet(
+        id,
+        sheetBase,
+        onDependency,
+        customCssResolver,
+      )
+
+      return sheet
+    },
+  }
+}
+
+async function ensureSourceDetectionRootExists(compiler: {
+  root: Awaited<ReturnType<typeof compile>>["root"]
+}) {
+  // Verify if the `source(…)` path exists (until the glob pattern starts)
+  if (compiler.root && compiler.root !== "none") {
+    let globSymbols = /[*{]/
+    let basePath: string[] = []
+    for (let segment of compiler.root.pattern.split("/")) {
+      if (globSymbols.test(segment)) {
+        break
+      }
+
+      basePath.push(segment)
+    }
+
+    let exists = await fsPromises
+      .stat(path.resolve(compiler.root.base, basePath.join("/")))
+      .then((stat) => stat.isDirectory())
+      .catch(() => false)
+
+    if (!exists) {
+      throw new Error(
+        `The \`source(${compiler.root.pattern})\` does not exist or is not a directory.`,
+      )
+    }
+  }
+}
+
+export async function compileAst(ast: AstNode[], options: CompileOptions) {
+  let compiler = await _compileAst(ast, createCompileOptions(options))
+  await ensureSourceDetectionRootExists(compiler)
+  return compiler
+}
+
+export async function compile(css: string, options: CompileOptions) {
+  let compiler = await _compile(css, createCompileOptions(options))
+  await ensureSourceDetectionRootExists(compiler)
+  return compiler
+}
+
+export async function loadModule(
+  id: string,
+  base: string,
+  _onDependency: (path: string) => void,
+  customJsResolver?: Resolver,
+) {
+  if (id[0] !== ".") {
+    let resolvedPath = await resolveJsId(id, base, customJsResolver)
+    if (!resolvedPath) {
+      throw new Error(`Could not resolve '${id}' from '${base}'`)
+    }
+
+    let module = await importModule(pathToFileURL(resolvedPath).href)
+    return {
+      path: resolvedPath,
+      base: path.dirname(resolvedPath),
+      module: module.default ?? module,
+    }
+  }
+
+  let resolvedPath = await resolveJsId(id, base, customJsResolver)
+  if (!resolvedPath) {
+    throw new Error(`Could not resolve '${id}' from '${base}'`)
+  }
+
+  let [module] = await Promise.all([
+    importModule(pathToFileURL(resolvedPath).href + "?id=" + Date.now()),
+  ])
+
+  return {
+    path: resolvedPath,
+    base: path.dirname(resolvedPath),
+    module: module.default ?? module,
+  }
+}
+
+async function loadStylesheet(
+  id: string,
+  base: string,
+  onDependency: (path: string) => void,
+  cssResolver?: Resolver,
+) {
+  let resolvedPath = await resolveCssId(id, base, cssResolver)
+  if (!resolvedPath) throw new Error(`Could not resolve '${id}' from '${base}'`)
+
+  onDependency(resolvedPath)
+
+  let file = await fsPromises.readFile(resolvedPath, "utf-8")
+  return {
+    path: resolvedPath,
+    base: path.dirname(resolvedPath),
+    content: file,
+  }
+}
+
+async function importModule(path: string): Promise<any> {
+  if (typeof globalThis.__tw_load === "function") {
+    let module = await globalThis.__tw_load(path)
+    if (module) {
+      return module
+    }
+  }
+
+  return await import(path)
+}
+
+const cssResolver = BunEnhancedResolve.ResolverFactory.createResolver({
+  extensions: [".css"],
+  mainFields: ["style"],
+  conditionNames: ["style"],
+})
+async function resolveCssId(
+  id: string,
+  base: string,
+  customCssResolver?: Resolver,
+): Promise<string | false | undefined> {
+  if (typeof globalThis.__tw_resolve === "function") {
+    let resolved = globalThis.__tw_resolve(id, base)
+    if (resolved) {
+      return Promise.resolve(resolved)
+    }
+  }
+
+  if (customCssResolver) {
+    let customResolution = await customCssResolver(id, base)
+    if (customResolution) {
+      return customResolution
+    }
+  }
+
+  return runResolver(cssResolver, id, base)
+}
+
+const esmResolver = BunEnhancedResolve.ResolverFactory.createResolver({
+  extensions: [".js", ".json", ".node", ".ts"],
+  conditionNames: ["node", "import"],
+  mainFields: ["module", "main"],
+})
+
+const cjsResolver = BunEnhancedResolve.ResolverFactory.createResolver({
+  extensions: [".js", ".json", ".node", ".ts"],
+  conditionNames: ["node", "require"],
+  mainFields: ["main"],
+})
+
+async function resolveJsId(
+  id: string,
+  base: string,
+  customJsResolver?: Resolver,
+): Promise<string | false | undefined> {
+  if (typeof globalThis.__tw_resolve === "function") {
+    let resolved = globalThis.__tw_resolve(id, base)
+    if (resolved) {
+      return Promise.resolve(resolved)
+    }
+  }
+
+  if (customJsResolver) {
+    let customResolution = await customJsResolver(id, base)
+    if (customResolution) {
+      return customResolution
+    }
+  }
+
+  return runResolver(esmResolver, id, base).catch(() =>
+    runResolver(cjsResolver, id, base)
+  )
+}
+
+function runResolver(
+  resolver: BunEnhancedResolve.Resolver,
+  id: string,
+  base: string,
+): Promise<string | false | undefined> {
+  return new Promise((resolve, reject) =>
+    resolver.resolve({}, base, id, {}, (err, result) => {
+      if (err) return reject(err)
+      resolve(result)
+    })
+  )
+}

package/src/x/tailwind/plugin.ts

@@ -1,6 +1,6 @@
 import * as NPath from "node:path"
-import * as BunTailwindPlugin from "../../bun/BunTailwindPlugin.ts"
 import * as NodeUtils from "../../NodeUtils.ts"
+import * as TailwindPlugin from "./TailwindPlugin.ts"
 
 // Append `?dir=` to module identifier to pass custom directory to scan
 const dirParam = URL.parse(import.meta.url)?.searchParams.get("dir")
@@ -12,6 +12,6 @@ const scanPath = dirParam
   : process.cwd()
 
 // Export as default to be used in bunfig.toml
-export default BunTailwindPlugin.make({
+export default TailwindPlugin.make({
   scanPath,
 })

package/src/JsModule.test.ts

@@ -1,14 +0,0 @@
-import * as t from "bun:test"
-import * as JsModule from "./JsModule.ts"
-
-t.describe(`${JsModule.importSource.name}`, () => {
-  t.it("imports a string", async () => {
-    const mod = await JsModule.importSource<any>(`
-      export const b = "B"
-    `)
-
-    t
-      .expect(mod.b)
-      .toBe("B")
-  })
-})

package/src/JsModule.ts

@@ -1,116 +0,0 @@
-import * as Array from "effect/Array"
-import * as Function from "effect/Function"
-import * as Iterable from "effect/Iterable"
-import * as Order from "effect/Order"
-import * as Record from "effect/Record"
-import * as NFS from "node:fs"
-import * as NFSP from "node:fs/promises"
-import * as NPath from "node:path"
-import * as process from "node:process"
-
-/**
- * Imports a blob as a module.
- * Useful for loading code from build artifacts.
- *
- * Temporary files are wrriten to closest node_modules/ for node resolver
- * to pick up dependencies correctly and to avoid arbitrary file watchers
- * from detecting them.
- */
-export async function importBlob<M = unknown>(
-  blob: Blob,
-  entrypoint = "index.js",
-): Promise<M> {
-  return await importBundle({
-    [entrypoint]: blob,
-  }, entrypoint)
-}
-
-/**
- * Imports an entrypoint from multiple blobs.
- * Useful for loading code from build artifacts.
- *
- * Temporary files are wrriten to closest node_modules/ for node resolver
- * to pick up dependencies correctly and to avoid arbitrary file watchers
- * from detecting them.
- *
- * WARNING: dynamic imports that happened after this function will fail
- */
-export async function importBundle<M = unknown>(
-  blobs: {
-    [path: string]: Blob
-  },
-  entrypoint: string,
-  basePath = findNodeModules() + "/.tmp",
-): Promise<M> {
-  const sortedBlobs = Function.pipe(
-    blobs,
-    Record.toEntries,
-    Array.sortWith(v => v[0], Order.string),
-    Array.map(v => v[1]),
-  )
-  const bundleBlob = new Blob(sortedBlobs)
-  const hashPrefix = await hashBuffer(await bundleBlob.arrayBuffer())
-    .then(v => v.slice(0, 8))
-  const dir = `${basePath}/effect-start-${hashPrefix}`
-
-  await NFSP.mkdir(dir, { recursive: true })
-
-  await Promise.all(Function.pipe(
-    blobs,
-    Record.toEntries,
-    Array.map(([path, blob]) => {
-      const fullPath = `${dir}/${path}`
-
-      return blob
-        .arrayBuffer()
-        .then(v => NFSP.writeFile(fullPath, Buffer.from(v)))
-    }),
-  ))
-
-  const bundleModule = await import(`${dir}/${entrypoint}`)
-
-  await NFSP
-    .rmdir(dir, { recursive: true })
-    // if called concurrently, file sometimes may be deleted
-    // safe ignore when this happens
-    .catch(() => {})
-
-  return bundleModule
-}
-
-export function findNodeModules(startDir = process.cwd()) {
-  let currentDir = NPath.resolve(startDir)
-
-  while (currentDir !== NPath.parse(currentDir).root) {
-    const nodeModulesPath = NPath.join(currentDir, "node_modules")
-    if (
-      NFS.statSync(nodeModulesPath).isDirectory()
-    ) {
-      return nodeModulesPath
-    }
-
-    currentDir = NPath.dirname(currentDir)
-  }
-
-  return null
-}
-
-/**
- * Loads a JS module from a string using data: import
- */
-export async function importSource<M = unknown>(
-  code: string,
-): Promise<M> {
-  const dataUrl = `data:text/javascript,${encodeURIComponent(code)}`
-  return await import(dataUrl)
-}
-
-async function hashBuffer(buffer: BufferSource) {
-  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer)
-
-  return Function.pipe(
-    new Uint8Array(hashBuffer),
-    Iterable.map(b => b.toString(16).padStart(2, "0")),
-    Iterable.reduce("", (a, b) => a + b),
-  )
-}