auklet 0.0.16 → 0.0.18

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

@@ -1,225 +1,120 @@
 import fs from 'node:fs';
 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 { SOURCE_MODULE_RE } from '#auklet/css/constants';
+import { appendUniqueMapValue, getSourceModuleDir } from '#auklet/utils';
+import { isTypeOnlyModuleReference, collectModuleImportReferences, getModuleReferenceImportedNames, } from '#auklet/css/core/styleImports/sourceImportExportAnalyzer';
 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 = '**';
+import { matchStyleAutoImportRules, createStyleAutoImportRules, createStyleAutoImportSpecifier, createDirectStyleAutoImportSpecifier, } from '#auklet/css/core/styleImports/autoImportRules';
 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 = createStyleAutoImportRules(config);
+        for (const file of files) {
+            if (!SOURCE_MODULE_RE.test(file)) {
+                continue;
             }
-          }
-          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;
+            const sourceRelative = path.relative(this.srcRoot, file);
+            const sourceDir = path.dirname(sourceRelative);
+            const sourceModuleDir = getSourceModuleDir(sourceRelative);
+            const code = fs.readFileSync(file, 'utf8');
+            const imports = collectModuleImportReferences(file, code);
+            for (const item of imports) {
+                this.collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item);
+                if (isTypeOnlyModuleReference(item))
+                    continue;
+                const importPath = item.importPath;
+                const ruleMatches = matchStyleAutoImportRules(rules, importPath);
+                if (!ruleMatches.length)
+                    continue;
+                const directSpecifiers = ruleMatches.flatMap((ruleMatch) => {
+                    const specifier = createDirectStyleAutoImportSpecifier(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 = getModuleReferenceImportedNames(file, item);
+                    for (const importedName of importedNames) {
+                        const specifier = createStyleAutoImportSpecifier(ruleMatch.rule, ruleMatch.values, importedName);
+                        const cssFile = this.resolver.resolveStyleDependency(specifier);
+                        if (!fs.existsSync(cssFile)) {
+                            continue;
+                        }
+                        appendUniqueMapValue(entries, sourceModuleDir, specifier);
+                    }
+                }
             }
-            appendUniqueMapValue(entries, sourceModuleDir, specifier);
-          }
         }
-      }
+        return entries;
     }
-    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');
+    collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item) {
+        if (isTypeOnlyModuleReference(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));
     }
-    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);
+    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');
+        }
+        return null;
     }
-    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),
-        });
-      }
+    isInsideSourceRoot(file) {
+        const relative = path.relative(this.srcRoot, file);
+        return !relative.startsWith('..') && !path.isAbsolute(relative);
     }
-    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),
-      });
+    resolveSourceImportPaths(sourceDir, importPath) {
+        return [
+            ...resolveRelativeSourceImport(sourceDir, importPath),
+            ...resolvePackageImportsSourceImport(this.packageRoot, this.srcRoot, importPath),
+            ...resolveTsconfigPathsSourceImport(this.packageRoot, this.srcRoot, 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;
+    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, '');
     }
-    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;
+    toRelativeSpecifier(fromDir, file) {
+        const relative = path.relative(fromDir, file).split(path.sep).join('/');
+        return relative.startsWith('.') ? relative : `./${relative}`;
     }
-    return `${importPath}${suffix}`;
-  }
 }

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

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

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

@@ -0,0 +1,173 @@
+import ts from 'typescript';
+export function collectModuleImportReferences(file, code) {
+    const imports = [];
+    const importBindings = new Map();
+    const localDeclarations = new Set();
+    const sourceFile = ts.createSourceFile(file, code, ts.ScriptTarget.Latest, false, file.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    sourceFile.forEachChild((node) => {
+        collectLocalDeclarationNames(node, localDeclarations);
+        if (ts.isImportDeclaration(node)) {
+            collectImportBindings(node, importBindings);
+        }
+    });
+    sourceFile.forEachChild((node) => {
+        if (ts.isImportDeclaration(node)) {
+            if (!ts.isStringLiteral(node.moduleSpecifier)) {
+                return;
+            }
+            imports.push({
+                importPath: node.moduleSpecifier.text,
+                importClause: node.importClause,
+            });
+            return;
+        }
+        if (ts.isExportDeclaration(node)) {
+            collectExportDeclaration(file, node, imports, importBindings, localDeclarations);
+        }
+    });
+    return imports;
+}
+export function isTypeOnlyModuleReference(item) {
+    return isTypeOnlyImportClause(item.importClause) || item.isTypeOnly;
+}
+export function getModuleReferenceImportedNames(file, item) {
+    if (item.importedNames) {
+        if (item.isTypeOnly)
+            return [];
+        if (item.hasNamespaceImport) {
+            throw createNamespaceImportError(file, item.importPath);
+        }
+        return item.importedNames;
+    }
+    const importClause = item.importClause;
+    if (!importClause || isTypeOnlyImportClause(importClause)) {
+        return [];
+    }
+    const names = [];
+    if (importClause.name) {
+        names.push(importClause.name.text);
+    }
+    const namedBindings = importClause.namedBindings;
+    if (!namedBindings) {
+        return names;
+    }
+    if (ts.isNamespaceImport(namedBindings)) {
+        throw createNamespaceImportError(file, item.importPath);
+    }
+    for (const element of namedBindings.elements) {
+        if (element.isTypeOnly)
+            continue;
+        names.push((element.propertyName ?? element.name).text);
+    }
+    return names;
+}
+const collectLocalDeclarationNames = (node, localDeclarations) => {
+    if ((ts.isFunctionDeclaration(node) ||
+        ts.isClassDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node) ||
+        ts.isEnumDeclaration(node)) &&
+        node.name) {
+        localDeclarations.add(node.name.text);
+        return;
+    }
+    if (!ts.isVariableStatement(node))
+        return;
+    for (const declaration of node.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+            localDeclarations.add(declaration.name.text);
+        }
+    }
+};
+const collectImportBindings = (node, importBindings) => {
+    if (!ts.isStringLiteral(node.moduleSpecifier) || !node.importClause) {
+        return;
+    }
+    const importPath = node.moduleSpecifier.text;
+    const isTypeOnly = isTypeOnlyImportClause(node.importClause);
+    if (node.importClause.name) {
+        const importedName = node.importClause.name.text;
+        importBindings.set(importedName, {
+            importPath,
+            importedName,
+            isTypeOnly,
+            hasNamespaceImport: false,
+        });
+    }
+    const namedBindings = node.importClause.namedBindings;
+    if (!namedBindings)
+        return;
+    if (ts.isNamespaceImport(namedBindings)) {
+        importBindings.set(namedBindings.name.text, {
+            importPath,
+            importedName: namedBindings.name.text,
+            isTypeOnly,
+            hasNamespaceImport: true,
+        });
+        return;
+    }
+    for (const element of namedBindings.elements) {
+        const importedName = (element.propertyName ?? element.name).text;
+        importBindings.set(element.name.text, {
+            importPath,
+            importedName,
+            isTypeOnly: isTypeOnly || element.isTypeOnly,
+            hasNamespaceImport: false,
+        });
+    }
+};
+const collectExportDeclaration = (file, node, imports, importBindings, localDeclarations) => {
+    if (node.moduleSpecifier) {
+        if (!ts.isStringLiteral(node.moduleSpecifier))
+            return;
+        if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
+            throw new Error(`[auklet:css] Export-all declarations are not supported for CSS auto import: ${node.moduleSpecifier.text}\n` +
+                `Use named exports instead, for example: export { Component } from '${node.moduleSpecifier.text}'.\n` +
+                `File: ${file}`);
+        }
+        imports.push({
+            importPath: node.moduleSpecifier.text,
+            importedNames: getExportedNames(node),
+            isTypeOnly: node.isTypeOnly,
+        });
+        return;
+    }
+    if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
+        return;
+    }
+    for (const element of node.exportClause.elements) {
+        if (node.isTypeOnly || element.isTypeOnly)
+            continue;
+        const localName = (element.propertyName ?? element.name).text;
+        const binding = importBindings.get(localName);
+        if (binding) {
+            imports.push({
+                importPath: binding.importPath,
+                importedNames: [binding.importedName],
+                isTypeOnly: binding.isTypeOnly,
+                hasNamespaceImport: binding.hasNamespaceImport,
+            });
+            continue;
+        }
+        if (!localDeclarations.has(localName)) {
+            throw new Error(`[auklet:css] Unable to resolve exported symbol "${localName}" for CSS auto import.\n` +
+                `File: ${file}`);
+        }
+    }
+};
+const getExportedNames = (node) => {
+    if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
+        return [];
+    }
+    return node.exportClause.elements
+        .filter((element) => !element.isTypeOnly)
+        .map((element) => (element.propertyName ?? element.name).text);
+};
+const isTypeOnlyImportClause = (importClause) => {
+    return importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword;
+};
+const createNamespaceImportError = (file, importPath) => {
+    return new Error(`Namespace import is not supported for CSS auto import: ${importPath}\n` +
+        `Use named imports instead, for example: import { Component } from '${importPath}'.\n` +
+        `File: ${file}`);
+};

package/dist/css/core/styleModuleEntryPlanner.d.ts

@@ -1,29 +1,26 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export type ModuleStyleEntryPlan = {
-  sourceDir: string;
-  moduleStyleImports: Array<string>;
-  ownStyleFiles: Array<string>;
+    sourceDir: string;
+    moduleStyleImports: Array<string>;
+    ownStyleFiles: Array<string>;
 };
 export declare class StyleModuleEntryPlanner {
-  private readonly packageContext;
-  private readonly styleFilesByDir;
-  private readonly importedStyleFiles;
-  constructor(packageContext: StylePackageContext);
-  createEntries(moduleStyleImports: Map<string, Array<string>>): {
-    sourceDir: string;
-    moduleStyleImports: string[];
-    ownStyleFiles: string[];
-  }[];
-  createEntry(
-    sourceDir: string,
-    moduleStyleImports: Map<string, Array<string>>,
-  ): {
-    sourceDir: string;
-    moduleStyleImports: string[];
-    ownStyleFiles: string[];
-  };
-  private getSourceDirs;
-  private getSourceModuleDirs;
-  private getOwnStyleDirs;
-  private getOwnStyleFiles;
+    private readonly packageContext;
+    private readonly importedStyleFiles;
+    private readonly styleFilesByDir;
+    constructor(packageContext: StylePackageContext);
+    createEntries(moduleStyleImports: Map<string, Array<string>>): {
+        sourceDir: string;
+        moduleStyleImports: string[];
+        ownStyleFiles: string[];
+    }[];
+    createEntry(sourceDir: string, moduleStyleImports: Map<string, Array<string>>): {
+        sourceDir: string;
+        moduleStyleImports: string[];
+        ownStyleFiles: string[];
+    };
+    private getSourceDirs;
+    private getSourceModuleDirs;
+    private getOwnStyleDirs;
+    private getOwnStyleFiles;
 }