auklet 0.0.16 → 0.0.18

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

@@ -5,57 +5,58 @@ import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { parsePackageStyleId } from '#auklet/css/vite/moduleGraph/styleId';
 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 { MonorepoPackageSource } from '#auklet/css/vite/moduleGraph/packageSource/monorepo';
+import { SinglePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/singlePackage';
 import { normalizeFileKey } from '#auklet/utils';
 // package style graph 的对外门面，负责 package source、watch 边界和请求分发。
 export class ModuleStyleGraph {
-  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(),
-    );
-  }
-  createRequestCache() {
-    return new ModuleStyleGraphRequestCache({
-      packageSource: this.packageSource,
-      config: this.config,
-      loadAukletConfig: this.loadAukletConfig,
-    });
-  }
+    config;
+    packageSource;
+    styleCodeFactory;
+    loadAukletConfig;
+    constructor(options) {
+        this.config = options.config ?? moduleStyleBuildConfig;
+        this.styleCodeFactory = new StyleCodeFactory(this.config);
+        this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
+        this.packageSource =
+            (options.mode ?? 'package') === 'monorepo'
+                ? new MonorepoPackageSource({
+                    root: normalizeFileKey(options.root),
+                    packagesDir: options.packagesDir ?? 'packages',
+                    styleExtensions: this.config.styleExtensions,
+                })
+                : new SinglePackageSource({
+                    root: normalizeFileKey(options.root),
+                    styleExtensions: this.config.styleExtensions,
+                    loadAukletConfig: this.loadAukletConfig,
+                });
+    }
+    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());
+    }
+    createRequestCache() {
+        return new ModuleStyleGraphRequestCache({
+            packageSource: this.packageSource,
+            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

@@ -1,9 +1,18 @@
-import type { StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
+import type { StylePackageInfo, StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
 export type MonorepoPackageSourceOptions = {
-  workspaceRoot: string;
-  packagesDir: string;
-  styleExtensions: Array<string>;
+    root: string;
+    packagesDir: string;
+    styleExtensions: Array<string>;
 };
-export declare function createMonorepoPackageSource(
-  options: MonorepoPackageSourceOptions,
-): StylePackageSource;
+export declare class MonorepoPackageSource implements StylePackageSource {
+    private readonly options;
+    private packages?;
+    private packageNames?;
+    private readonly root;
+    constructor(options: MonorepoPackageSourceOptions);
+    getPackages(): StylePackageInfo[];
+    getPackageNames(): string[];
+    isKnownPackageName(packageName: string): boolean;
+    isSourceGraphFile(file: string): boolean;
+    getWatchRoots(): Promise<string[]>;
+}

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

@@ -1,77 +1,69 @@
 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 { SOURCE_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;
+export class MonorepoPackageSource {
+    options;
+    packages;
+    packageNames;
+    root;
+    constructor(options) {
+        this.options = options;
+        this.root = normalizeFileKey(options.root);
+    }
+    getPackages() {
+        if (this.packages)
+            return this.packages;
+        const packagesRoot = path.join(this.root, 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.root, this.options.packagesDir));
+        if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
+            return false;
+        }
+        if (normalizedFile.endsWith(aukletConfigFile))
+            return true;
+        if (SOURCE_MODULE_RE.test(normalizedFile))
+            return true;
+        return this.options.styleExtensions.some((extension) => normalizedFile.endsWith(extension));
     }
-    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 [];
+    async getWatchRoots() {
+        const packagesRoot = path.join(this.root, this.options.packagesDir);
         return [
-          {
-            packageName: pkg.name,
-            packageRoot,
-          },
+            toWatchPath(packagesRoot, '*', 'src'),
+            toWatchPath(packagesRoot, '*', aukletConfigFile),
         ];
-      });
-    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/singlePackage.d.ts

@@ -0,0 +1,21 @@
+import type { StylePackageInfo, StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
+import type { LoadAukletConfig } from '#auklet/css/vite/moduleGraph/types';
+export type SinglePackageSourceOptions = {
+    root: string;
+    styleExtensions: Array<string>;
+    loadAukletConfig?: LoadAukletConfig;
+};
+export declare class SinglePackageSource implements StylePackageSource {
+    private readonly options;
+    private packageInfo?;
+    private readonly root;
+    private readonly loadAukletConfig;
+    constructor(options: SinglePackageSourceOptions);
+    getPackages(): StylePackageInfo[];
+    getPackageNames(): string[];
+    isKnownPackageName(packageName: string): boolean;
+    isSourceGraphFile(file: string): boolean;
+    getWatchRoots(): Promise<string[]>;
+    private getPackageInfo;
+    private isInsidePackage;
+}

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

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
+import { loadAukletConfig } from '#auklet/configLoader';
+import { SOURCE_MODULE_RE } from '#auklet/css/constants';
+import { normalizeFileKey, toWatchPath } from '#auklet/utils';
+export class SinglePackageSource {
+    options;
+    packageInfo;
+    root;
+    loadAukletConfig;
+    constructor(options) {
+        this.options = options;
+        this.root = normalizeFileKey(options.root);
+        this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
+    }
+    getPackages() {
+        return [this.getPackageInfo()];
+    }
+    getPackageNames() {
+        return [this.getPackageInfo().packageName];
+    }
+    isKnownPackageName(packageName) {
+        return packageName === this.getPackageInfo().packageName;
+    }
+    isSourceGraphFile(file) {
+        const normalizedFile = normalizeFileKey(file);
+        if (!this.isInsidePackage(normalizedFile))
+            return false;
+        if (normalizedFile.endsWith(aukletConfigFile))
+            return true;
+        if (SOURCE_MODULE_RE.test(normalizedFile))
+            return true;
+        return this.options.styleExtensions.some((extension) => normalizedFile.endsWith(extension));
+    }
+    async getWatchRoots() {
+        const normalizedConfig = normalizeAukletConfig(await this.loadAukletConfig(this.root, { cacheBust: true }));
+        return [
+            toWatchPath(this.root, normalizedConfig.source),
+            toWatchPath(this.root, aukletConfigFile),
+        ];
+    }
+    getPackageInfo() {
+        if (this.packageInfo)
+            return this.packageInfo;
+        const packageJsonPath = path.join(this.root, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            throw new Error(`[auklet:css] package mode requires a package.json at ${this.root}.`);
+        }
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (!pkg.name) {
+            throw new Error(`[auklet:css] package mode requires package.json#name at ${this.root}.`);
+        }
+        this.packageInfo = {
+            packageName: pkg.name,
+            packageRoot: this.root,
+        };
+        return this.packageInfo;
+    }
+    isInsidePackage(file) {
+        return file === this.root || file.startsWith(`${this.root}/`);
+    }
+}

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

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

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

@@ -1,67 +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 { StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
-import type {
-  LoadAukletConfig,
-  PackageStyleId,
-} from '#auklet/css/vite/moduleGraph/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 = {
-  packageSource: StylePackageSource;
-  config: ModuleStyleBuildConfig;
-  loadAukletConfig?: LoadAukletConfig;
+    packageSource: StylePackageSource;
+    config: ModuleStyleBuildConfig;
+    loadAukletConfig?: LoadAukletConfig;
 };
 export declare class ModuleStyleGraphRequestCache {
-  private readonly options;
-  private readonly contexts;
-  private readonly loadAukletConfig;
-  constructor(options: ModuleStyleGraphRequestCacheOptions);
-  getPackageNames(): string[];
-  isKnownPackageName(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;
@@ -70,8 +61,6 @@ export declare class ModuleStyleGraphRequestCache {
         resolver: WorkspaceStyleResolver;
         sourceRoot: string;
         styleProcessor: StyleProcessor;
-      }
-    | null
-  >;
-  private createContext;
+    } | null>;
+    private createContext;
 }

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

@@ -3,55 +3,57 @@ import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export class ModuleStyleGraphRequestCache {
-  options;
-  contexts = new Map();
-  loadAukletConfig;
-  constructor(options) {
-    this.options = options;
-    this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
-  }
-  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,
-      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,
-    };
-  }
+    options;
+    contexts = new Map();
+    loadAukletConfig;
+    constructor(options) {
+        this.options = options;
+        this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
+    }
+    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,
+            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,
+        };
+    }
 }