effect-start 0.21.0 → 0.22.0

package/src/x/cloudflare/CloudflareTunnel.ts

@@ -11,9 +11,9 @@ import {
   String,
 } from "effect"
 
-export class CloudflareTunnelSpawnError extends Data.TaggedError(
-  "CloudflareTunnelSpawnError",
-)<{ cause: unknown }> {}
+export class CloudflareTunnelSpawnError extends Data.TaggedError("CloudflareTunnelSpawnError")<{
+  cause: unknown
+}> {}
 
 export const start = (opts: {
   command?: string
@@ -23,36 +23,28 @@ export const start = (opts: {
   logLevel?: LogLevel.LogLevel
   logPrefix?: string
 }) =>
-  Effect.gen(function*() {
-    const logPrefix = String.isString(opts.logPrefix)
-      ? opts.logPrefix
-      : "CloudflareTunnel: "
-    const args: string[] = [
+  Effect.gen(function* () {
+    const logPrefix = String.isString(opts.logPrefix) ? opts.logPrefix : "CloudflareTunnel: "
+    const args: Array<string> = [
       "tunnel",
       "run",
-      opts.tunnelUrl
-        ? [
-          "--url",
-          opts.tunnelUrl,
-        ]
-        : [],
+      opts.tunnelUrl ? ["--url", opts.tunnelUrl] : [],
       opts.tunnelName,
-    ]
-      .flatMap(v => v)
+    ].flatMap((v) => v)
 
     const proc = yield* Effect.try({
       try: () =>
-        Bun.spawn(
-          [opts.command ?? "cloudflared", ...args],
-          { stderr: "pipe", stdout: "pipe" },
-        ),
+        Bun.spawn([opts.command ?? "cloudflared", ...args], {
+          stderr: "pipe",
+          stdout: "pipe",
+        }),
       catch: (err) => new CloudflareTunnelSpawnError({ cause: err }),
     })
 
     yield* Effect.addFinalizer(() =>
       Effect.sync(() => {
         proc.kill()
-      })
+      }),
     )
 
     yield* Effect.logInfo(
@@ -68,48 +60,39 @@ export const start = (opts: {
       ),
       Stream.decodeText("utf-8"),
       Stream.splitLines,
-      opts.cleanLogs ?? true
-        ? Stream.map(v =>
-          v.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s\w+\s/, "")
-        )
+      (opts.cleanLogs ?? true)
+        ? Stream.map((v) => v.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s\w+\s/, ""))
         : identity,
-      logPrefix
-        ? Stream.map(v => logPrefix + v)
-        : identity,
-      Stream.runForEach(v =>
-        Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)
-      ),
+      logPrefix ? Stream.map((v) => logPrefix + v) : identity,
+      Stream.runForEach((v) => Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)),
     )
   })
 
 export const layer = () =>
-  Layer.scopedDiscard(Effect.gen(function*() {
-    const tunnelName = yield* pipe(
-      Config.string("CLOUDFLARE_TUNNEL_NAME"),
-      Config.option,
-      Effect.andThen(Option.getOrUndefined),
-    )
-    const tunnelUrl = yield* pipe(
-      Config.string("CLOUDFLARE_TUNNEL_URL"),
-      Config.option,
-      Effect.andThen(Option.getOrUndefined),
-    )
+  Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const tunnelName = yield* pipe(
+        Config.string("CLOUDFLARE_TUNNEL_NAME"),
+        Config.option,
+        Effect.andThen(Option.getOrUndefined),
+      )
+      const tunnelUrl = yield* pipe(
+        Config.string("CLOUDFLARE_TUNNEL_URL"),
+        Config.option,
+        Effect.andThen(Option.getOrUndefined),
+      )
 
-    if (!tunnelName) {
-      yield* Effect.logWarning("CLOUDFLARE_TUNNEL_NAME not provided. Skipping.")
+      if (!tunnelName) {
+        yield* Effect.logWarning("CLOUDFLARE_TUNNEL_NAME not provided. Skipping.")
 
-      return
-    }
+        return
+      }
 
-    yield* Effect
-      .forkScoped(
+      yield* Effect.forkScoped(
         start({
           tunnelName,
           tunnelUrl,
-        }).pipe(
-          Effect.catchAll(err =>
-            Effect.logError("Cloudflare tunnel failed", err)
-          ),
-        ),
+        }).pipe(Effect.catchAll((err) => Effect.logError("Cloudflare tunnel failed", err))),
       )
-  }))
+    }),
+  )

package/src/x/datastar/Datastar.ts

@@ -1,4 +1,4 @@
-import * as HyperNode from "../../hyper/HyperNode.ts"
+import type * as HyperNode from "../../hyper/HyperNode.ts"
 
 export const HyperHooks = {
   onNode,
@@ -49,18 +49,11 @@ function onNode(node: HyperNode.HyperNode) {
 
   // Handle dynamic attributes with suffixes
   for (const [key, value] of Object.entries(node.props)) {
-    if (
-      key.startsWith("data-signals-")
-      && typeof value === "object"
-      && value !== null
-    ) {
+    if (key.startsWith("data-signals-") && typeof value === "object" && value !== null) {
       node.props[key] = JSON.stringify(value)
     }
 
-    if (
-      key.startsWith("data-on-")
-      && typeof value === "function"
-    ) {
+    if (key.startsWith("data-on-") && typeof value === "function") {
       // @ts-ignore
       node.props[key] = `(${value.toString()})()`
     }

package/src/x/datastar/index.ts

@@ -1,4 +1,2 @@
 export * as Datastar from "./Datastar.ts"
-export {
-  HyperHooks,
-} from "./Datastar.ts"
+export { HyperHooks } from "./Datastar.ts"

package/src/x/datastar/jsx-datastar.d.ts

@@ -2,10 +2,7 @@
 type DatastarSignalsObject = Record<string, any>
 type DatastarClassObject = Record<string, boolean | string>
 type DatastarAttrObject = Record<string, string | boolean | number>
-type DatastarStyleObject = Record<
-  string,
-  string | number | boolean | null | undefined
->
+type DatastarStyleObject = Record<string, string | number | boolean | null | undefined>
 
 /**
  * Datastar attributes for reactive web applications

package/src/x/tailwind/TailwindPlugin.ts

@@ -46,12 +46,12 @@ export const make = (opts?: {
 
       const prepopulateCandidates = opts?.scanPath
         ? async () => {
-          const candidates = await scanFiles(opts.scanPath!)
+            const candidates = await scanFiles(opts.scanPath!)
 
-          scannedCandidates.clear()
+            scannedCandidates.clear()
 
-          candidates.forEach(candidate => scannedCandidates.add(candidate))
-        }
+            candidates.forEach((candidate) => scannedCandidates.add(candidate))
+          }
         : null
 
       // Track import relationships when dynamically scanning
@@ -60,122 +60,129 @@ export const make = (opts?: {
       // Better to pass scanPath explicitly.
       // @see https://github.com/oven-sh/bun/issues/20877
       if (!prepopulateCandidates) {
-        builder.onResolve({
-          filter: /.*/,
-        }, (args) => {
-          const fullPath = Bun.resolveSync(args.path, args.resolveDir)
-          const importer = args.importer
-
-          if (fullPath.includes("/node_modules/")) {
-            return undefined
-          }
-
-          /**
-           * Register every visited module.
-           */
+        builder.onResolve(
           {
-            if (!importAncestors.has(fullPath)) {
-              importAncestors.set(fullPath, new Set())
+            filter: /.*/,
+          },
+          (args) => {
+            const fullPath = Bun.resolveSync(args.path, args.resolveDir)
+            const importer = args.importer
+
+            if (fullPath.includes("/node_modules/")) {
+              return undefined
             }
 
-            if (!importDescendants.has(fullPath)) {
-              importDescendants.set(fullPath, new Set())
+            /**
+             * Register every visited module.
+             */
+            {
+              if (!importAncestors.has(fullPath)) {
+                importAncestors.set(fullPath, new Set())
+              }
+
+              if (!importDescendants.has(fullPath)) {
+                importDescendants.set(fullPath, new Set())
+              }
+
+              if (!importAncestors.has(importer)) {
+                importAncestors.set(args.importer, new Set())
+              }
+
+              if (!importDescendants.has(importer)) {
+                importDescendants.set(importer, new Set())
+              }
             }
 
-            if (!importAncestors.has(importer)) {
-              importAncestors.set(args.importer, new Set())
-            }
+            importAncestors.get(fullPath)!.add(importer)
+            importDescendants.get(importer)!.add(fullPath)
 
-            if (!importDescendants.has(importer)) {
-              importDescendants.set(importer, new Set())
-            }
-          }
-
-          importAncestors.get(fullPath)!.add(importer)
-          importDescendants.get(importer)!.add(fullPath)
-
-          return undefined
-        })
+            return undefined
+          },
+        )
       }
 
       /**
        * Scan for class name candidates in component files.
        */
-      builder.onLoad({
-        filter: filesPattern,
-      }, async (args) => {
-        const contents = await Bun.file(args.path).text()
-        const classNames = extractClassNames(contents)
-
-        if (classNames.size > 0) {
-          classNameCandidates.set(args.path, classNames)
-        }
+      builder.onLoad(
+        {
+          filter: filesPattern,
+        },
+        async (args) => {
+          const contents = await Bun.file(args.path).text()
+          const classNames = extractClassNames(contents)
+
+          if (classNames.size > 0) {
+            classNameCandidates.set(args.path, classNames)
+          }
 
-        return undefined
-      })
+          return undefined
+        },
+      )
 
       /**
        * Compile tailwind entrypoints.
        */
-      builder.onLoad({
-        filter: cssPattern,
-      }, async (args) => {
-        const source = await Bun.file(args.path).text()
-
-        if (!hasCssImport(source, "tailwindcss")) {
-          return undefined
-        }
+      builder.onLoad(
+        {
+          filter: cssPattern,
+        },
+        async (args) => {
+          const source = await Bun.file(args.path).text()
+
+          if (!hasCssImport(source, "tailwindcss")) {
+            return undefined
+          }
 
-        const compiler = await Tailwind.compile(source, {
-          base: NPath.dirname(args.path),
-          onDependency: (path) => {},
-        })
+          const compiler = await Tailwind.compile(source, {
+            base: NPath.dirname(args.path),
+            onDependency: (path) => {},
+          })
 
-        await prepopulateCandidates?.()
+          await prepopulateCandidates?.()
 
-        // wait for other files to be loaded so we can collect class name candidates
-        await args.defer()
+          // wait for other files to be loaded so we can collect class name candidates
+          await args.defer()
 
-        const candidates = new Set<string>(scannedCandidates)
+          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) ?? []),
-          ]
-          const visitedModules = new Set<string>()
+          // 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) ?? []),
+            ]
+            const visitedModules = new Set<string>()
 
-          while (pendingModules.length > 0) {
-            const currentPath = pendingModules.shift()!
+            while (pendingModules.length > 0) {
+              const currentPath = pendingModules.shift()!
 
-            if (visitedModules.has(currentPath)) {
-              continue
-            }
+              if (visitedModules.has(currentPath)) {
+                continue
+              }
 
-            const moduleImports = importDescendants.get(currentPath)
+              const moduleImports = importDescendants.get(currentPath)
 
-            moduleImports?.forEach(moduleImport => {
-              const moduleCandidates = classNameCandidates.get(moduleImport)
+              moduleImports?.forEach((moduleImport) => {
+                const moduleCandidates = classNameCandidates.get(moduleImport)
 
-              moduleCandidates?.forEach(candidate => candidates.add(candidate))
+                moduleCandidates?.forEach((candidate) => candidates.add(candidate))
 
-              pendingModules.push(moduleImport)
-            })
+                pendingModules.push(moduleImport)
+              })
 
-            visitedModules.add(currentPath)
+              visitedModules.add(currentPath)
+            }
           }
-        }
 
-        const contents = compiler.build([
-          ...candidates,
-        ])
+          const contents = compiler.build([...candidates])
 
-        return {
-          contents,
-          loader: "css",
-        }
-      })
+          return {
+            contents,
+            loader: "css",
+          }
+        },
+      )
     },
   }
 }
@@ -186,19 +193,19 @@ const TEMPLATE_EXPRESSION_REGEX = /\$\{[^}]*\}/g
 const TAILWIND_CLASS_REGEX = /^[a-zA-Z0-9_:-]+(\[[^\]]*\])?$/
 const CLASS_NAME_PATTERNS = [
   // HTML class attributes with double quotes: <div class="bg-blue-500 text-white">
-  "<[^>]*?\\sclass\\s*=\\s*\"([^\"]+)\"",
+  '<[^>]*?\\sclass\\s*=\\s*"([^"]+)"',
 
   // HTML class attributes with single quotes: <div class='bg-blue-500 text-white'>
   "<[^>]*?\\sclass\\s*=\\s*'([^']+)'",
 
   // JSX className attributes with double quotes: <div className="bg-blue-500 text-white">
-  "<[^>]*?\\sclassName\\s*=\\s*\"([^\"]+)\"",
+  '<[^>]*?\\sclassName\\s*=\\s*"([^"]+)"',
 
   // JSX className attributes with single quotes: <div className='bg-blue-500 text-white'>
   "<[^>]*?\\sclassName\\s*=\\s*'([^']+)'",
 
   // JSX className with braces and double quotes: <div className={"bg-blue-500 text-white"}>
-  "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*\"([^\"]+)\"\\s*\\}",
+  '<[^>]*?\\sclassName\\s*=\\s*\\{\\s*"([^"]+)"\\s*\\}',
 
   // JSX className with braces and single quotes: <div className={'bg-blue-500 text-white'}>
   "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
@@ -210,19 +217,19 @@ const CLASS_NAME_PATTERNS = [
   "<[^>]*?\\sclass\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
 
   // HTML class at start of tag with double quotes: <div class="bg-blue-500">
-  "<\\w+\\s+class\\s*=\\s*\"([^\"]+)\"",
+  '<\\w+\\s+class\\s*=\\s*"([^"]+)"',
 
   // HTML class at start of tag with single quotes: <div class='bg-blue-500'>
   "<\\w+\\s+class\\s*=\\s*'([^']+)'",
 
   // JSX className at start of tag with double quotes: <div className="bg-blue-500">
-  "<\\w+\\s+className\\s*=\\s*\"([^\"]+)\"",
+  '<\\w+\\s+className\\s*=\\s*"([^"]+)"',
 
   // JSX className at start of tag with single quotes: <div className='bg-blue-500'>
   "<\\w+\\s+className\\s*=\\s*'([^']+)'",
 
   // JSX className at start with braces and double quotes: <div className={"bg-blue-500"}>
-  "<\\w+\\s+className\\s*=\\s*\\{\\s*\"([^\"]+)\"\\s*\\}",
+  '<\\w+\\s+className\\s*=\\s*\\{\\s*"([^"]+)"\\s*\\}',
 
   // JSX className at start with braces and single quotes: <div className={'bg-blue-500'}>
   "<\\w+\\s+className\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
@@ -235,7 +242,7 @@ const CLASS_NAME_PATTERNS = [
 ]
 
 const CLASS_NAME_REGEX = new RegExp(
-  CLASS_NAME_PATTERNS.map(pattern => `(?:${pattern})`).join("|"),
+  CLASS_NAME_PATTERNS.map((pattern) => `(?:${pattern})`).join("|"),
   "g",
 )
 
@@ -244,8 +251,7 @@ function hasCssImport(css: string, specifier?: string): boolean {
 
   if (!importPath) return false
 
-  return specifier === undefined
-    || importPath.includes(specifier)
+  return specifier === undefined || importPath.includes(specifier)
 }
 
 export function extractClassNames(source: string): Set<string> {
@@ -270,17 +276,20 @@ export function extractClassNames(source: string): Set<string> {
       const staticParts = classString.split(TEMPLATE_EXPRESSION_REGEX)
 
       for (const part of staticParts) {
-        const names = part.trim().split(/\s+/).filter(name => {
-          if (name.length === 0) return false
-          if (name.endsWith("-") || name.startsWith("-")) return false
-          return TAILWIND_CLASS_REGEX.test(name)
-        })
-        names.forEach(name => candidates.add(name))
+        const names = part
+          .trim()
+          .split(/\s+/)
+          .filter((name) => {
+            if (name.length === 0) return false
+            if (name.endsWith("-") || name.startsWith("-")) return false
+            return TAILWIND_CLASS_REGEX.test(name)
+          })
+        names.forEach((name) => candidates.add(name))
       }
     } else {
       // Simple case: regular class string without expressions
-      const names = classString.split(/\s+/).filter(name => name.length > 0)
-      names.forEach(name => candidates.add(name))
+      const names = classString.split(/\s+/).filter((name) => name.length > 0)
+      names.forEach((name) => candidates.add(name))
     }
   }
 
@@ -291,12 +300,10 @@ async function scanFiles(dir: string): Promise<Set<string>> {
   const candidates = new Set<string>()
   const glob = new Bun.Glob("**/*.{js,jsx,ts,tsx,html,vue,svelte,astro}")
 
-  for await (
-    const filePath of glob.scan({
-      cwd: dir,
-      absolute: true,
-    })
-  ) {
+  for await (const filePath of glob.scan({
+    cwd: dir,
+    absolute: true,
+  })) {
     if (filePath.includes("/node_modules/")) {
       continue
     }

package/src/x/tailwind/compile.ts

@@ -1,25 +1,14 @@
 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 { 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 { Features, Polyfills }
 
-export type Resolver = (
-  id: string,
-  base: string,
-) => Promise<string | false | undefined>
+export type Resolver = (id: string, base: string) => Promise<string | false | undefined>
 
 export interface CompileOptions {
   base: string
@@ -48,12 +37,7 @@ function createCompileOptions({
       return loadModule(id, base, onDependency, customJsResolver)
     },
     async loadStylesheet(id: string, sheetBase: string) {
-      let sheet = await loadStylesheet(
-        id,
-        sheetBase,
-        onDependency,
-        customCssResolver,
-      )
+      let sheet = await loadStylesheet(id, sheetBase, onDependency, customCssResolver)
 
       return sheet
     },
@@ -66,7 +50,7 @@ async function ensureSourceDetectionRootExists(compiler: {
   // Verify if the `source(…)` path exists (until the glob pattern starts)
   if (compiler.root && compiler.root !== "none") {
     let globSymbols = /[*{]/
-    let basePath: string[] = []
+    let basePath: Array<string> = []
     for (let segment of compiler.root.pattern.split("/")) {
       if (globSymbols.test(segment)) {
         break
@@ -89,7 +73,7 @@ async function ensureSourceDetectionRootExists(compiler: {
 }
 
 export async function compileAst(
-  ast: AstNode[],
+  ast: Array<AstNode>,
   options: CompileOptions,
 ): ReturnType<typeof _compileAst> {
   let compiler = await _compileAst(ast, createCompileOptions(options))
@@ -97,10 +81,7 @@ export async function compileAst(
   return compiler
 }
 
-export async function compile(
-  css: string,
-  options: CompileOptions,
-): ReturnType<typeof _compile> {
+export async function compile(css: string, options: CompileOptions): ReturnType<typeof _compile> {
   let compiler = await _compile(css, createCompileOptions(options))
   await ensureSourceDetectionRootExists(compiler)
   return compiler
@@ -131,9 +112,7 @@ export async function loadModule(
     throw new Error(`Could not resolve '${id}' from '${base}'`)
   }
 
-  let [module] = await Promise.all([
-    importModule(pathToFileURL(resolvedPath).href + "?id=" + Date.now()),
-  ])
+  let module = await importModule(pathToFileURL(resolvedPath).href + "?id=" + Date.now())
 
   return {
     path: resolvedPath,
@@ -230,9 +209,7 @@ async function resolveJsId(
     }
   }
 
-  return runResolver(esmResolver, id, base).catch(() =>
-    runResolver(cjsResolver, id, base)
-  )
+  return runResolver(esmResolver, id, base).catch(() => runResolver(cjsResolver, id, base))
 }
 
 function runResolver(
@@ -244,6 +221,6 @@ function runResolver(
     resolver.resolve({}, base, id, {}, (err, result) => {
       if (err) return reject(err)
       resolve(result)
-    })
+    }),
   )
 }

package/src/x/tailwind/plugin.ts

@@ -8,8 +8,8 @@ const packageJson = await NodeUtils.findClosestPackageJson(process.cwd())
 const scanPath = dirParam
   ? NPath.resolve(process.cwd(), dirParam)
   : packageJson
-  ? NPath.dirname(packageJson)
-  : process.cwd()
+    ? NPath.dirname(packageJson)
+    : process.cwd()
 
 // Export as default to be used in bunfig.toml
 export default TailwindPlugin.make({