effect-start 0.17.0 → 0.17.2

package/dist/x/cloudflare/CloudflareTunnel.d.ts

@@ -0,0 +1,13 @@
+import { Effect, Layer, LogLevel } from "effect";
+/**
+ * Starts Cloudflare tunnel using cloudflared cli.
+ */
+export declare const start: (opts: {
+    command?: string;
+    tunnelName: string;
+    tunnelUrl?: string;
+    cleanLogs?: false;
+    logLevel?: LogLevel.LogLevel;
+    logPrefix?: string;
+}) => Effect.Effect<void, import("@effect/platform/Error").PlatformError, import("effect/Scope").Scope | import("@effect/platform/CommandExecutor").CommandExecutor>;
+export declare const layer: () => Layer.Layer<never, import("effect/ConfigError").ConfigError, import("@effect/platform/CommandExecutor").CommandExecutor>;

package/dist/x/cloudflare/CloudflareTunnel.js

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

package/dist/x/cloudflare/index.d.ts

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

package/dist/x/cloudflare/index.js

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

package/dist/x/datastar/Datastar.d.ts

@@ -0,0 +1,6 @@
+import * as HyperNode from "../../hyper/HyperNode.ts";
+export declare const HyperHooks: {
+    readonly onNode: typeof onNode;
+};
+declare function onNode(node: HyperNode.HyperNode): void;
+export {};

package/dist/x/datastar/Datastar.js

@@ -0,0 +1,46 @@
+export const HyperHooks = {
+    onNode,
+};
+function onNode(node) {
+    const { "data-signals": dataSignals, "data-class": dataClass, "data-attr": dataAttr, "data-style": dataStyle, "data-show": dataShow, "data-ignore": dataIgnore, "data-ignore-morph": dataIgnoreMorph, } = node.props;
+    if (typeof dataSignals === "object" && dataSignals !== null) {
+        node.props["data-signals"] = JSON.stringify(dataSignals);
+    }
+    if (typeof dataClass === "function") {
+        node.props["data-class"] = `(${dataClass.toString()})()`;
+    }
+    else if (typeof dataClass === "object" && dataClass !== null) {
+        node.props["data-class"] = JSON.stringify(dataClass);
+    }
+    if (typeof dataAttr === "object" && dataAttr !== null) {
+        node.props["data-attr"] = JSON.stringify(dataAttr);
+    }
+    if (typeof dataStyle === "function") {
+        node.props["data-style"] = `(${dataStyle.toString()})()`;
+    }
+    else if (typeof dataStyle === "object" && dataStyle !== null) {
+        node.props["data-style"] = JSON.stringify(dataStyle);
+    }
+    if (typeof dataShow === "boolean") {
+        node.props["data-show"] = dataShow.toString();
+    }
+    if (dataIgnore !== true && dataIgnore !== undefined) {
+        delete node.props["data-ignore"];
+    }
+    if (dataIgnoreMorph !== true && dataIgnoreMorph !== undefined) {
+        delete node.props["data-ignore-morph"];
+    }
+    // Handle dynamic attributes with suffixes
+    for (const [key, value] of Object.entries(node.props)) {
+        if (key.startsWith("data-signals-")
+            && typeof value === "object"
+            && value !== null) {
+            node.props[key] = JSON.stringify(value);
+        }
+        if (key.startsWith("data-on-")
+            && typeof value === "function") {
+            // @ts-ignore
+            node.props[key] = `(${value.toString()})()`;
+        }
+    }
+}

package/dist/x/datastar/index.d.ts

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

package/dist/x/datastar/index.js

@@ -0,0 +1,2 @@
+export * as Datastar from "./Datastar.js";
+export { HyperHooks, } from "./Datastar.js";

package/dist/x/tailwind/TailwindPlugin.d.ts

@@ -0,0 +1,23 @@
+import type { BunPlugin } from "bun";
+export declare const make: (opts?: {
+    /**
+     * Pattern to match component and HTML files for class name extraction.
+     */
+    filesPattern?: RegExp;
+    /**
+     * Pattern to match CSS files that import Tailwind.
+     */
+    cssPattern?: RegExp;
+    /**
+     * Scan a path for candidates.
+     * By default, only class names found in files that are part of the import graph
+     * that imports tailwind are considered.
+     *
+     * This option scans the provided path and ensures that class names found under this path
+     * are includedd, even if they are not part of the import graph.
+     * Useful when we want to scan clientside code which is not imported directly on serverside.
+     */
+    scanPath?: string;
+    target?: "browser" | "bun" | "node";
+}) => BunPlugin;
+export declare function extractClassNames(source: string): Set<string>;

package/dist/x/tailwind/TailwindPlugin.js

@@ -0,0 +1,219 @@
+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;
+}

package/dist/x/tailwind/compile.d.ts

@@ -0,0 +1,19 @@
+import { compile as _compile, compileAst as _compileAst, Features, Polyfills } from "tailwindcss";
+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;
+}
+export declare function compileAst(ast: AstNode[], options: CompileOptions): ReturnType<typeof _compileAst>;
+export declare function compile(css: string, options: CompileOptions): ReturnType<typeof _compile>;
+export declare function loadModule(id: string, base: string, _onDependency: (path: string) => void, customJsResolver?: Resolver): Promise<{
+    path: string;
+    base: string;
+    module: any;
+}>;

package/dist/x/tailwind/compile.js

@@ -0,0 +1,156 @@
+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;
+        },
+    };
+}
+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.`);
+        }
+    }
+}
+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;
+}
+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);
+    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, 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;
+        }
+    }
+    return await import(__rewriteRelativeImportExtension(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);
+        }
+    }
+    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, 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;
+        }
+    }
+    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);
+    }));
+}

package/dist/x/tailwind/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Bun.BunPlugin;
+export default _default;

package/dist/x/tailwind/plugin.js

@@ -0,0 +1,15 @@
+import * as NPath from "node:path";
+import * as NodeUtils from "../../node/Utils.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 scanPath = dirParam
+    ? 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,
+});