@knighted/css 1.0.0-rc.0 → 1.0.0-rc.10

package/bin/generate-types.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const distPath = path.resolve(__dirname, '../dist/generateTypes.js')
+
+async function main() {
+  try {
+    const mod = await import(pathToFileURL(distPath).href)
+    const runner =
+      typeof mod.runGenerateTypesCli === 'function'
+        ? mod.runGenerateTypesCli
+        : typeof mod.default === 'function'
+          ? mod.default
+          : undefined
+    if (typeof runner !== 'function') {
+      console.error('[knighted-css] Unable to load generateTypes CLI entry point.')
+      process.exitCode = 1
+      return
+    }
+    await runner(process.argv.slice(2))
+  } catch (error) {
+    console.error('[knighted-css] Failed to run generateTypes CLI.')
+    console.error(error)
+    process.exitCode = 1
+  }
+}
+
+void main()

package/dist/cjs/css.cjs

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_EXTENSIONS = void 0;
 exports.css = css;
 exports.cssWithMeta = cssWithMeta;
+exports.compileVanillaModule = compileVanillaModule;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = require("node:fs");
-const dependency_tree_1 = __importDefault(require("dependency-tree"));
 const lightningcss_1 = require("lightningcss");
 const helpers_js_1 = require("./helpers.cjs");
+const moduleGraph_js_1 = require("./moduleGraph.cjs");
+const sassInternals_js_1 = require("./sassInternals.cjs");
 exports.DEFAULT_EXTENSIONS = ['.css', '.scss', '.sass', '.less', '.css.ts'];
 async function css(entry, options = {}) {
     const { css: output } = await cssWithMeta(entry, options);
@@ -20,11 +22,12 @@ async function cssWithMeta(entry, options = {}) {
     const cwd = options.cwd ? node_path_1.default.resolve(options.cwd) : process.cwd();
     const entryPath = await resolveEntry(entry, cwd, options.resolver);
     const extensions = (options.extensions ?? exports.DEFAULT_EXTENSIONS).map(ext => ext.toLowerCase());
-    const files = collectStyleDependencies(entryPath, {
+    const files = await collectStyleDependencies(entryPath, {
         cwd,
         extensions,
         filter: options.filter,
-        dependencyTreeOptions: options.dependencyTree,
+        graphOptions: options.moduleGraph,
+        resolver: options.resolver,
     });
     if (files.length === 0) {
         return { css: '', files: [] };
@@ -34,6 +37,7 @@ async function cssWithMeta(entry, options = {}) {
         const chunk = await compileStyleModule(file, {
             cwd,
             peerResolver: options.peerResolver,
+            resolver: options.resolver,
         });
         if (chunk) {
             chunks.push(chunk);
@@ -73,30 +77,33 @@ async function resolveEntry(entry, cwd, resolver) {
     }
     return node_path_1.default.resolve(cwd, entry);
 }
-function collectStyleDependencies(entryPath, { cwd, extensions, filter, dependencyTreeOptions, }) {
+async function collectStyleDependencies(entryPath, { cwd, extensions, filter, graphOptions, resolver, }) {
     const seen = new Set();
     const order = [];
     const shouldInclude = typeof filter === 'function'
         ? filter
         : (filePath) => !filePath.includes('node_modules');
     const entryIsStyle = Boolean(matchExtension(entryPath, extensions));
-    let treeList = [];
+    let discoveredStyles = [];
     if (!entryIsStyle) {
-        const dependencyConfig = {
-            ...dependencyTreeOptions,
-            filename: entryPath,
-            directory: cwd,
+        discoveredStyles = await (0, moduleGraph_js_1.collectStyleImports)(entryPath, {
+            cwd,
+            styleExtensions: extensions,
             filter: shouldInclude,
-        };
-        treeList = dependency_tree_1.default.toList(dependencyConfig);
+            resolver,
+            graphOptions,
+        });
     }
-    const candidates = entryIsStyle ? [entryPath] : [entryPath, ...treeList];
+    const candidates = entryIsStyle ? [entryPath] : [entryPath, ...discoveredStyles];
     for (const candidate of candidates) {
         const match = matchExtension(candidate, extensions);
-        if (!match || seen.has(candidate))
+        if (!match)
+            continue;
+        const resolvedCandidate = node_path_1.default.resolve(candidate);
+        if (seen.has(resolvedCandidate))
             continue;
-        seen.add(candidate);
-        order.push({ path: node_path_1.default.resolve(candidate), ext: match });
+        seen.add(resolvedCandidate);
+        order.push({ path: resolvedCandidate, ext: match });
     }
     return order;
 }
@@ -104,28 +111,79 @@ function matchExtension(filePath, extensions) {
     const lower = filePath.toLowerCase();
     return extensions.find(ext => lower.endsWith(ext));
 }
-async function compileStyleModule(file, { cwd, peerResolver }) {
+async function compileStyleModule(file, { cwd, peerResolver, resolver, }) {
     switch (file.ext) {
         case '.css':
             return node_fs_1.promises.readFile(file.path, 'utf8');
         case '.scss':
         case '.sass':
-            return compileSass(file.path, file.ext === '.sass', peerResolver);
+            return compileSass(file.path, file.ext === '.sass', {
+                cwd,
+                peerResolver,
+                resolver,
+            });
         case '.less':
             return compileLess(file.path, peerResolver);
         case '.css.ts':
-            return compileVanillaExtract(file.path, cwd, peerResolver);
+            return (await compileVanillaModule(file.path, cwd, peerResolver)).css;
         default:
             return '';
     }
 }
-async function compileSass(filePath, indented, peerResolver) {
+async function compileSass(filePath, indented, { cwd, peerResolver, resolver, }) {
     const sassModule = await optionalPeer('sass', 'Sass', peerResolver);
-    const sass = sassModule;
-    const result = sass.compile(filePath, {
-        style: 'expanded',
+    const sass = resolveSassNamespace(sassModule);
+    const importer = (0, sassInternals_js_1.createSassImporter)({ cwd, resolver });
+    const loadPaths = buildSassLoadPaths(filePath);
+    if (typeof sass.compileAsync === 'function') {
+        const result = await sass.compileAsync(filePath, {
+            style: 'expanded',
+            loadPaths,
+            importers: importer ? [importer] : undefined,
+        });
+        return result.css;
+    }
+    if (typeof sass.render === 'function') {
+        return renderLegacySass(sass, filePath, indented, loadPaths);
+    }
+    throw new Error('@knighted/css: Installed "sass" package does not expose compileAsync or render APIs. Please update "sass" to a supported version.');
+}
+function renderLegacySass(sass, filePath, indented, loadPaths) {
+    return new Promise((resolve, reject) => {
+        sass.render({
+            file: filePath,
+            indentedSyntax: indented,
+            outputStyle: 'expanded',
+            includePaths: loadPaths,
+        }, (error, result) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (!result || typeof result.css === 'undefined') {
+                resolve('');
+                return;
+            }
+            resolve(result.css.toString());
+        });
     });
-    return result.css;
+}
+// Ensure Sass can resolve bare module specifiers by walking node_modules folders.
+function buildSassLoadPaths(filePath) {
+    const loadPaths = new Set();
+    let cursor = node_path_1.default.dirname(filePath);
+    const root = node_path_1.default.parse(cursor).root;
+    while (true) {
+        loadPaths.add(cursor);
+        loadPaths.add(node_path_1.default.join(cursor, 'node_modules'));
+        if (cursor === root)
+            break;
+        cursor = node_path_1.default.dirname(cursor);
+    }
+    const cwd = process.cwd();
+    loadPaths.add(cwd);
+    loadPaths.add(node_path_1.default.join(cwd, 'node_modules'));
+    return Array.from(loadPaths).filter(dir => dir && (0, node_fs_1.existsSync)(dir));
 }
 async function compileLess(filePath, peerResolver) {
     const mod = await optionalPeer('less', 'Less', peerResolver);
@@ -134,7 +192,7 @@ async function compileLess(filePath, peerResolver) {
     const result = await less.render(source, { filename: filePath });
     return result.css;
 }
-async function compileVanillaExtract(filePath, cwd, peerResolver) {
+async function compileVanillaModule(filePath, cwd, peerResolver) {
     const mod = await optionalPeer('@vanilla-extract/integration', 'Vanilla Extract', peerResolver);
     const namespace = unwrapModuleNamespace(mod);
     const compileFn = namespace.compile;
@@ -174,7 +232,10 @@ async function compileVanillaExtract(filePath, cwd, peerResolver) {
             imports.push(virtualFile.source);
         }
     }
-    return imports.join('\n');
+    return {
+        source,
+        css: imports.join('\n'),
+    };
 }
 const defaultPeerLoader = name => import(name);
 async function optionalPeer(name, label, loader) {
@@ -193,6 +254,27 @@ async function optionalPeer(name, label, loader) {
         throw error;
     }
 }
+function resolveSassNamespace(mod) {
+    if (isSassNamespace(mod)) {
+        return mod;
+    }
+    if (typeof mod === 'object' &&
+        mod !== null &&
+        'default' in mod) {
+        const candidate = mod.default;
+        if (isSassNamespace(candidate)) {
+            return candidate;
+        }
+    }
+    return mod;
+}
+function isSassNamespace(candidate) {
+    if (typeof candidate !== 'object' || !candidate) {
+        return false;
+    }
+    const namespace = candidate;
+    return typeof namespace.compile === 'function' || typeof namespace.render === 'function';
+}
 function unwrapModuleNamespace(mod) {
     if (typeof mod === 'object' &&
         mod !== null &&

package/dist/cjs/css.d.cts

@@ -1,11 +1,11 @@
-import type { Options as DependencyTreeOpts } from 'dependency-tree';
 import { type TransformOptions as LightningTransformOptions } from 'lightningcss';
 import { type SpecificitySelector, type SpecificityStrategy } from './helpers.cjs';
+import type { ModuleGraphOptions } from './moduleGraph.cjs';
+import type { CssResolver } from './types.cjs';
+export type { CssResolver } from './types.cjs';
+export type { ModuleGraphOptions } from './moduleGraph.cjs';
 export declare const DEFAULT_EXTENSIONS: string[];
 type LightningCssConfig = boolean | Partial<Omit<LightningTransformOptions<never>, 'code'>>;
-export type CssResolver = (specifier: string, ctx: {
-    cwd: string;
-}) => string | Promise<string | undefined>;
 type PeerLoader = (name: string) => Promise<unknown>;
 export interface CssOptions {
     extensions?: string[];
@@ -17,10 +17,14 @@ export interface CssOptions {
         strategy?: SpecificityStrategy;
         match?: SpecificitySelector[];
     };
-    dependencyTree?: Partial<Omit<DependencyTreeOpts, 'filename' | 'directory'>>;
+    moduleGraph?: ModuleGraphOptions;
     resolver?: CssResolver;
     peerResolver?: PeerLoader;
 }
+export interface VanillaCompileResult {
+    source: string;
+    css: string;
+}
 /**
  * Extract and compile all CSS-like dependencies for a given module.
  */
@@ -30,4 +34,4 @@ export interface CssResult {
 }
 export declare function css(entry: string, options?: CssOptions): Promise<string>;
 export declare function cssWithMeta(entry: string, options?: CssOptions): Promise<CssResult>;
-export {};
+export declare function compileVanillaModule(filePath: string, cwd: string, peerResolver?: PeerLoader): Promise<VanillaCompileResult>;