auklet 0.0.2 → 0.0.4

package/dist/css/core/moduleStyleImportCollector.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import ts from 'typescript';
 import { isArray } from 'aidly';
+import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
 import {
   appendUniqueMapValue,
   getSourceModuleDir,
@@ -11,6 +12,11 @@ import {
 } from '#auklet/utils';
 const GLOBSTAR_TOKEN = '**';
 export class ModuleStyleImportCollector {
+  srcRoot;
+  packageRoot;
+  resolver;
+  styleExtensions;
+  sourceImportAliasRules;
   constructor(srcRoot, packageRoot, resolver, styleExtensions = ['.css']) {
     this.srcRoot = srcRoot;
     this.packageRoot = packageRoot;
@@ -18,9 +24,9 @@ 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)) {
         continue;
@@ -40,11 +46,13 @@ export class ModuleStyleImportCollector {
         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);
@@ -97,13 +105,7 @@ export class ModuleStyleImportCollector {
     return imports;
   }
   collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item) {
-    var _a;
-    if (
-      (_a = item.importClause) === null || _a === void 0
-        ? void 0
-        : _a.isTypeOnly
-    )
-      return;
+    if (item.importClause?.isTypeOnly) return;
     const importedStyleEntry = this.resolveSourceImportStyleEntry(
       sourceDir,
       item.importPath,
@@ -145,14 +147,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 +169,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 +217,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,15 +238,7 @@ 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 [];
@@ -273,12 +260,7 @@ export class ModuleStyleImportCollector {
     }
     for (const element of namedBindings.elements) {
       if (element.isTypeOnly) continue;
-      names.push(
-        ((_a = element.propertyName) !== null && _a !== void 0
-          ? _a
-          : element.name
-        ).text,
-      );
+      names.push((element.propertyName ?? element.name).text);
     }
     return names;
   }

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

@@ -0,0 +1,20 @@
+import type { NormalizedAukletConfig } from '#auklet/types';
+export declare function getGlobalStyleDependencies(
+  config: NormalizedAukletConfig,
+): string[];
+export declare function getExternalStyleDependencies(
+  config: NormalizedAukletConfig,
+): string[];
+export declare function getThemeStyleDependencies(
+  config: NormalizedAukletConfig,
+  themeName: string,
+): string[];
+export declare function getThemeNames(config: NormalizedAukletConfig): string[];
+export declare function getThemeStyleEntries(config: NormalizedAukletConfig): {
+  themeName: string;
+  file: string;
+}[];
+export declare function resolveThemeStyleFiles(
+  config: NormalizedAukletConfig,
+  packageRoot: string,
+): Map<string, string>;

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

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { isArray } from 'aidly';
+import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
+export function getGlobalStyleDependencies(config) {
+  const dependencies = [];
+  for (const [packageName, dependency] of Object.entries(
+    config.styles.dependencies,
+  )) {
+    const globalDependencies = isArray(dependency.entry)
+      ? dependency.entry
+      : dependency.entry
+      ? [dependency.entry]
+      : [];
+    for (const globalDependency of globalDependencies) {
+      dependencies.push(joinDependencySpecifier(packageName, globalDependency));
+    }
+  }
+  return dependencies;
+}
+export function getExternalStyleDependencies(config) {
+  return getGlobalStyleDependencies(config);
+}
+export function getThemeStyleDependencies(config, themeName) {
+  const dependencies = [];
+  for (const [packageName, dependency] of Object.entries(
+    config.styles.dependencies,
+  )) {
+    const themeDependency = dependency.themes?.[themeName];
+    if (!themeDependency) continue;
+    dependencies.push(joinDependencySpecifier(packageName, themeDependency));
+  }
+  return dependencies;
+}
+export function getThemeNames(config) {
+  const names = new Set(Object.keys(config.styles.themes));
+  for (const dependency of Object.values(config.styles.dependencies)) {
+    for (const themeName of Object.keys(dependency.themes ?? {})) {
+      names.add(themeName);
+    }
+  }
+  return [...names];
+}
+export function getThemeStyleEntries(config) {
+  return Object.entries(config.styles.themes).map(([themeName, file]) => ({
+    themeName,
+    file,
+  }));
+}
+export function resolveThemeStyleFiles(config, packageRoot) {
+  const themeFiles = new Map();
+  for (const { themeName, file } of getThemeStyleEntries(config)) {
+    themeFiles.set(themeName, path.resolve(packageRoot, file));
+  }
+  return themeFiles;
+}

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

@@ -0,0 +1,8 @@
+export declare function groupStyleFilesByDir(
+  sourceRoot: string,
+  styleFiles: Array<string>,
+): Map<string, string[]>;
+export declare function createStyleFileKeySet(
+  styleFiles: Iterable<string>,
+): Set<string>;
+export declare function createStyleFileKey(styleFile: string): string;

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

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import { getSourceModuleDir, normalizeFileKey } from '#auklet/utils';
+export function groupStyleFilesByDir(sourceRoot, styleFiles) {
+  const styleFilesByDir = new Map();
+  for (const styleFile of styleFiles) {
+    const sourceRelative = path.relative(sourceRoot, styleFile);
+    const sourceDir = getSourceModuleDir(sourceRelative);
+    const values = styleFilesByDir.get(sourceDir) ?? [];
+    values.push(styleFile);
+    styleFilesByDir.set(sourceDir, values);
+  }
+  return styleFilesByDir;
+}
+export function createStyleFileKeySet(styleFiles) {
+  return new Set(Array.from(styleFiles, normalizeFileKey));
+}
+export function createStyleFileKey(styleFile) {
+  return normalizeFileKey(styleFile);
+}

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

@@ -0,0 +1,59 @@
+import type { NormalizedAukletConfig } from '#auklet/types';
+type StyleModulePart = {
+  type: 'module';
+};
+type StyleThemesPart = {
+  type: 'themes';
+  themeNames: Array<string>;
+};
+type DependenciesPart = {
+  type: 'dependencies';
+  specifiers: Array<string>;
+};
+type ThemePart = {
+  type: 'theme';
+  themeName: string;
+};
+export type ExternalEntryPart = DependenciesPart;
+export type ThemeEntryPart = DependenciesPart | ThemePart;
+export type StyleEntryPart =
+  | DependenciesPart
+  | StyleThemesPart
+  | StyleModulePart;
+export declare function createStyleEntryParts(config: NormalizedAukletConfig): (
+  | {
+      type: 'dependencies';
+      specifiers: string[];
+    }
+  | {
+      type: 'themes';
+      themeNames: string[];
+    }
+  | {
+      type: 'module';
+      themeNames?: undefined;
+    }
+)[];
+export declare function createThemeEntryParts(
+  config: NormalizedAukletConfig,
+  themeName: string,
+  options?: {
+    includeDependencies?: boolean;
+  },
+): (
+  | {
+      type: 'dependencies';
+      specifiers: string[];
+    }
+  | {
+      type: 'theme';
+      themeName: string;
+    }
+)[];
+export declare function createExternalEntryParts(
+  config: NormalizedAukletConfig,
+): {
+  type: 'dependencies';
+  specifiers: string[];
+}[];
+export {};

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/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,66 @@
+import path from 'node:path';
+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) => sourceFile.endsWith('.tsx'))
+      .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/moduleStyleImportCollector';
+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[];
+}

package/dist/css/core/stylePackageContext.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ModuleStyleImportCollector } from '#auklet/css/core/moduleStyleImportCollector';
+import { StyleProcessor } from '#auklet/css/core/styleProcessor';
+import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+import {
+  createStyleFileKey,
+  createStyleFileKeySet,
+} from '#auklet/css/core/style/files';
+import {
+  getThemeNames,
+  resolveThemeStyleFiles,
+} from '#auklet/css/core/style/dependencies';
+import { fileWalker } from '#auklet/utils';
+export class StylePackageContext {
+  options;
+  normalizedConfig;
+  sourceRoot;
+  resolver;
+  styleProcessor;
+  importCollector;
+  sourceFiles;
+  themeFiles;
+  themeNames;
+  styleFiles;
+  constructor(options) {
+    this.options = options;
+    const { config, context, normalizedConfig } = this.options;
+    this.normalizedConfig = normalizedConfig;
+    this.sourceRoot = path.join(context.packageRoot, context.sourceDir);
+    this.resolver = new WorkspaceStyleResolver(config, context);
+    this.styleProcessor = new StyleProcessor(config, this.resolver);
+    this.importCollector = new ModuleStyleImportCollector(
+      this.sourceRoot,
+      context.packageRoot,
+      this.resolver,
+      config.styleExtensions,
+    );
+    this.sourceFiles = fs.existsSync(this.sourceRoot)
+      ? fileWalker(this.sourceRoot)
+      : [];
+    this.themeFiles = resolveThemeStyleFiles(
+      normalizedConfig,
+      context.packageRoot,
+    );
+    this.themeNames = getThemeNames(normalizedConfig);
+    this.styleFiles = this.getStyleFiles(this.sourceFiles);
+  }
+  getStyleFiles(files) {
+    const themeFileKeys = createStyleFileKeySet(this.themeFiles.values());
+    return files
+      .filter((file) =>
+        this.options.config.styleExtensions.includes(path.extname(file)),
+      )
+      .filter((styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)));
+  }
+}

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

@@ -1,15 +1,15 @@
 import postcss, { type Root } from 'postcss';
-import type { ModuleCssBuildConfig } from '#auklet/types';
+import type { ModuleStyleBuildConfig } from '#auklet/types';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
 export declare class StyleProcessor {
   private readonly config;
   private readonly resolver;
-  constructor(config: ModuleCssBuildConfig, resolver: WorkspaceStyleResolver);
+  constructor(config: ModuleStyleBuildConfig, resolver: WorkspaceStyleResolver);
   createRoot(): postcss.Root;
   appendImportRule(root: Root, specifier: string): void;
   stringify(root: Root): string;
   appendStyleContent(target: Root, content: string, from: string): void;
-  readStyleFile(cssPath: string, seen?: Set<string>): string;
+  readStyleFile(stylePath: string, seen?: Set<string>): string;
   collectImportedStyleFiles(styleFiles: Array<string>): Set<string>;
   private parse;
   private parseImportSpecifier;