effect-start 0.23.0 → 0.25.0

package/dist/x/tailwind/compile.js

@@ -1,154 +1,210 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import fsPromises from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { compile as _compile, compileAst as _compileAst } from "tailwindcss";
-import * as BunEnhancedResolve from "../../bun/_BunEnhancedResolve";
-function createCompileOptions({ base, from, polyfills, onDependency, customCssResolver, customJsResolver, }) {
-    return {
-        base,
-        polyfills,
-        from,
-        async loadModule(id, base) {
-            return loadModule(id, base, onDependency, customJsResolver);
-        },
-        async loadStylesheet(id, sheetBase) {
-            let sheet = await loadStylesheet(id, sheetBase, onDependency, customCssResolver);
-            return sheet;
-        },
-    };
+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"
+
+export { Features, Polyfills }
+
+function createCompileOptions({
+  base,
+  from,
+  polyfills,
+  onDependency,
+
+  customCssResolver,
+  customJsResolver,
+}) {
+  return {
+    base,
+    polyfills,
+    from,
+    async loadModule(id, base) {
+      return loadModule(id, base, onDependency, customJsResolver)
+    },
+    async loadStylesheet(id, sheetBase) {
+      let sheet = await loadStylesheet(id, sheetBase, onDependency, customCssResolver)
+
+      return sheet
+    },
+  }
 }
+
 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 = [];
-        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.`);
-        }
+  // Verify if the `source(…)` path exists (until the glob pattern starts)
+  if (compiler.root && compiler.root !== "none") {
+    let globSymbols = /[*{]/
+    let basePath = []
+    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, options) {
-    let compiler = await _compileAst(ast, createCompileOptions(options));
-    await ensureSourceDetectionRootExists(compiler);
-    return compiler;
+
+export async function compileAst(
+  ast,
+  options,
+) {
+  let compiler = await _compileAst(ast, createCompileOptions(options))
+  await ensureSourceDetectionRootExists(compiler)
+  return compiler
 }
+
 export async function compile(css, options) {
-    let compiler = await _compile(css, createCompileOptions(options));
-    await ensureSourceDetectionRootExists(compiler);
-    return compiler;
+  let compiler = await _compile(css, createCompileOptions(options))
+  await ensureSourceDetectionRootExists(compiler)
+  return compiler
 }
-export async function loadModule(id, base, _onDependency, customJsResolver) {
-    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);
+
+export async function loadModule(
+  id,
+  base,
+  _onDependency,
+  customJsResolver,
+) {
+  if (id[0] !== ".") {
+    let resolvedPath = await resolveJsId(id, base, customJsResolver)
     if (!resolvedPath) {
-        throw new Error(`Could not resolve '${id}' from '${base}'`);
+      throw new Error(`Could not resolve '${id}' from '${base}'`)
     }
-    let module = await importModule(pathToFileURL(resolvedPath).href + "?id=" + Date.now());
+
+    let module = await importModule(pathToFileURL(resolvedPath).href)
     return {
-        path: resolvedPath,
-        base: path.dirname(resolvedPath),
-        module: module.default ?? module,
-    };
+      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 importModule(pathToFileURL(resolvedPath).href + "?id=" + Date.now())
+
+  return {
+    path: resolvedPath,
+    base: path.dirname(resolvedPath),
+    module: module.default ?? module,
+  }
 }
-async function loadStylesheet(id, base, onDependency, cssResolver) {
-    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 loadStylesheet(
+  id,
+  base,
+  onDependency,
+  cssResolver,
+) {
+  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) {
-    if (typeof globalThis.__tw_load === "function") {
-        let module = await globalThis.__tw_load(path);
-        if (module) {
-            return module;
-        }
+  if (typeof globalThis.__tw_load === "function") {
+    let module = await globalThis.__tw_load(path)
+    if (module) {
+      return module
     }
-    return await import(__rewriteRelativeImportExtension(path));
+  }
+
+  return await import(path)
 }
+
 const cssResolver = BunEnhancedResolve.ResolverFactory.createResolver({
-    extensions: [".css"],
-    mainFields: ["style"],
-    conditionNames: ["style"],
-});
-async function resolveCssId(id, base, customCssResolver) {
-    if (typeof globalThis.__tw_resolve === "function") {
-        let resolved = globalThis.__tw_resolve(id, base);
-        if (resolved) {
-            return Promise.resolve(resolved);
-        }
+  extensions: [".css"],
+  mainFields: ["style"],
+  conditionNames: ["style"],
+})
+async function resolveCssId(
+  id,
+  base,
+  customCssResolver,
+) {
+  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;
-        }
+  }
+
+  if (customCssResolver) {
+    let customResolution = await customCssResolver(id, base)
+    if (customResolution) {
+      return customResolution
     }
-    return runResolver(cssResolver, id, base);
+  }
+
+  return runResolver(cssResolver, id, base)
 }
+
 const esmResolver = BunEnhancedResolve.ResolverFactory.createResolver({
-    extensions: [".js", ".json", ".node", ".ts"],
-    conditionNames: ["node", "import"],
-    mainFields: ["module", "main"],
-});
+  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, base, customJsResolver) {
-    if (typeof globalThis.__tw_resolve === "function") {
-        let resolved = globalThis.__tw_resolve(id, base);
-        if (resolved) {
-            return Promise.resolve(resolved);
-        }
+  extensions: [".js", ".json", ".node", ".ts"],
+  conditionNames: ["node", "require"],
+  mainFields: ["main"],
+})
+
+async function resolveJsId(
+  id,
+  base,
+  customJsResolver,
+) {
+  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;
-        }
+  }
+
+  if (customJsResolver) {
+    let customResolution = await customJsResolver(id, base)
+    if (customResolution) {
+      return customResolution
     }
-    return runResolver(esmResolver, id, base).catch(() => runResolver(cjsResolver, id, base));
+  }
+
+  return runResolver(esmResolver, id, base).catch(() => runResolver(cjsResolver, id, base))
 }
-function runResolver(resolver, id, base) {
-    return new Promise((resolve, reject) => resolver.resolve({}, base, id, {}, (err, result) => {
-        if (err)
-            return reject(err);
-        resolve(result);
-    }));
+
+function runResolver(
+  resolver,
+  id,
+  base,
+) {
+  return new Promise((resolve, reject) =>
+    resolver.resolve({}, base, id, {}, (err, result) => {
+      if (err) return reject(err)
+      resolve(result)
+    }),
+  )
 }

package/dist/x/tailwind/plugin.js

@@ -1,15 +1,17 @@
-import * as NPath from "node:path";
-import * as NodeUtils from "../../node/NodeUtils.js";
-import * as TailwindPlugin from "./TailwindPlugin.js";
+import * as NPath from "node:path"
+import * as NodeUtils from "../../node/NodeUtils.js"
+import * as TailwindPlugin from "./TailwindPlugin.js"
+
 // Append `?dir=` to module identifier to pass custom directory to scan
-const dirParam = URL.parse(import.meta.url)?.searchParams.get("dir");
-const packageJson = await NodeUtils.findClosestPackageJson(process.cwd());
+const dirParam = URL.parse(import.meta.url)?.searchParams.get("dir")
+const packageJson = await NodeUtils.findClosestPackageJson(process.cwd())
 const scanPath = dirParam
-    ? NPath.resolve(process.cwd(), dirParam)
-    : packageJson
-        ? NPath.dirname(packageJson)
-        : process.cwd();
+  ? NPath.resolve(process.cwd(), dirParam)
+  : packageJson
+    ? NPath.dirname(packageJson)
+    : process.cwd()
+
 // Export as default to be used in bunfig.toml
 export default TailwindPlugin.make({
-    scanPath,
-});
+  scanPath,
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "license": "MIT",
   "files": [
     "src/",

package/src/Development.ts

@@ -104,10 +104,12 @@ export const layerWatch = (opts?: {
   filter?: (event: FileSystem.WatchEvent) => boolean
 }) => Layer.scoped(Development, watch(opts))
 
+export const option = Effect.serviceOption(Development)
+
 export const stream = (): Stream.Stream<DevelopmentEvent> =>
   Stream.unwrap(
     Function.pipe(
-      Effect.serviceOption(Development),
+      option,
       Effect.map(
         Option.match({
           onNone: () => Stream.empty,

package/src/Entity.ts

@@ -325,6 +325,23 @@ export function length(self: Entity): number | undefined {
   return undefined
 }
 
+export function fromResponse(
+  response: Response,
+  request?: Request,
+): Entity<Effect.Effect<Uint8Array, Error, never>, Error> {
+  return make(
+    Effect.tryPromise({
+      try: () => response.arrayBuffer().then((buf) => new Uint8Array(buf)),
+      catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+    }),
+    {
+      headers: Object.fromEntries(response.headers.entries()),
+      status: response.status,
+      url: response.url || request?.url,
+    },
+  )
+}
+
 function mismatch(expected: Schema.Schema.Any, actual: unknown): ParseResult.ParseError {
   return new ParseResult.ParseError({
     issue: new ParseResult.Type(expected.ast, actual),