effect-start 0.23.1 → 0.26.0

package/dist/x/tailwind/TailwindPlugin.js

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

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

@@ -1,19 +0,0 @@
-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: Array<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

@@ -1,154 +0,0 @@
-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 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

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

package/dist/x/tailwind/plugin.js

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