auklet 0.0.16 → 0.0.17

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

@@ -3,16 +3,8 @@ import path from 'node:path';
 import { isArray } from 'aidly';
 import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
 import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
-import {
-  appendUniqueMapValue,
-  getSourceModuleDir,
-  POSIX_SEPARATOR,
-} from '#auklet/utils';
-import {
-  collectModuleStyleSourceReferences,
-  getSourceReferenceImportedNames,
-  isTypeOnlySourceReference,
-} from '#auklet/css/core/styleImports/sourceReference';
+import { appendUniqueMapValue, getSourceModuleDir, POSIX_SEPARATOR, } from '#auklet/utils';
+import { collectModuleStyleSourceReferences, 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';
@@ -20,206 +12,175 @@ 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;
-  constructor(srcRoot, packageRoot, resolver, styleExtensions = ['.css']) {
-    this.srcRoot = srcRoot;
-    this.packageRoot = packageRoot;
-    this.resolver = resolver;
-    this.styleExtensions = styleExtensions;
-  }
-  collect(files, config) {
-    const entries = new Map();
-    const rules = this.createAutoImportRules(config);
-    for (const file of files) {
-      if (!SOURCE_COMPONENT_MODULE_RE.test(file)) {
-        continue;
-      }
-      const sourceRelative = path.relative(this.srcRoot, file);
-      const sourceDir = path.dirname(sourceRelative);
-      const sourceModuleDir = getSourceModuleDir(sourceRelative);
-      const code = fs.readFileSync(file, 'utf8');
-      const imports = collectModuleStyleSourceReferences(file, code);
-      for (const item of imports) {
-        this.collectSourceImportStyle(
-          entries,
-          sourceDir,
-          sourceModuleDir,
-          item,
-        );
-        if (isTypeOnlySourceReference(item)) continue;
-        const importPath = item.importPath;
-        const ruleMatches = this.matchAutoImportRules(rules, importPath);
-        if (!ruleMatches.length) continue;
-        const directSpecifiers = ruleMatches.flatMap((ruleMatch) => {
-          const specifier = this.createDirectStyleSpecifier(
-            ruleMatch.rule,
-            importPath,
-          );
-          return specifier ? [specifier] : [];
-        });
-        if (directSpecifiers.length) {
-          for (const specifier of directSpecifiers) {
-            const cssFile = this.resolver.resolveStyleDependency(specifier);
-            if (fs.existsSync(cssFile)) {
-              appendUniqueMapValue(entries, sourceModuleDir, specifier);
+    srcRoot;
+    packageRoot;
+    resolver;
+    styleExtensions;
+    constructor(srcRoot, packageRoot, resolver, styleExtensions = ['.css']) {
+        this.srcRoot = srcRoot;
+        this.packageRoot = packageRoot;
+        this.resolver = resolver;
+        this.styleExtensions = styleExtensions;
+    }
+    collect(files, config) {
+        const entries = new Map();
+        const rules = this.createAutoImportRules(config);
+        for (const file of files) {
+            if (!SOURCE_COMPONENT_MODULE_RE.test(file)) {
+                continue;
+            }
+            const sourceRelative = path.relative(this.srcRoot, file);
+            const sourceDir = path.dirname(sourceRelative);
+            const sourceModuleDir = getSourceModuleDir(sourceRelative);
+            const code = fs.readFileSync(file, 'utf8');
+            const imports = collectModuleStyleSourceReferences(file, code);
+            for (const item of imports) {
+                this.collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item);
+                if (isTypeOnlySourceReference(item))
+                    continue;
+                const importPath = item.importPath;
+                const ruleMatches = this.matchAutoImportRules(rules, importPath);
+                if (!ruleMatches.length)
+                    continue;
+                const directSpecifiers = ruleMatches.flatMap((ruleMatch) => {
+                    const specifier = this.createDirectStyleSpecifier(ruleMatch.rule, importPath);
+                    return specifier ? [specifier] : [];
+                });
+                if (directSpecifiers.length) {
+                    for (const specifier of directSpecifiers) {
+                        const cssFile = this.resolver.resolveStyleDependency(specifier);
+                        if (fs.existsSync(cssFile)) {
+                            appendUniqueMapValue(entries, sourceModuleDir, specifier);
+                        }
+                    }
+                    continue;
+                }
+                for (const ruleMatch of ruleMatches) {
+                    const importedNames = getSourceReferenceImportedNames(file, item);
+                    for (const importedName of importedNames) {
+                        const specifier = this.createStyleSpecifier(ruleMatch.rule, ruleMatch.values, importedName);
+                        const cssFile = this.resolver.resolveStyleDependency(specifier);
+                        if (!fs.existsSync(cssFile)) {
+                            continue;
+                        }
+                        appendUniqueMapValue(entries, sourceModuleDir, specifier);
+                    }
+                }
             }
-          }
-          continue;
         }
-        for (const ruleMatch of ruleMatches) {
-          const importedNames = getSourceReferenceImportedNames(file, item);
-          for (const importedName of importedNames) {
-            const specifier = this.createStyleSpecifier(
-              ruleMatch.rule,
-              ruleMatch.values,
-              importedName,
-            );
-            const cssFile = this.resolver.resolveStyleDependency(specifier);
-            if (!fs.existsSync(cssFile)) {
-              continue;
+        return entries;
+    }
+    collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item) {
+        if (isTypeOnlySourceReference(item))
+            return;
+        const importedStyleEntry = this.resolveSourceImportStyleEntry(sourceDir, item.importPath);
+        if (!importedStyleEntry)
+            return;
+        const sourceStyleDir = path.join(this.srcRoot, sourceModuleDir, 'style');
+        appendUniqueMapValue(entries, sourceModuleDir, this.toRelativeSpecifier(sourceStyleDir, importedStyleEntry));
+    }
+    resolveSourceImportStyleEntry(sourceDir, importPath) {
+        const sourceRelativePaths = this.resolveSourceImportPaths(sourceDir, importPath);
+        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;
             }
-            appendUniqueMapValue(entries, sourceModuleDir, specifier);
-          }
+            const hasFileSourceStyle = this.styleExtensions.some((extension) => fs.existsSync(`${sourceBase}${extension}`));
+            if (hasFileSourceStyle)
+                return path.join(sourceBase, 'style', 'index.css');
         }
-      }
+        return null;
     }
-    return entries;
-  }
-  collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item) {
-    if (isTypeOnlySourceReference(item)) return;
-    const importedStyleEntry = this.resolveSourceImportStyleEntry(
-      sourceDir,
-      item.importPath,
-    );
-    if (!importedStyleEntry) return;
-    const sourceStyleDir = path.join(this.srcRoot, sourceModuleDir, 'style');
-    appendUniqueMapValue(
-      entries,
-      sourceModuleDir,
-      this.toRelativeSpecifier(sourceStyleDir, importedStyleEntry),
-    );
-  }
-  resolveSourceImportStyleEntry(sourceDir, importPath) {
-    const sourceRelativePaths = this.resolveSourceImportPaths(
-      sourceDir,
-      importPath,
-    );
-    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');
+    isInsideSourceRoot(file) {
+        const relative = path.relative(this.srcRoot, file);
+        return !relative.startsWith('..') && !path.isAbsolute(relative);
     }
-    return null;
-  }
-  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);
+    resolveSourceImportPaths(sourceDir, importPath) {
+        return [
+            ...resolveRelativeSourceImport(sourceDir, importPath),
+            ...resolvePackageImportsSourceImport(this.packageRoot, this.srcRoot, importPath),
+            ...resolveTsconfigPathsSourceImport(this.packageRoot, this.srcRoot, importPath),
+        ];
     }
-    return sourceBase.replace(SOURCE_EXTENSION_RE, '');
-  }
-  toRelativeSpecifier(fromDir, file) {
-    const relative = path.relative(fromDir, file).split(path.sep).join('/');
-    return relative.startsWith('.') ? relative : `./${relative}`;
-  }
-  createAutoImportRules(config) {
-    const rules = [];
-    for (const [packageName, dependency] of Object.entries(
-      config.styles.dependencies,
-    )) {
-      const dependencyPaths = isArray(dependency.components)
-        ? dependency.components
-        : dependency.components
-        ? [dependency.components]
-        : [];
-      for (const dependencyPath of dependencyPaths) {
-        rules.push({
-          packageName,
-          outputPattern: joinDependencySpecifier(packageName, dependencyPath),
-        });
-      }
+    toSourceBase(sourceRelativePath) {
+        const sourceBase = path.join(this.srcRoot, sourceRelativePath);
+        if (SOURCE_INDEX_RE.test(sourceBase)) {
+            return path.dirname(sourceBase);
+        }
+        return sourceBase.replace(SOURCE_EXTENSION_RE, '');
     }
-    return rules;
-  }
-  matchAutoImportRules(rules, importPath) {
-    const matches = [];
-    for (const rule of rules) {
-      if (
-        importPath !== rule.packageName &&
-        !importPath.startsWith(`${rule.packageName}${POSIX_SEPARATOR}`)
-      ) {
-        continue;
-      }
-      matches.push({
-        rule,
-        values: this.getImportPathValues(rule.packageName, importPath),
-      });
+    toRelativeSpecifier(fromDir, file) {
+        const relative = path.relative(fromDir, file).split(path.sep).join('/');
+        return relative.startsWith('.') ? relative : `./${relative}`;
     }
-    return matches;
-  }
-  getImportPathValues(packageName, importPath) {
-    return importPath
-      .slice(packageName.length)
-      .replace(new RegExp(`^${POSIX_SEPARATOR}`), '')
-      .split(POSIX_SEPARATOR)
-      .filter(Boolean);
-  }
-  createStyleSpecifier(rule, values, importedName) {
-    const pathValues = [...values];
-    return rule.outputPattern.replace(/\*\*|\*/g, (token) => {
-      const matchedValue = pathValues.shift();
-      if (matchedValue) return matchedValue;
-      if (token === GLOBSTAR_TOKEN) return importedName;
-      return matchedValue ?? importedName;
-    });
-  }
-  createDirectStyleSpecifier(rule, importPath) {
-    const wildcardIndex = rule.outputPattern.indexOf('*');
-    if (wildcardIndex < 0) {
-      return null;
+    createAutoImportRules(config) {
+        const rules = [];
+        for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {
+            const dependencyPaths = isArray(dependency.components)
+                ? dependency.components
+                : dependency.components
+                    ? [dependency.components]
+                    : [];
+            for (const dependencyPath of dependencyPaths) {
+                rules.push({
+                    packageName,
+                    outputPattern: joinDependencySpecifier(packageName, dependencyPath),
+                });
+            }
+        }
+        return rules;
     }
-    const wildcardLength = rule.outputPattern.startsWith(
-      GLOBSTAR_TOKEN,
-      wildcardIndex,
-    )
-      ? GLOBSTAR_TOKEN.length
-      : 1;
-    const prefix = rule.outputPattern.slice(0, wildcardIndex);
-    const suffix = rule.outputPattern.slice(wildcardIndex + wildcardLength);
-    if (!importPath.startsWith(prefix)) {
-      return null;
+    matchAutoImportRules(rules, importPath) {
+        const matches = [];
+        for (const rule of rules) {
+            if (importPath !== rule.packageName &&
+                !importPath.startsWith(`${rule.packageName}${POSIX_SEPARATOR}`)) {
+                continue;
+            }
+            matches.push({
+                rule,
+                values: this.getImportPathValues(rule.packageName, importPath),
+            });
+        }
+        return matches;
+    }
+    getImportPathValues(packageName, importPath) {
+        return importPath
+            .slice(packageName.length)
+            .replace(new RegExp(`^${POSIX_SEPARATOR}`), '')
+            .split(POSIX_SEPARATOR)
+            .filter(Boolean);
+    }
+    createStyleSpecifier(rule, values, importedName) {
+        const pathValues = [...values];
+        return rule.outputPattern.replace(/\*\*|\*/g, (token) => {
+            const matchedValue = pathValues.shift();
+            if (matchedValue)
+                return matchedValue;
+            if (token === GLOBSTAR_TOKEN)
+                return importedName;
+            return matchedValue ?? importedName;
+        });
+    }
+    createDirectStyleSpecifier(rule, importPath) {
+        const wildcardIndex = rule.outputPattern.indexOf('*');
+        if (wildcardIndex < 0) {
+            return null;
+        }
+        const wildcardLength = rule.outputPattern.startsWith(GLOBSTAR_TOKEN, wildcardIndex)
+            ? GLOBSTAR_TOKEN.length
+            : 1;
+        const prefix = rule.outputPattern.slice(0, wildcardIndex);
+        const suffix = rule.outputPattern.slice(wildcardIndex + wildcardLength);
+        if (!importPath.startsWith(prefix)) {
+            return null;
+        }
+        return `${importPath}${suffix}`;
     }
-    return `${importPath}${suffix}`;
-  }
 }

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

@@ -1,19 +1,11 @@
 import ts from 'typescript';
 export type ModuleStyleSourceReference = {
-  importPath: string;
-  importClause?: ts.ImportClause;
-  importedNames?: Array<string>;
-  isTypeOnly?: boolean;
-  hasNamespaceImport?: boolean;
+    importPath: string;
+    importClause?: ts.ImportClause;
+    importedNames?: Array<string>;
+    isTypeOnly?: boolean;
+    hasNamespaceImport?: boolean;
 };
-export declare function collectModuleStyleSourceReferences(
-  file: string,
-  code: string,
-): ModuleStyleSourceReference[];
-export declare function isTypeOnlySourceReference(
-  item: ModuleStyleSourceReference,
-): boolean | undefined;
-export declare function getSourceReferenceImportedNames(
-  file: string,
-  item: ModuleStyleSourceReference,
-): string[];
+export declare function collectModuleStyleSourceReferences(file: string, code: string): ModuleStyleSourceReference[];
+export declare function isTypeOnlySourceReference(item: ModuleStyleSourceReference): boolean | undefined;
+export declare function getSourceReferenceImportedNames(file: string, item: ModuleStyleSourceReference): string[];