auklet 0.0.10 → 0.0.11

package/README.md

@@ -53,6 +53,8 @@ import type { AukletConfig } from 'auklet';
 export const config: AukletConfig = {
   source: 'src',
   output: 'dist',
+  modules: true,
+  tsconfig: 'tsconfig.json',
   styles: {
     themes: {
       light: './src/themes/light.css',
@@ -72,17 +74,12 @@ export const config: AukletConfig = {
       },
     },
   },
-  modules: true,
   build: {
-    formats: ['esm', 'cjs'],
+    alias: { ... },
+    globals: { ... },
     target: 'es2020',
-    alias: {
-      '@shared': './src/shared',
-    },
+    formats: ['esm', 'cjs'],
     mainFields: ['browser', 'module', 'main'],
-    globals: {
-      react: 'React',
-    },
     configureTsdown(config, context) {
       if (context.kind !== 'bundle') return config;
       return {
@@ -90,7 +87,6 @@ export const config: AukletConfig = {
         sourcemap: true,
       };
     },
-    tsconfig: 'tsconfig.json',
   },
 };
 ```
@@ -112,6 +108,12 @@ Component style inference only scans source `.tsx` files. Component imports or
 re-exports in `.ts` files are ignored for CSS auto import, so component barrel
 files that should drive component CSS must be `.tsx`.
 
+Same-package component style inference resolves relative imports,
+`package.json#imports` mappings, and `tsconfig.json` `compilerOptions.paths`.
+For `package.json#imports`, the `source` condition is preferred when present.
+Only aliases that resolve into the current package source directory are treated
+as same-package CSS dependencies.
+
 Supported value forms include named imports, named re-exports, and local
 re-exports that can be traced back to an import binding:
 

package/dist/css/core/resolvers/packageImports.d.ts

@@ -0,0 +1,5 @@
+export declare function resolvePackageImportsSourceImport(
+  packageRoot: string,
+  sourceRoot: string,
+  importPath: string,
+): string[];

package/dist/css/core/resolvers/packageImports.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { findPathInImports } from 'conditional-export';
+import { POSIX_SEPARATOR, toPosixPath } from '#auklet/utils';
+const conditions = ['source', 'import', 'default'];
+const sourceExtensions = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+const readPackageImports = (packageRoot) => {
+  const packageJsonPath = path.join(packageRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) return {};
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.imports ?? {};
+  } catch {
+    return {};
+  }
+};
+const trimSourceExtension = (value) => {
+  return value.replace(sourceExtensions, '');
+};
+const toSourceRelativePath = (packageRoot, sourceRoot, target) => {
+  if (!target.startsWith('.')) return null;
+  const file = path.resolve(packageRoot, target);
+  const relative = path.relative(sourceRoot, file);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) return null;
+  return trimSourceExtension(toPosixPath(relative));
+};
+export function resolvePackageImportsSourceImport(
+  packageRoot,
+  sourceRoot,
+  importPath,
+) {
+  if (!importPath.startsWith('#')) return [];
+  const resolved = (() => {
+    try {
+      return findPathInImports(
+        importPath,
+        readPackageImports(packageRoot),
+        conditions,
+      );
+    } catch {
+      return null;
+    }
+  })();
+  if (!resolved) return [];
+  const sourceRelativePath = toSourceRelativePath(
+    packageRoot,
+    sourceRoot,
+    resolved,
+  );
+  return sourceRelativePath
+    ? [sourceRelativePath.split(POSIX_SEPARATOR).join(path.sep)]
+    : [];
+}

package/dist/css/core/resolvers/relative.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveRelativeSourceImport(
+  sourceDir: string,
+  importPath: string,
+): string[];

package/dist/css/core/resolvers/relative.js

@@ -0,0 +1,5 @@
+import path from 'node:path';
+export function resolveRelativeSourceImport(sourceDir, importPath) {
+  if (!importPath.startsWith('.')) return [];
+  return [path.normalize(path.join(sourceDir, importPath))];
+}

package/dist/css/core/resolvers/tsconfigPaths.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveTsconfigPathsSourceImport(
+  packageRoot: string,
+  sourceRoot: string,
+  importPath: string,
+): string[];

package/dist/css/core/resolvers/tsconfigPaths.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+import { POSIX_SEPARATOR, toPosixPath } from '#auklet/utils';
+const sourceExtensions = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+const findTsconfig = (packageRoot) => {
+  let current = packageRoot;
+  while (true) {
+    const tsconfig = path.join(current, 'tsconfig.json');
+    if (fs.existsSync(tsconfig)) return tsconfig;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+};
+const readTsconfigPaths = (packageRoot) => {
+  const tsconfig = findTsconfig(packageRoot);
+  if (!tsconfig) return null;
+  const loaded = ts.readConfigFile(tsconfig, ts.sys.readFile);
+  if (loaded.error) return null;
+  const parsed = ts.parseJsonConfigFileContent(
+    loaded.config,
+    ts.sys,
+    path.dirname(tsconfig),
+    {},
+    tsconfig,
+  );
+  return {
+    baseUrl: parsed.options.baseUrl ?? path.dirname(tsconfig),
+    paths: parsed.options.paths ?? {},
+  };
+};
+const resolvePattern = (pattern, target, importPath) => {
+  const wildcardIndex = pattern.indexOf('*');
+  if (wildcardIndex < 0) return pattern === importPath ? target : null;
+  const prefix = pattern.slice(0, wildcardIndex);
+  const suffix = pattern.slice(wildcardIndex + 1);
+  if (!importPath.startsWith(prefix) || !importPath.endsWith(suffix)) {
+    return null;
+  }
+  const value = importPath.slice(
+    prefix.length,
+    importPath.length - suffix.length,
+  );
+  return target.replace(/\*/g, value);
+};
+const getPatternScore = (pattern) => {
+  const wildcardIndex = pattern.indexOf('*');
+  if (wildcardIndex < 0) return Number.MAX_SAFE_INTEGER;
+  return pattern.slice(0, wildcardIndex).length;
+};
+const trimSourceExtension = (value) => {
+  return value.replace(sourceExtensions, '');
+};
+const toSourceRelativePath = (sourceRoot, file) => {
+  const relative = path.relative(sourceRoot, file);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) return null;
+  return trimSourceExtension(toPosixPath(relative));
+};
+export function resolveTsconfigPathsSourceImport(
+  packageRoot,
+  sourceRoot,
+  importPath,
+) {
+  const config = readTsconfigPaths(packageRoot);
+  if (!config) return [];
+  const matches = [];
+  for (const [pattern, targets] of Object.entries(config.paths)) {
+    for (const target of targets) {
+      const resolved = resolvePattern(pattern, target, importPath);
+      if (!resolved) continue;
+      const sourceRelativePath = toSourceRelativePath(
+        sourceRoot,
+        path.resolve(config.baseUrl, resolved),
+      );
+      if (sourceRelativePath) {
+        matches.push({
+          path: sourceRelativePath.split(POSIX_SEPARATOR).join(path.sep),
+          score: getPatternScore(pattern),
+        });
+      }
+    }
+  }
+  return matches.sort((a, b) => b.score - a.score).map((match) => match.path);
+}

package/dist/css/core/styleImports/collector.d.ts

@@ -5,7 +5,6 @@ export declare class ModuleStyleImportCollector {
   private readonly packageRoot;
   private readonly resolver;
   private readonly styleExtensions;
-  private readonly sourceImportAliasRules;
   constructor(
     srcRoot: string,
     packageRoot: string,
@@ -18,8 +17,9 @@ export declare class ModuleStyleImportCollector {
   ): Map<string, string[]>;
   private collectSourceImportStyle;
   private resolveSourceImportStyleEntry;
-  private resolveSourceImportPath;
-  private createSourceImportAliasRules;
+  private isInsideSourceRoot;
+  private resolveSourceImportPaths;
+  private toSourceBase;
   private toRelativeSpecifier;
   private createAutoImportRules;
   private matchAutoImportRules;

package/dist/css/core/styleImports/collector.js

@@ -13,19 +13,22 @@ import {
   getSourceReferenceImportedNames,
   isTypeOnlySourceReference,
 } from '#auklet/css/core/styleImports/sourceReference';
+import { resolveRelativeSourceImport } from '#auklet/css/core/resolvers/relative';
+import { resolvePackageImportsSourceImport } from '#auklet/css/core/resolvers/packageImports';
+import { resolveTsconfigPathsSourceImport } from '#auklet/css/core/resolvers/tsconfigPaths';
 const GLOBSTAR_TOKEN = '**';
+const SOURCE_EXTENSION_RE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+const SOURCE_INDEX_RE = new RegExp(`[/\\\\]index${SOURCE_EXTENSION_RE.source}`);
 export class ModuleStyleImportCollector {
   srcRoot;
   packageRoot;
   resolver;
   styleExtensions;
-  sourceImportAliasRules;
   constructor(srcRoot, packageRoot, resolver, styleExtensions = ['.css']) {
     this.srcRoot = srcRoot;
     this.packageRoot = packageRoot;
     this.resolver = resolver;
     this.styleExtensions = styleExtensions;
-    this.sourceImportAliasRules = this.createSourceImportAliasRules();
   }
   collect(files, config) {
     const entries = new Map();
@@ -100,51 +103,51 @@ export class ModuleStyleImportCollector {
     );
   }
   resolveSourceImportStyleEntry(sourceDir, importPath) {
-    const sourceRelativePath = this.resolveSourceImportPath(
+    const sourceRelativePaths = this.resolveSourceImportPaths(
       sourceDir,
       importPath,
     );
-    if (!sourceRelativePath) return null;
-    const sourceBase = path.join(this.srcRoot, sourceRelativePath);
-    const directoryStyleEntry = path.join(sourceBase, 'style', 'index.css');
-    for (const extension of this.styleExtensions) {
-      const directorySourceStyle = path.join(sourceBase, `index${extension}`);
-      if (fs.existsSync(directorySourceStyle)) return directoryStyleEntry;
-    }
-    const hasFileSourceStyle = this.styleExtensions.some((extension) =>
-      fs.existsSync(`${sourceBase}${extension}`),
-    );
-    if (!hasFileSourceStyle) return null;
-    return path.join(sourceBase, 'style', 'index.css');
-  }
-  resolveSourceImportPath(sourceDir, importPath) {
-    if (importPath.startsWith('.')) {
-      return path.normalize(path.join(sourceDir, importPath));
-    }
-    for (const rule of this.sourceImportAliasRules) {
-      if (!importPath.startsWith(rule.prefix)) continue;
-      return importPath.slice(rule.prefix.length);
+    for (const sourceRelativePath of sourceRelativePaths) {
+      const sourceBase = this.toSourceBase(sourceRelativePath);
+      if (!this.isInsideSourceRoot(sourceBase)) continue;
+      const directoryStyleEntry = path.join(sourceBase, 'style', 'index.css');
+      for (const extension of this.styleExtensions) {
+        const directorySourceStyle = path.join(sourceBase, `index${extension}`);
+        if (fs.existsSync(directorySourceStyle)) return directoryStyleEntry;
+      }
+      const hasFileSourceStyle = this.styleExtensions.some((extension) =>
+        fs.existsSync(`${sourceBase}${extension}`),
+      );
+      if (hasFileSourceStyle)
+        return path.join(sourceBase, 'style', 'index.css');
     }
     return null;
   }
-  createSourceImportAliasRules() {
-    const packageJsonPath = path.join(this.packageRoot, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) return [];
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    const rules = [];
-    for (const [name, target] of Object.entries(packageJson.imports ?? {})) {
-      if (
-        !name.endsWith(`${POSIX_SEPARATOR}*`) ||
-        typeof target !== 'string' ||
-        !target.includes('*')
-      ) {
-        continue;
-      }
-      rules.push({
-        prefix: name.slice(0, -1),
-      });
+  isInsideSourceRoot(file) {
+    const relative = path.relative(this.srcRoot, file);
+    return !relative.startsWith('..') && !path.isAbsolute(relative);
+  }
+  resolveSourceImportPaths(sourceDir, importPath) {
+    return [
+      ...resolveRelativeSourceImport(sourceDir, importPath),
+      ...resolvePackageImportsSourceImport(
+        this.packageRoot,
+        this.srcRoot,
+        importPath,
+      ),
+      ...resolveTsconfigPathsSourceImport(
+        this.packageRoot,
+        this.srcRoot,
+        importPath,
+      ),
+    ];
+  }
+  toSourceBase(sourceRelativePath) {
+    const sourceBase = path.join(this.srcRoot, sourceRelativePath);
+    if (SOURCE_INDEX_RE.test(sourceBase)) {
+      return path.dirname(sourceBase);
     }
-    return rules;
+    return sourceBase.replace(SOURCE_EXTENSION_RE, '');
   }
   toRelativeSpecifier(fromDir, file) {
     const relative = path.relative(fromDir, file).split(path.sep).join('/');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "author": "chentao.arthur",
   "packageManager": "pnpm@10.27.0",
@@ -72,7 +72,7 @@
     "chokidar": "^5.0.0",
     "minimist": "^1.2.8",
     "typescript": "^6.0.3",
-    "tailwindcss": "^4.2.4"
+    "conditional-export": "^1.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.17.0",