auklet 0.0.3 → 0.0.5

package/dist/css/core/style/plan.js

@@ -0,0 +1,27 @@
+import {
+  getExternalStyleDependencies,
+  getGlobalStyleDependencies,
+  getThemeNames,
+  getThemeStyleDependencies,
+} from '#auklet/css/core/style/dependencies';
+const dependenciesPart = (specifiers) => ({ type: 'dependencies', specifiers });
+export function createStyleEntryParts(config) {
+  return [
+    dependenciesPart(getGlobalStyleDependencies(config)),
+    { type: 'themes', themeNames: getThemeNames(config) },
+    { type: 'module' },
+  ];
+}
+export function createThemeEntryParts(config, themeName, options = {}) {
+  const themePart = { type: 'theme', themeName };
+  if (options.includeDependencies === false) {
+    return [themePart];
+  }
+  return [
+    dependenciesPart(getThemeStyleDependencies(config, themeName)),
+    themePart,
+  ];
+}
+export function createExternalEntryParts(config) {
+  return [dependenciesPart(getExternalStyleDependencies(config))];
+}

package/dist/css/core/style/specifier.d.ts

@@ -0,0 +1,14 @@
+export type PackageStyleSpecifier = {
+  packageName: string;
+  stylePath: string;
+};
+export declare function parsePackageStyleSpecifier(specifier: string): {
+  packageName: string;
+  stylePath: string;
+} | null;
+export declare function joinDependencySpecifier(
+  packageName: string,
+  dependencyPath: string,
+): string;
+export declare function createImportCode(specifiers: Array<string>): string;
+export declare function removeStyleExtension(stylePath: string): string;

package/dist/css/core/style/specifier.js

@@ -0,0 +1,27 @@
+import path from 'node:path';
+export function parsePackageStyleSpecifier(specifier) {
+  if (specifier.startsWith('.')) return null;
+  const parts = specifier.split('/');
+  const packageName = specifier.startsWith('@')
+    ? `${parts.shift() ?? ''}/${parts.shift() ?? ''}`
+    : parts.shift() ?? '';
+  if (!packageName) return null;
+  return {
+    packageName,
+    stylePath: parts.join('/'),
+  };
+}
+export function joinDependencySpecifier(packageName, dependencyPath) {
+  if (!dependencyPath) return packageName;
+  return dependencyPath.startsWith('/')
+    ? `${packageName}${dependencyPath}`
+    : `${packageName}/${dependencyPath}`;
+}
+export function createImportCode(specifiers) {
+  return Array.from(new Set(specifiers))
+    .map((specifier) => `@import "${specifier}";`)
+    .join('\n');
+}
+export function removeStyleExtension(stylePath) {
+  return stylePath.slice(0, -path.extname(stylePath).length);
+}

package/dist/css/core/{moduleStyleImportCollector.d.ts → styleImports/collector.d.ts}

@@ -1,4 +1,4 @@
-import type { CssOptions } from '#auklet/types';
+import type { NormalizedAukletConfig } from '#auklet/types';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
 export declare class ModuleStyleImportCollector {
   private readonly srcRoot;
@@ -12,8 +12,10 @@ export declare class ModuleStyleImportCollector {
     resolver: WorkspaceStyleResolver,
     styleExtensions?: Array<string>,
   );
-  collect(files: Array<string>, cssOptions: CssOptions): Map<string, string[]>;
-  private getImportDeclarations;
+  collect(
+    files: Array<string>,
+    config: NormalizedAukletConfig,
+  ): Map<string, string[]>;
   private collectSourceImportStyle;
   private resolveSourceImportStyleEntry;
   private resolveSourceImportPath;
@@ -24,6 +26,4 @@ export declare class ModuleStyleImportCollector {
   private getImportPathValues;
   private createStyleSpecifier;
   private createDirectStyleSpecifier;
-  private joinDependencySpecifier;
-  private getImportedNames;
 }

package/dist/css/core/{moduleStyleImportCollector.js → styleImports/collector.js}

@@ -1,16 +1,25 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import ts from 'typescript';
 import { isArray } from 'aidly';
+import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
+import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
 import {
   appendUniqueMapValue,
   getSourceModuleDir,
-  SOURCE_DECLARATION_RE,
   POSIX_SEPARATOR,
-  SOURCE_MODULE_RE,
 } from '#auklet/utils';
+import {
+  collectModuleStyleSourceReferences,
+  getSourceReferenceImportedNames,
+  isTypeOnlySourceReference,
+} from '#auklet/css/core/styleImports/sourceReference';
 const GLOBSTAR_TOKEN = '**';
 export class ModuleStyleImportCollector {
+  srcRoot;
+  packageRoot;
+  resolver;
+  styleExtensions;
+  sourceImportAliasRules;
   constructor(srcRoot, packageRoot, resolver, styleExtensions = ['.css']) {
     this.srcRoot = srcRoot;
     this.packageRoot = packageRoot;
@@ -18,18 +27,18 @@ export class ModuleStyleImportCollector {
     this.styleExtensions = styleExtensions;
     this.sourceImportAliasRules = this.createSourceImportAliasRules();
   }
-  collect(files, cssOptions) {
+  collect(files, config) {
     const entries = new Map();
-    const rules = this.createAutoImportRules(cssOptions);
+    const rules = this.createAutoImportRules(config);
     for (const file of files) {
-      if (!SOURCE_MODULE_RE.test(file) || SOURCE_DECLARATION_RE.test(file)) {
+      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 = this.getImportDeclarations(file, code);
+      const imports = collectModuleStyleSourceReferences(file, code);
       for (const item of imports) {
         this.collectSourceImportStyle(
           entries,
@@ -37,14 +46,17 @@ export class ModuleStyleImportCollector {
           sourceModuleDir,
           item,
         );
+        if (isTypeOnlySourceReference(item)) continue;
         const importPath = item.importPath;
         const ruleMatches = this.matchAutoImportRules(rules, importPath);
         if (!ruleMatches.length) continue;
-        const directSpecifiers = ruleMatches
-          .map((ruleMatch) =>
-            this.createDirectStyleSpecifier(ruleMatch.rule, importPath),
-          )
-          .filter((specifier) => Boolean(specifier));
+        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);
@@ -55,7 +67,7 @@ export class ModuleStyleImportCollector {
           continue;
         }
         for (const ruleMatch of ruleMatches) {
-          const importedNames = this.getImportedNames(file, item);
+          const importedNames = getSourceReferenceImportedNames(file, item);
           for (const importedName of importedNames) {
             const specifier = this.createStyleSpecifier(
               ruleMatch.rule,
@@ -73,37 +85,8 @@ export class ModuleStyleImportCollector {
     }
     return entries;
   }
-  getImportDeclarations(file, code) {
-    const imports = [];
-    const sourceFile = ts.createSourceFile(
-      file,
-      code,
-      ts.ScriptTarget.Latest,
-      false,
-      file.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
-    );
-    sourceFile.forEachChild((node) => {
-      if (
-        !ts.isImportDeclaration(node) ||
-        !ts.isStringLiteral(node.moduleSpecifier)
-      ) {
-        return;
-      }
-      imports.push({
-        importPath: node.moduleSpecifier.text,
-        importClause: node.importClause,
-      });
-    });
-    return imports;
-  }
   collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item) {
-    var _a;
-    if (
-      (_a = item.importClause) === null || _a === void 0
-        ? void 0
-        : _a.isTypeOnly
-    )
-      return;
+    if (isTypeOnlySourceReference(item)) return;
     const importedStyleEntry = this.resolveSourceImportStyleEntry(
       sourceDir,
       item.importPath,
@@ -145,14 +128,11 @@ export class ModuleStyleImportCollector {
     return null;
   }
   createSourceImportAliasRules() {
-    var _a;
     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(
-      (_a = packageJson.imports) !== null && _a !== void 0 ? _a : {},
-    )) {
+    for (const [name, target] of Object.entries(packageJson.imports ?? {})) {
       if (
         !name.endsWith(`${POSIX_SEPARATOR}*`) ||
         typeof target !== 'string' ||
@@ -170,22 +150,20 @@ export class ModuleStyleImportCollector {
     const relative = path.relative(fromDir, file).split(path.sep).join('/');
     return relative.startsWith('.') ? relative : `./${relative}`;
   }
-  createAutoImportRules(cssOptions) {
-    var _a;
+  createAutoImportRules(config) {
     const rules = [];
     for (const [packageName, dependency] of Object.entries(
-      (_a = cssOptions.cssDependencies) !== null && _a !== void 0 ? _a : {},
+      config.styles.dependencies,
     )) {
-      const dependencyPaths = isArray(dependency.component)
-        ? dependency.component
-        : [dependency.component].filter((value) => Boolean(value));
+      const dependencyPaths = isArray(dependency.components)
+        ? dependency.components
+        : dependency.components
+        ? [dependency.components]
+        : [];
       for (const dependencyPath of dependencyPaths) {
         rules.push({
           packageName,
-          outputPattern: this.joinDependencySpecifier(
-            packageName,
-            dependencyPath,
-          ),
+          outputPattern: joinDependencySpecifier(packageName, dependencyPath),
         });
       }
     }
@@ -220,9 +198,7 @@ export class ModuleStyleImportCollector {
       const matchedValue = pathValues.shift();
       if (matchedValue) return matchedValue;
       if (token === GLOBSTAR_TOKEN) return importedName;
-      return matchedValue !== null && matchedValue !== void 0
-        ? matchedValue
-        : importedName;
+      return matchedValue ?? importedName;
     });
   }
   createDirectStyleSpecifier(rule, importPath) {
@@ -243,43 +219,4 @@ export class ModuleStyleImportCollector {
     }
     return `${importPath}${suffix}`;
   }
-  joinDependencySpecifier(packageName, dependencyPath) {
-    if (!dependencyPath) return packageName;
-    if (dependencyPath.startsWith(POSIX_SEPARATOR)) {
-      return `${packageName}${dependencyPath}`;
-    }
-    return `${packageName}${POSIX_SEPARATOR}${dependencyPath}`;
-  }
-  getImportedNames(file, item) {
-    var _a;
-    const importClause = item.importClause;
-    if (!importClause || importClause.isTypeOnly) {
-      return [];
-    }
-    const names = [];
-    if (importClause.name) {
-      names.push(importClause.name.text);
-    }
-    const namedBindings = importClause.namedBindings;
-    if (!namedBindings) {
-      return names;
-    }
-    if (ts.isNamespaceImport(namedBindings)) {
-      throw new Error(
-        `Namespace import is not supported for CSS auto import: ${item.importPath}\n` +
-          `Use named imports instead, for example: import { Component } from '${item.importPath}'.\n` +
-          `File: ${file}`,
-      );
-    }
-    for (const element of namedBindings.elements) {
-      if (element.isTypeOnly) continue;
-      names.push(
-        ((_a = element.propertyName) !== null && _a !== void 0
-          ? _a
-          : element.name
-        ).text,
-      );
-    }
-    return names;
-  }
 }

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

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+export type ModuleStyleSourceReference = {
+  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[];

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

@@ -0,0 +1,193 @@
+import ts from 'typescript';
+export function collectModuleStyleSourceReferences(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 isTypeOnlySourceReference(item) {
+  return isTypeOnlyImportClause(item.importClause) || item.isTypeOnly;
+}
+export function getSourceReferenceImportedNames(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

@@ -0,0 +1,29 @@
+import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
+export type ModuleStyleEntryPlan = {
+  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;
+}

package/dist/css/core/styleModuleEntryPlanner.js

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
+import { groupStyleFilesByDir } from '#auklet/css/core/style/files';
+import { getSourceModuleDir, toPosixPath } from '#auklet/utils';
+export class StyleModuleEntryPlanner {
+  packageContext;
+  styleFilesByDir;
+  importedStyleFiles;
+  constructor(packageContext) {
+    this.packageContext = packageContext;
+    this.styleFilesByDir = groupStyleFilesByDir(
+      this.packageContext.sourceRoot,
+      this.packageContext.styleFiles,
+    );
+    this.importedStyleFiles =
+      this.packageContext.styleProcessor.collectImportedStyleFiles(
+        this.packageContext.styleFiles,
+      );
+  }
+  createEntries(moduleStyleImports) {
+    return this.getSourceDirs(moduleStyleImports).map((sourceDir) =>
+      this.createEntry(sourceDir, moduleStyleImports),
+    );
+  }
+  createEntry(sourceDir, moduleStyleImports) {
+    return {
+      sourceDir,
+      moduleStyleImports: moduleStyleImports.get(sourceDir) ?? [],
+      ownStyleFiles: this.getOwnStyleFiles(sourceDir),
+    };
+  }
+  getSourceDirs(moduleStyleImports) {
+    return Array.from(
+      new Set([
+        ...this.getSourceModuleDirs(),
+        ...this.getOwnStyleDirs(),
+        ...moduleStyleImports.keys(),
+      ]),
+    ).filter((sourceDir) => sourceDir !== '.');
+  }
+  getSourceModuleDirs() {
+    return this.packageContext.sourceFiles
+      .filter((sourceFile) => SOURCE_COMPONENT_MODULE_RE.test(sourceFile))
+      .map((sourceFile) => {
+        return getSourceModuleDir(
+          path.relative(this.packageContext.sourceRoot, sourceFile),
+        );
+      })
+      .filter((sourceModuleDir) => {
+        return toPosixPath(sourceModuleDir).split('/').length === 2;
+      });
+  }
+  getOwnStyleDirs() {
+    return Array.from(this.styleFilesByDir.entries())
+      .filter(([, dirStyleFiles]) =>
+        dirStyleFiles.some(
+          (styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)),
+        ),
+      )
+      .map(([sourceDir]) => sourceDir);
+  }
+  getOwnStyleFiles(sourceDir) {
+    return (this.styleFilesByDir.get(sourceDir) ?? []).filter(
+      (styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)),
+    );
+  }
+}

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

@@ -0,0 +1,27 @@
+import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
+import { StyleProcessor } from '#auklet/css/core/styleProcessor';
+import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+import type {
+  ModuleStyleBuildConfig,
+  NormalizedAukletConfig,
+  ResolvedModuleStyleBuildContext,
+} from '#auklet/types';
+export type StylePackageContextOptions = {
+  config: ModuleStyleBuildConfig;
+  context: ResolvedModuleStyleBuildContext;
+  normalizedConfig: NormalizedAukletConfig;
+};
+export declare class StylePackageContext {
+  private readonly options;
+  readonly normalizedConfig: NormalizedAukletConfig;
+  readonly sourceRoot: string;
+  readonly resolver: WorkspaceStyleResolver;
+  readonly styleProcessor: StyleProcessor;
+  readonly importCollector: ModuleStyleImportCollector;
+  readonly sourceFiles: Array<string>;
+  readonly themeFiles: Map<string, string>;
+  readonly themeNames: Array<string>;
+  readonly styleFiles: Array<string>;
+  constructor(options: StylePackageContextOptions);
+  getStyleFiles(files: Array<string>): string[];
+}