auklet 0.0.15 → 0.0.17

package/dist/css/vite/moduleGraph/graph.js

@@ -2,72 +2,57 @@ import path from 'node:path';
 import { aukletConfigFile } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
-import { ModuleStyleGraphRequestCache } from '#auklet/css/vite/moduleGraph/requestCache';
-import { StyleCodeFactory } from '#auklet/css/vite/moduleGraph/styleCodeFactory';
 import { parsePackageStyleId } from '#auklet/css/vite/moduleGraph/styleId';
-import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
-import { normalizeFileKey, toWatchPath } from '#auklet/utils';
-// package style graph 的对外门面，负责 workspace 发现、watch 边界和请求分发。
+import { StyleCodeFactory } from '#auklet/css/vite/moduleGraph/styleCodeFactory';
+import { ModuleStyleGraphRequestCache } from '#auklet/css/vite/moduleGraph/requestCache';
+import { createMonorepoPackageSource } from '#auklet/css/vite/moduleGraph/packageSource/monorepo';
+import { normalizeFileKey } from '#auklet/utils';
+// package style graph 的对外门面，负责 package source、watch 边界和请求分发。
 export class ModuleStyleGraph {
-  config;
-  workspaceRoot;
-  packagesDir;
-  styleCodeFactory;
-  loadAukletConfig;
-  constructor(options) {
-    this.config = options.config ?? moduleStyleBuildConfig;
-    this.workspaceRoot = normalizeFileKey(options.workspaceRoot);
-    this.packagesDir = options.packagesDir ?? 'packages';
-    this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
-    this.styleCodeFactory = new StyleCodeFactory(this.config);
-  }
-  parsePackageStyleId(id) {
-    return parsePackageStyleId(id, this.getWorkspacePackageNames());
-  }
-  isWorkspaceSourceGraphFile(file) {
-    const normalizedFile = normalizeFileKey(file);
-    const packagesRoot = normalizeFileKey(
-      path.join(this.workspaceRoot, this.packagesDir),
-    );
-    if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
-      return false;
+    config;
+    packageSource;
+    styleCodeFactory;
+    loadAukletConfig;
+    constructor(options) {
+        this.config = options.config ?? moduleStyleBuildConfig;
+        const mode = options.mode ?? 'monorepo';
+        if (mode === 'package') {
+            throw new Error('[auklet:css] package mode is not supported yet.');
+        }
+        this.packageSource = createMonorepoPackageSource({
+            workspaceRoot: normalizeFileKey(options.workspaceRoot),
+            packagesDir: options.packagesDir ?? 'packages',
+            styleExtensions: this.config.styleExtensions,
+        });
+        this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
+        this.styleCodeFactory = new StyleCodeFactory(this.config);
+    }
+    parsePackageStyleId(id) {
+        return parsePackageStyleId(id, this.getPackageNames());
+    }
+    isSourceGraphFile(file) {
+        return this.packageSource.isSourceGraphFile(file);
+    }
+    isStyleConfigFile(file) {
+        return normalizeFileKey(file).endsWith(aukletConfigFile);
+    }
+    isStyleFile(file) {
+        return this.config.styleExtensions.includes(path.extname(file));
+    }
+    getPackageNames() {
+        return this.packageSource.getPackageNames();
+    }
+    getWatchRoots() {
+        return this.packageSource.getWatchRoots();
+    }
+    createPackageStyleCode(parsed) {
+        return this.styleCodeFactory.createPackageStyleCode(parsed, this.createRequestCache());
     }
-    if (normalizedFile.endsWith(aukletConfigFile)) return true;
-    if (SOURCE_COMPONENT_MODULE_RE.test(normalizedFile)) {
-      return true;
+    createRequestCache() {
+        return new ModuleStyleGraphRequestCache({
+            packageSource: this.packageSource,
+            config: this.config,
+            loadAukletConfig: this.loadAukletConfig,
+        });
     }
-    return this.config.styleExtensions.some((extension) =>
-      normalizedFile.endsWith(extension),
-    );
-  }
-  isStyleConfigFile(file) {
-    return normalizeFileKey(file).endsWith(aukletConfigFile);
-  }
-  isStyleFile(file) {
-    return this.config.styleExtensions.includes(path.extname(file));
-  }
-  getWorkspacePackageNames() {
-    return this.createRequestCache().getWorkspacePackageNames();
-  }
-  getWatchRoots() {
-    const packagesRoot = path.join(this.workspaceRoot, this.packagesDir);
-    return [
-      toWatchPath(packagesRoot, '*', 'src'),
-      toWatchPath(packagesRoot, '*', aukletConfigFile),
-    ];
-  }
-  createPackageStyleCode(parsed) {
-    return this.styleCodeFactory.createPackageStyleCode(
-      parsed,
-      this.createRequestCache(),
-    );
-  }
-  createRequestCache() {
-    return new ModuleStyleGraphRequestCache({
-      workspaceRoot: this.workspaceRoot,
-      packagesDir: this.packagesDir,
-      config: this.config,
-      loadAukletConfig: this.loadAukletConfig,
-    });
-  }
 }

package/dist/css/vite/moduleGraph/loadResult.d.ts

@@ -1,7 +1,5 @@
 import type { PackageStyleLoadResult } from '#auklet/css/vite/moduleGraph/types';
-export declare function mergeLoadResults(
-  ...results: Array<PackageStyleLoadResult>
-): {
-  code: string;
-  watchFiles: string[];
+export declare function mergeLoadResults(...results: Array<PackageStyleLoadResult>): {
+    code: string;
+    watchFiles: string[];
 };

package/dist/css/vite/moduleGraph/loadResult.js

@@ -1,12 +1,10 @@
 // 合并递归 style graph 加载结果，同时保留 CSS 顺序并去重 watch files。
 export function mergeLoadResults(...results) {
-  return {
-    code: results
-      .map((result) => result.code)
-      .filter((code) => code.trim())
-      .join('\n'),
-    watchFiles: Array.from(
-      new Set(results.flatMap((result) => result.watchFiles)),
-    ),
-  };
+    return {
+        code: results
+            .map((result) => result.code)
+            .filter((code) => code.trim())
+            .join('\n'),
+        watchFiles: Array.from(new Set(results.flatMap((result) => result.watchFiles))),
+    };
 }

package/dist/css/vite/moduleGraph/packageSource/monorepo.d.ts

@@ -0,0 +1,7 @@
+import type { StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
+export type MonorepoPackageSourceOptions = {
+    workspaceRoot: string;
+    packagesDir: string;
+    styleExtensions: Array<string>;
+};
+export declare function createMonorepoPackageSource(options: MonorepoPackageSourceOptions): StylePackageSource;

package/dist/css/vite/moduleGraph/packageSource/monorepo.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { aukletConfigFile } from '#auklet/config';
+import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
+import { normalizeFileKey, toWatchPath } from '#auklet/utils';
+export function createMonorepoPackageSource(options) {
+    return new MonorepoPackageSource(options);
+}
+class MonorepoPackageSource {
+    options;
+    packages;
+    packageNames;
+    workspaceRoot;
+    constructor(options) {
+        this.options = options;
+        this.workspaceRoot = normalizeFileKey(options.workspaceRoot);
+    }
+    getPackages() {
+        if (this.packages)
+            return this.packages;
+        const packagesRoot = path.join(this.workspaceRoot, this.options.packagesDir);
+        if (!fs.existsSync(packagesRoot)) {
+            this.packages = [];
+            return this.packages;
+        }
+        this.packages = fs
+            .readdirSync(packagesRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .flatMap((entry) => {
+            const packageRoot = path.join(packagesRoot, entry.name);
+            const packageJsonPath = path.join(packageRoot, 'package.json');
+            if (!fs.existsSync(packageJsonPath))
+                return [];
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (!pkg.name)
+                return [];
+            return [
+                {
+                    packageName: pkg.name,
+                    packageRoot,
+                },
+            ];
+        });
+        return this.packages;
+    }
+    getPackageNames() {
+        this.packageNames ??= this.getPackages().map((item) => item.packageName);
+        return this.packageNames;
+    }
+    isKnownPackageName(packageName) {
+        return this.getPackageNames().includes(packageName);
+    }
+    isSourceGraphFile(file) {
+        const normalizedFile = normalizeFileKey(file);
+        const packagesRoot = normalizeFileKey(path.join(this.workspaceRoot, this.options.packagesDir));
+        if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
+            return false;
+        }
+        if (normalizedFile.endsWith(aukletConfigFile))
+            return true;
+        if (SOURCE_COMPONENT_MODULE_RE.test(normalizedFile))
+            return true;
+        return this.options.styleExtensions.some((extension) => normalizedFile.endsWith(extension));
+    }
+    getWatchRoots() {
+        const packagesRoot = path.join(this.workspaceRoot, this.options.packagesDir);
+        return [
+            toWatchPath(packagesRoot, '*', 'src'),
+            toWatchPath(packagesRoot, '*', aukletConfigFile),
+        ];
+    }
+}

package/dist/css/vite/moduleGraph/packageSource/types.d.ts

@@ -0,0 +1,11 @@
+export type StylePackageInfo = {
+    packageName: string;
+    packageRoot: string;
+};
+export interface StylePackageSource {
+    getPackages(): Array<StylePackageInfo>;
+    getPackageNames(): Array<string>;
+    isKnownPackageName(packageName: string): boolean;
+    isSourceGraphFile(file: string): boolean;
+    getWatchRoots(): Array<string>;
+}

package/dist/css/vite/moduleGraph/requestCache.d.ts

@@ -1,69 +1,58 @@
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
-import type {
-  ModuleStyleBuildConfig,
-  NormalizedAukletConfig,
-  ResolvedModuleStyleBuildContext,
-} from '#auklet/types';
+import type { ModuleStyleBuildConfig, NormalizedAukletConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
 import type { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
-import type {
-  LoadAukletConfig,
-  PackageStyleId,
-} from '#auklet/css/vite/moduleGraph/types';
+import type { StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
+import type { LoadAukletConfig, PackageStyleId } from '#auklet/css/vite/moduleGraph/types';
 export type PackageStyleContext = {
-  normalizedConfig: NormalizedAukletConfig;
-  context: ResolvedModuleStyleBuildContext;
-  packageContext: StylePackageContext;
-  packageName: string;
-  configPath: string;
-  resolver: WorkspaceStyleResolver;
-  sourceRoot: string;
-  styleProcessor: StyleProcessor;
+    normalizedConfig: NormalizedAukletConfig;
+    context: ResolvedModuleStyleBuildContext;
+    packageContext: StylePackageContext;
+    packageName: string;
+    configPath: string;
+    resolver: WorkspaceStyleResolver;
+    sourceRoot: string;
+    styleProcessor: StyleProcessor;
 };
 export type ModuleStyleGraphRequestCacheOptions = {
-  workspaceRoot: string;
-  packagesDir: string;
-  config: ModuleStyleBuildConfig;
-  loadAukletConfig?: LoadAukletConfig;
+    packageSource: StylePackageSource;
+    config: ModuleStyleBuildConfig;
+    loadAukletConfig?: LoadAukletConfig;
 };
 export declare class ModuleStyleGraphRequestCache {
-  private readonly options;
-  private workspacePackages?;
-  private workspacePackageNames?;
-  private readonly contexts;
-  private readonly loadAukletConfig;
-  constructor(options: ModuleStyleGraphRequestCacheOptions);
-  getWorkspacePackageNames(): string[];
-  isWorkspacePackageName(packageName: string): boolean;
-  getContext(parsed: PackageStyleId): Promise<
-    | PackageStyleContext
-    | {
+    private readonly options;
+    private readonly contexts;
+    private readonly loadAukletConfig;
+    constructor(options: ModuleStyleGraphRequestCacheOptions);
+    getPackageNames(): string[];
+    isKnownPackageName(packageName: string): boolean;
+    getContext(parsed: PackageStyleId): Promise<PackageStyleContext | {
         normalizedConfig: {
-          source: string;
-          output: string;
-          modules: boolean;
-          build: {
-            formats: Array<import('#auklet/types').PackageBuildFormat>;
-            target: import('#auklet/types').PackageBuildTarget;
-            platform: import('#auklet/types').PackageBuildPlatform;
-            banner?: string;
-            externals?: Array<string>;
-            alias?: Record<string, string>;
-            mainFields?: Array<string>;
-            globals?: Record<string, string>;
-            configureTsdown?: import('#auklet/types').ConfigureTsdown;
-            tsconfig?: string;
-          };
-          styles: {
-            themes: {};
-            dependencies: {
-              [k: string]: {
-                entry: string | string[] | undefined;
-                themes: Record<string, string> | undefined;
-                components: string | string[] | undefined;
-              };
+            source: string;
+            output: string;
+            modules: boolean;
+            build: {
+                formats: Array<import("#auklet/types").PackageBuildFormat>;
+                target: import("#auklet/types").PackageBuildTarget;
+                platform: import("#auklet/types").PackageBuildPlatform;
+                banner?: string;
+                externals?: Array<string>;
+                alias?: Record<string, string>;
+                mainFields?: Array<string>;
+                globals?: Record<string, string>;
+                configureTsdown?: import("#auklet/types").ConfigureTsdown;
+                tsconfig?: string;
+            };
+            styles: {
+                themes: {};
+                dependencies: {
+                    [k: string]: {
+                        entry: string | string[] | undefined;
+                        themes: Record<string, string> | undefined;
+                        components: string | string[] | undefined;
+                    };
+                };
             };
-          };
         };
         context: ResolvedModuleStyleBuildContext;
         packageContext: StylePackageContext;
@@ -72,9 +61,6 @@ export declare class ModuleStyleGraphRequestCache {
         resolver: WorkspaceStyleResolver;
         sourceRoot: string;
         styleProcessor: StyleProcessor;
-      }
-    | null
-  >;
-  private createContext;
-  private getWorkspacePackages;
+    } | null>;
+    private createContext;
 }

package/dist/css/vite/moduleGraph/requestCache.js

@@ -1,92 +1,59 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export class ModuleStyleGraphRequestCache {
-  options;
-  workspacePackages;
-  workspacePackageNames;
-  contexts = new Map();
-  loadAukletConfig;
-  constructor(options) {
-    this.options = options;
-    this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
-  }
-  getWorkspacePackageNames() {
-    this.workspacePackageNames ??= this.getWorkspacePackages().map(
-      (item) => item.packageName,
-    );
-    return this.workspacePackageNames;
-  }
-  isWorkspacePackageName(packageName) {
-    return this.getWorkspacePackageNames().includes(packageName);
-  }
-  async getContext(parsed) {
-    const cachedContext = this.contexts.get(parsed.packageName);
-    if (cachedContext) return cachedContext;
-    const context = this.createContext(parsed);
-    this.contexts.set(parsed.packageName, context);
-    return context;
-  }
-  async createContext(parsed) {
-    const workspacePackage = this.getWorkspacePackages().find(
-      (item) => item.packageName === parsed.packageName,
-    );
-    if (!workspacePackage) return null;
-    const packageRoot = workspacePackage.packageRoot;
-    if (!fs.existsSync(packageRoot)) return null;
-    const rawConfig = await this.loadAukletConfig(packageRoot, {
-      cacheBust: true,
-    });
-    const normalizedConfig = normalizeAukletConfig(rawConfig);
-    const context = {
-      packageRoot,
-      sourceDir: normalizedConfig.source,
-      outputDir: normalizedConfig.output,
-    };
-    const packageContext = new StylePackageContext({
-      config: this.options.config,
-      context,
-      normalizedConfig,
-    });
-    return {
-      normalizedConfig,
-      context,
-      packageContext,
-      packageName: parsed.packageName,
-      configPath: path.join(packageRoot, aukletConfigFile),
-      resolver: packageContext.resolver,
-      sourceRoot: packageContext.sourceRoot,
-      styleProcessor: packageContext.styleProcessor,
-    };
-  }
-  getWorkspacePackages() {
-    if (this.workspacePackages) return this.workspacePackages;
-    const packagesRoot = path.join(
-      this.options.workspaceRoot,
-      this.options.packagesDir,
-    );
-    if (!fs.existsSync(packagesRoot)) {
-      this.workspacePackages = [];
-      return this.workspacePackages;
+    options;
+    contexts = new Map();
+    loadAukletConfig;
+    constructor(options) {
+        this.options = options;
+        this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
     }
-    this.workspacePackages = fs
-      .readdirSync(packagesRoot, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .flatMap((entry) => {
-        const packageRoot = path.join(packagesRoot, entry.name);
-        const packageJsonPath = path.join(packageRoot, 'package.json');
-        if (!fs.existsSync(packageJsonPath)) return [];
-        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        if (!pkg.name) return [];
-        return [
-          {
-            packageName: pkg.name,
+    getPackageNames() {
+        return this.options.packageSource.getPackageNames();
+    }
+    isKnownPackageName(packageName) {
+        return this.options.packageSource.isKnownPackageName(packageName);
+    }
+    async getContext(parsed) {
+        const cachedContext = this.contexts.get(parsed.packageName);
+        if (cachedContext)
+            return cachedContext;
+        const context = this.createContext(parsed);
+        this.contexts.set(parsed.packageName, context);
+        return context;
+    }
+    async createContext(parsed) {
+        const stylePackage = this.options.packageSource
+            .getPackages()
+            .find((item) => item.packageName === parsed.packageName);
+        if (!stylePackage)
+            return null;
+        const packageRoot = stylePackage.packageRoot;
+        const rawConfig = await this.loadAukletConfig(packageRoot, {
+            cacheBust: true,
+        });
+        const normalizedConfig = normalizeAukletConfig(rawConfig);
+        const context = {
             packageRoot,
-          },
-        ];
-      });
-    return this.workspacePackages;
-  }
+            sourceDir: normalizedConfig.source,
+            outputDir: normalizedConfig.output,
+        };
+        const packageContext = new StylePackageContext({
+            config: this.options.config,
+            context,
+            normalizedConfig,
+        });
+        return {
+            normalizedConfig,
+            context,
+            packageContext,
+            packageName: parsed.packageName,
+            configPath: path.join(packageRoot, aukletConfigFile),
+            resolver: packageContext.resolver,
+            sourceRoot: packageContext.sourceRoot,
+            styleProcessor: packageContext.styleProcessor,
+        };
+    }
 }

package/dist/css/vite/moduleGraph/styleCodeFactory.d.ts

@@ -2,22 +2,19 @@ import type { ModuleStyleBuildConfig } from '#auklet/types';
 import type { ModuleStyleGraphRequestCache } from '#auklet/css/vite/moduleGraph/requestCache';
 import type { PackageStyleId } from '#auklet/css/vite/moduleGraph/types';
 export declare class StyleCodeFactory {
-  private readonly config;
-  constructor(config: ModuleStyleBuildConfig);
-  createPackageStyleCode(
-    parsed: PackageStyleId,
-    cache: ModuleStyleGraphRequestCache,
-  ): Promise<{
-    code: string;
-    watchFiles: string[];
-  }>;
-  private createStyleCode;
-  private createDependencyStyleCode;
-  private createExternalStyleCode;
-  private createThemeStyleCode;
-  private createModuleStyleCode;
-  private createSourceModuleStyleCode;
-  private toDevModuleImportSpecifier;
-  private toDevExternalStyleSpecifier;
-  private parsePackageStyleIdInRequest;
+    private readonly config;
+    constructor(config: ModuleStyleBuildConfig);
+    createPackageStyleCode(parsed: PackageStyleId, cache: ModuleStyleGraphRequestCache): Promise<{
+        code: string;
+        watchFiles: string[];
+    }>;
+    private createStyleCode;
+    private createDependencyStyleCode;
+    private createExternalStyleCode;
+    private createThemeStyleCode;
+    private createModuleStyleCode;
+    private createSourceModuleStyleCode;
+    private toDevModuleImportSpecifier;
+    private toDevExternalStyleSpecifier;
+    private parsePackageStyleIdInRequest;
 }