effect-start 0.25.0 → 0.27.0

package/dist/testing/utils.js

@@ -1,61 +0,0 @@
-import * as Array from "effect/Array"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Logger from "effect/Logger"
-
-/**
- * Creates a scoped Effects and runs is asynchronously.
- * Useful for testing.
- */
-export const effectFn =
-  (layer) =>
-  (
-    f,
-  ) =>
-    Function.pipe(
-      Effect.gen(f),
-      Effect.scoped,
-      Effect.provide(Logger.pretty),
-      Effect.provide(layer ?? Layer.empty),
-      // @ts-expect-error will have to figure out how to clear deps
-      Effect.runPromise,
-      (v) => v.then(() => {}, clearStackTraces),
-    )
-
-/*
- * When effect fails, instead of throwing FiberFailure,
- * throw a plain Error with the strack trace and hides
- * effect internals.
- * Otherwise, at least on Bun, the strack trace is repeated,
- * with some junks in between taking half of the screen.
- *
- * Direct children that starts with a dot are excluded because
- * some tools, like effect-start, use it to generate temporary
- * files that are then loaded into a runtime.
- */
-const clearStackTraces = (err) => {
-  const ExternalStackTraceLineRegexp = /\(.*\/node_modules\/[^.]/
-
-  const message =
-    err instanceof Error
-      ? err.message
-      : typeof err === "object" && err !== null && "message" in err
-        ? String(err.message)
-        : String(err)
-  const stack =
-    err instanceof Error
-      ? (err.stack ?? "")
-      : typeof err === "object" && err !== null && "stack" in err
-        ? String(err.stack)
-        : ""
-
-  const newErr = new Error(message)
-  newErr.stack = Function.pipe(
-    stack.split("\n"),
-    Array.takeWhile((s) => !ExternalStackTraceLineRegexp.test(s)),
-    Array.join("\n"),
-  )
-
-  throw newErr
-}

package/dist/x/cloudflare/CloudflareTunnel.js

@@ -1,63 +0,0 @@
-import * as System from "../../System.js"
-import { Config, Effect, Layer, LogLevel, Option, pipe, Stream, String } from "effect"
-
-export const start = (opts) =>
-  Effect.gen(function* () {
-    const command = opts.command ?? "cloudflared"
-    yield* System.which(command)
-    const logPrefix = String.isString(opts.logPrefix) ? opts.logPrefix : "CloudflareTunnel: "
-    const args = [
-      "tunnel",
-      "run",
-      opts.tunnelUrl ? ["--url", opts.tunnelUrl] : [],
-      opts.tunnelName,
-    ].flatMap((v) => v)
-
-    const proc = yield* System.spawn(command, args)
-
-    yield* Effect.logInfo(
-      `Cloudflare tunnel started name=${opts.tunnelName} pid=${proc.pid} tunnelUrl=${
-        opts.tunnelUrl ?? "<empty>"
-      }`,
-    )
-
-    yield* pipe(
-      Stream.merge(proc.stdout, proc.stderr),
-      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/, ""))
-        : (s) => s,
-      logPrefix ? Stream.map((v) => logPrefix + v) : (s) => s,
-      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),
-      )
-
-      if (!tunnelName) {
-        yield* Effect.logWarning("CLOUDFLARE_TUNNEL_NAME not provided. Skipping.")
-
-        return
-      }
-
-      yield* Effect.forkScoped(
-        start({
-          tunnelName,
-          tunnelUrl,
-        }).pipe(Effect.catchAll((err) => Effect.logError("Cloudflare tunnel failed", err))),
-      )
-    }),
-  )

package/dist/x/cloudflare/index.js

@@ -1 +0,0 @@
-export * as CloudflareTunnel from "./CloudflareTunnel.js"

package/dist/x/tailscale/TailscaleTunnel.js

@@ -1,94 +0,0 @@
-import * as PlatformError from "../../PlatformError.js"
-import * as StartApp from "../../StartApp.js"
-import * as System from "../../System.js"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as LogLevel from "effect/LogLevel"
-import * as Stream from "effect/Stream"
-import * as Function from "effect/Function"
-
-const getStatus = (command) =>
-  Effect.gen(function* () {
-    const proc = yield* System.spawn(command, ["status", "--json"])
-    const exitCode = yield* proc.exitCode
-
-    if (exitCode !== 0) {
-      const stderr = yield* proc.stderr.pipe(Stream.decodeText("utf-8"), Stream.mkString)
-      return yield* new PlatformError.SystemError({
-        reason: "Unknown",
-        module: "TailscaleTunnel",
-        method: "getStatus",
-        description: `tailscale status exited with code ${exitCode}: ${stderr}`,
-      })
-    }
-
-    const stdout = yield* proc.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString)
-    const json = JSON.parse(stdout)
-
-    if (json.BackendState !== "Running") {
-      return yield* new PlatformError.SystemError({
-        reason: "Unknown",
-        module: "TailscaleTunnel",
-        method: "getStatus",
-        description: `tailscale is in state "${json.BackendState}", expected "Running"`,
-      })
-    }
-
-    return json
-  })
-
-const serve = (opts) =>
-  Effect.gen(function* () {
-    const logPrefix = opts.logPrefix ?? "TailscaleTunnel: "
-    const args = [opts.public ? "funnel" : "serve", String(opts.port)]
-
-    const proc = yield* System.spawn(opts.command, args)
-
-    yield* Function.pipe(
-      Stream.merge(proc.stdout, proc.stderr),
-      Stream.decodeText("utf-8"),
-      Stream.splitLines,
-      logPrefix ? Stream.map((v) => logPrefix + v) : (s) => s,
-      Stream.runForEach((v) => Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)),
-    )
-  })
-
-export const start = (opts) =>
-  Effect.gen(function* () {
-    const command = opts.command ?? "tailscale"
-    yield* System.which(command)
-    const status = yield* getStatus(command)
-    const dnsName = status.Self?.DNSName?.replace(/\.$/, "")
-    yield* serve({ ...opts, command, dnsName })
-  })
-
-export const layer = (opts) =>
-  Layer.scopedDiscard(
-    Effect.gen(function* () {
-      yield* Effect.forkScoped(
-        Effect.gen(function* () {
-          const app = yield* StartApp.StartApp
-          const { server } = yield* Deferred.await(app.server)
-          const port = server.port
-          const command = "tailscale"
-
-          yield* System.which(command)
-          const status = yield* getStatus(command)
-          const dnsName = status.Self?.DNSName?.replace(/\.$/, "")
-
-          const serveUrl = dnsName ? `https://${dnsName}` : undefined
-          yield* Effect.logInfo(
-            `Tailscale ${opts?.public ? "funnel" : "serve"}${serveUrl ? ` url=${serveUrl}` : ""}`,
-          )
-
-          yield* serve({
-            command,
-            port,
-            dnsName,
-            public: opts?.public,
-          })
-        }).pipe(Effect.tapError((e) => Effect.logError(`Tailscale: ${e.description}`))),
-      )
-    }),
-  )

package/dist/x/tailscale/index.js

@@ -1 +0,0 @@
-export * as TailscaleTunnel from "./TailscaleTunnel.js"

package/dist/x/tailwind/TailwindPlugin.js

@@ -1,294 +0,0 @@
-import * as NPath from "node:path"
-import * as Tailwind from "./compile.js"
-
-export const make = (opts) => {
-  const {
-    filesPattern = /\.(jsx?|tsx?|html|svelte|vue|astro)$/,
-    cssPattern = /\.css$/,
-    target = "browser",
-  } = opts ?? {}
-
-  return {
-    name: "Tailwind.css plugin",
-    target,
-    async setup(builder) {
-      const scannedCandidates = new Set()
-      // (file) -> (class names)
-      const classNameCandidates = new Map()
-      // (importer path) -> (imported paths)
-      const importAncestors = new Map()
-      // (imported path) -> (importer paths)
-      const importDescendants = new Map()
-
-      const prepopulateCandidates = opts?.scanPath
-        ? async () => {
-            const candidates = await scanFiles(opts.scanPath)
-
-            scannedCandidates.clear()
-
-            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) => {
-            const fullPath = Bun.resolveSync(args.path, args.resolveDir)
-            const importer = args.importer
-
-            if (fullPath.includes("/node_modules/")) {
-              return undefined
-            }
-
-            /**
-             * 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())
-              }
-            }
-
-            importAncestors.get(fullPath).add(importer)
-            importDescendants.get(importer).add(fullPath)
-
-            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)
-          }
-
-          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
-          }
-
-          const compiler = await Tailwind.compile(source, {
-            base: NPath.dirname(args.path),
-            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(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()
-
-            while (pendingModules.length > 0) {
-              const currentPath = pendingModules.shift()
-
-              if (visitedModules.has(currentPath)) {
-                continue
-              }
-
-              const moduleImports = importDescendants.get(currentPath)
-
-              moduleImports?.forEach((moduleImport) => {
-                const moduleCandidates = classNameCandidates.get(moduleImport)
-
-                moduleCandidates?.forEach((candidate) => candidates.add(candidate))
-
-                pendingModules.push(moduleImport)
-              })
-
-              visitedModules.add(currentPath)
-            }
-          }
-
-          const contents = compiler.build([...candidates])
-
-          return {
-            contents,
-            loader: "css",
-          }
-        },
-      )
-    },
-  }
-}
-
-const CSS_IMPORT_REGEX = /@import\s+(?:url\()?["']?([^"')]+)["']?\)?\s*[^;]*;/
-const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g
-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*"([^"]+)"',
-
-  // 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*"([^"]+)"',
-
-  // 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*\\}',
-
-  // JSX className with braces and single quotes: <div className={'bg-blue-500 text-white'}>
-  "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
-
-  // JSX className with template literals: <div className={`bg-blue-500 ${variable}`}>
-  "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
-
-  // HTML class with template literals: <div class={`bg-blue-500 ${variable}`}>
-  "<[^>]*?\\sclass\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
-
-  // HTML class at start of tag with double quotes: <div class="bg-blue-500">
-  '<\\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*"([^"]+)"',
-
-  // 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*\\}',
-
-  // JSX className at start with braces and single quotes: <div className={'bg-blue-500'}>
-  "<\\w+\\s+className\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
-
-  // JSX className at start with template literals: <div className={`bg-blue-500 ${variable}`}>
-  "<\\w+\\s+className\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
-
-  // HTML class at start with template literals: <div class={`bg-blue-500 ${variable}`}>
-  "<\\w+\\s+class\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
-]
-
-const CLASS_NAME_REGEX = new RegExp(
-  CLASS_NAME_PATTERNS.map((pattern) => `(?:${pattern})`).join("|"),
-  "g",
-)
-
-function hasCssImport(css, specifier) {
-  const [, importPath] = css.match(CSS_IMPORT_REGEX) ?? []
-
-  if (!importPath) return false
-
-  return specifier === undefined || importPath.includes(specifier)
-}
-
-export function extractClassNames(source) {
-  const candidates = new Set()
-  const sourceWithoutComments = source.replace(HTML_COMMENT_REGEX, "")
-
-  for (const match of sourceWithoutComments.matchAll(CLASS_NAME_REGEX)) {
-    // Find the first non-undefined capture group (skip match[0] which is full match)
-    let classString = ""
-    for (let i = 1; i < match.length; i++) {
-      if (match[i] !== undefined) {
-        classString = match[i]
-        break
-      }
-    }
-
-    if (!classString) {
-      continue
-    }
-
-    if (classString.includes("${")) {
-      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))
-      }
-    } else {
-      // Simple case: regular class string without expressions
-      const names = classString.split(/\s+/).filter((name) => name.length > 0)
-      names.forEach((name) => candidates.add(name))
-    }
-  }
-
-  return candidates
-}
-
-async function scanFiles(dir) {
-  const candidates = new Set()
-  const glob = new Bun.Glob("**/*.{js,jsx,ts,tsx,html,vue,svelte,astro}")
-
-  for await (const filePath of glob.scan({
-    cwd: dir,
-    absolute: true,
-  })) {
-    if (filePath.includes("/node_modules/")) {
-      continue
-    }
-
-    const contents = await Bun.file(filePath).text()
-    const classNames = extractClassNames(contents)
-
-    classNames.forEach((className) => candidates.add(className))
-  }
-
-  return candidates
-}