auklet 0.0.17 → 0.0.19

package/dist/css/production/moduleOutputWriter.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import { createComponentStyleEntryPlans } from '#auklet/css/core/style/entries';
-import { ComponentStyleEntryWriter } from '#auklet/css/production/format/componentWriter';
+import { createModuleStyleEntryPlans } from '#auklet/css/core/style/entries';
+import { ModuleStyleEntryWriter } from '#auklet/css/production/format/moduleEntryWriter';
 import { StyleEntryWriter } from '#auklet/css/production/format/entryWriter';
 import { ExternalStyleWriter } from '#auklet/css/production/format/externalWriter';
 import { ModuleStyleWriter } from '#auklet/css/production/format/moduleWriter';
@@ -16,7 +16,7 @@ export class ModuleStyleOutputWriter {
     externalWriter;
     moduleWriter;
     entryWriter;
-    componentWriter;
+    moduleEntryWriter;
     constructor(options) {
         this.config = options.config;
         this.context = options.context;
@@ -26,23 +26,23 @@ export class ModuleStyleOutputWriter {
         this.externalWriter = new ExternalStyleWriter(options);
         this.moduleWriter = new ModuleStyleWriter(options);
         this.entryWriter = new StyleEntryWriter(options);
-        this.componentWriter = new ComponentStyleEntryWriter(options);
+        this.moduleEntryWriter = new ModuleStyleEntryWriter(options);
     }
     write() {
-        const componentEntries = this.createComponentEntries();
+        const moduleEntries = this.createModuleEntries();
         const outputs = [];
         for (const format of this.config.output.outputFormats) {
-            outputs.push(...this.writeFormat(format, componentEntries));
+            outputs.push(...this.writeFormat(format, moduleEntries));
         }
         return outputs;
     }
     get outputRoot() {
         return path.join(this.context.packageRoot, this.context.outputDir);
     }
-    createComponentEntries() {
-        return createComponentStyleEntryPlans(this.packageContext);
+    createModuleEntries() {
+        return createModuleStyleEntryPlans(this.packageContext);
     }
-    writeFormat(format, componentEntries) {
+    writeFormat(format, moduleEntries) {
         const outRoot = path.join(this.outputRoot, format);
         const outputs = [];
         this.themeWriter.clean(outRoot);
@@ -53,7 +53,7 @@ export class ModuleStyleOutputWriter {
         const externalStyle = this.externalWriter.write(outRoot);
         const moduleStyle = this.moduleWriter.write(outRoot);
         const entryStyle = this.entryWriter.write(outRoot, themeStyleMap, moduleStyle);
-        const componentStyles = this.componentWriter.write(outRoot, componentEntries);
+        const moduleStyleEntries = this.moduleEntryWriter.write(outRoot, moduleEntries);
         outputs.push(...themeStyles.map((themeStyle) => themeStyle.file));
         outputs.push(...themeEntries);
         if (externalStyle)
@@ -62,7 +62,7 @@ export class ModuleStyleOutputWriter {
             outputs.push(moduleStyle);
         if (entryStyle)
             outputs.push(entryStyle);
-        outputs.push(...componentStyles);
+        outputs.push(...moduleStyleEntries);
         return outputs;
     }
 }

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

@@ -13,7 +13,7 @@ export declare class ModuleStyleGraph {
     isStyleConfigFile(file: string): boolean;
     isStyleFile(file: string): boolean;
     getPackageNames(): string[];
-    getWatchRoots(): string[];
+    getWatchRoots(): Promise<string[]>;
     createPackageStyleCode(parsed: PackageStyleId): Promise<{
         code: string;
         watchFiles: string[];

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

@@ -5,7 +5,8 @@ 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 {
@@ -15,17 +16,20 @@ export class ModuleStyleGraph {
     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);
+        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());

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

@@ -1,7 +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;
+    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,24 +1,21 @@
 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 {
+export class MonorepoPackageSource {
     options;
     packages;
     packageNames;
-    workspaceRoot;
+    root;
     constructor(options) {
         this.options = options;
-        this.workspaceRoot = normalizeFileKey(options.workspaceRoot);
+        this.root = normalizeFileKey(options.root);
     }
     getPackages() {
         if (this.packages)
             return this.packages;
-        const packagesRoot = path.join(this.workspaceRoot, this.options.packagesDir);
+        const packagesRoot = path.join(this.root, this.options.packagesDir);
         if (!fs.existsSync(packagesRoot)) {
             this.packages = [];
             return this.packages;
@@ -52,18 +49,18 @@ class MonorepoPackageSource {
     }
     isSourceGraphFile(file) {
         const normalizedFile = normalizeFileKey(file);
-        const packagesRoot = normalizeFileKey(path.join(this.workspaceRoot, this.options.packagesDir));
+        const packagesRoot = normalizeFileKey(path.join(this.root, this.options.packagesDir));
         if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
             return false;
         }
         if (normalizedFile.endsWith(aukletConfigFile))
             return true;
-        if (SOURCE_COMPONENT_MODULE_RE.test(normalizedFile))
+        if (SOURCE_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);
+    async getWatchRoots() {
+        const packagesRoot = path.join(this.root, 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

@@ -7,5 +7,5 @@ export interface StylePackageSource {
     getPackageNames(): Array<string>;
     isKnownPackageName(packageName: string): boolean;
     isSourceGraphFile(file: string): boolean;
-    getWatchRoots(): Array<string>;
+    getWatchRoots(): Promise<Array<string>>;
 }

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

@@ -3,9 +3,8 @@ import { mergeLoadResults } from '#auklet/css/vite/moduleGraph/loadResult';
 import { parsePackageStyleId } from '#auklet/css/vite/moduleGraph/styleId';
 import { toDevDependencyImportSpecifier } from '#auklet/css/vite/moduleGraph/devDependency';
 import { EXTERNAL_ENTRY, MODULE_ENTRY, STYLE_ENTRY, THEMES_ENTRY_PREFIX, } from '#auklet/css/constants';
-import { createComponentStyleEntryPlan, createExternalEntryParts, createStyleEntryParts, createThemeEntryParts, } from '#auklet/css/core/style/entries';
-import { createImportCode, parsePackageStyleSpecifier, removeStyleExtension, } from '#auklet/css/core/style/specifier';
-import { toFsSpecifier, toPosixPath } from '#auklet/utils';
+import { createModuleStyleEntryPlan, createExternalEntryParts, createStyleEntryParts, createThemeEntryParts, } from '#auklet/css/core/style/entries';
+import { createDevExternalStyleSpecifier, createDevModuleStyleSpecifier, createImportCode, removeStyleExtension, } from '#auklet/css/core/style/specifier';
 // 生成 Vite/dev 虚拟 CSS；production writer 共享入口语义，但写入真实文件。
 export class StyleCodeFactory {
     config;
@@ -129,13 +128,13 @@ export class StyleCodeFactory {
     async createSourceModuleStyleCode(context, cache, stylePath) {
         const sourceModuleDir = removeStyleExtension(stylePath);
         const { styleFiles, sourceFiles } = context.packageContext;
-        const entry = createComponentStyleEntryPlan(context.packageContext, sourceModuleDir);
+        const entry = createModuleStyleEntryPlan(context.packageContext, sourceModuleDir);
         const sourceStyleDir = path.join(context.sourceRoot, sourceModuleDir, this.config.output.styleDir);
         const moduleStyleResults = [];
         const moduleStyleSpecifiers = [];
         const moduleStyleWatchFiles = [];
         for (const specifier of entry.moduleStyleImports) {
-            const result = this.toDevModuleImportSpecifier(context, cache, sourceStyleDir, specifier);
+            const result = this.toDevModuleImportSpecifier(specifier, context, cache, sourceStyleDir);
             const parsed = this.parsePackageStyleIdInRequest(result, cache);
             if (parsed) {
                 moduleStyleResults.push(await this.createPackageStyleCode(parsed, cache));
@@ -170,32 +169,23 @@ export class StyleCodeFactory {
             ],
         });
     }
-    toDevModuleImportSpecifier(context, cache, sourceStyleDir, specifier) {
-        if (!specifier.startsWith('.')) {
-            return this.toDevExternalStyleSpecifier(specifier, cache);
-        }
-        const outputStyleEntry = path.resolve(sourceStyleDir, specifier);
-        const styleEntrySuffix = `${path.sep}${this.config.output.styleDir}${path.sep}${this.config.output.indexStyleFile}`;
-        if (!outputStyleEntry.endsWith(styleEntrySuffix)) {
-            return toFsSpecifier(outputStyleEntry);
-        }
-        const sourceModuleDir = path.relative(context.sourceRoot, outputStyleEntry.slice(0, -styleEntrySuffix.length));
-        return `${context.packageName}/${toPosixPath(sourceModuleDir)}.css`;
+    toDevModuleImportSpecifier(specifier, context, cache, sourceStyleDir) {
+        return createDevModuleStyleSpecifier(specifier, {
+            sourceStyleDir,
+            sourceRoot: context.sourceRoot,
+            packageName: context.packageName,
+            styleDir: this.config.output.styleDir,
+            indexStyleFile: this.config.output.indexStyleFile,
+            mapExternalSpecifier: (externalSpecifier) => this.toDevExternalStyleSpecifier(externalSpecifier, cache),
+        });
     }
     toDevExternalStyleSpecifier(specifier, cache) {
-        const parsed = parsePackageStyleSpecifier(specifier);
-        if (!parsed)
-            return specifier;
-        if (cache.isKnownPackageName(parsed.packageName)) {
-            if (parsed.stylePath === STYLE_ENTRY) {
-                return `${parsed.packageName}/${EXTERNAL_ENTRY}`;
-            }
-            if (parsed.stylePath ===
-                [this.config.output.styleDir, this.config.output.indexStyleFile].join('/')) {
-                return `${parsed.packageName}/${EXTERNAL_ENTRY}`;
-            }
-        }
-        return specifier;
+        return createDevExternalStyleSpecifier(specifier, {
+            isKnownPackageName: (packageName) => cache.isKnownPackageName(packageName),
+            styleDir: this.config.output.styleDir,
+            indexStyleFile: this.config.output.indexStyleFile,
+            externalStyleFile: EXTERNAL_ENTRY,
+        });
     }
     parsePackageStyleIdInRequest(id, cache) {
         return parsePackageStyleId(id, cache.getPackageNames());

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

@@ -1,6 +1,6 @@
 import type { AukletConfig, ModuleStyleBuildConfig } from '#auklet/types';
 export interface ModuleStyleGraphOptions {
-    workspaceRoot: string;
+    root: string;
     packagesDir?: string;
     mode?: 'monorepo' | 'package';
     config?: ModuleStyleBuildConfig;

package/dist/css/vite/vitePlugin.d.ts

@@ -1,6 +1,6 @@
 import type { HotUpdateOptions, ViteDevServer } from 'vite';
 import type { ModuleStyleGraphOptions } from '#auklet/css/vite/moduleGraph/types';
-export type AukletStylePluginOptions = Partial<Pick<ModuleStyleGraphOptions, 'workspaceRoot' | 'mode'>> & Omit<ModuleStyleGraphOptions, 'workspaceRoot'>;
+export type AukletStylePluginOptions = Partial<Pick<ModuleStyleGraphOptions, 'root' | 'mode'>> & Omit<ModuleStyleGraphOptions, 'root'>;
 export declare function aukletStylePlugin(options?: AukletStylePluginOptions): {
     name: string;
     apply: "serve";
@@ -12,7 +12,7 @@ export declare function aukletStylePlugin(options?: AukletStylePluginOptions): {
     load(this: {
         addWatchFile?: (file: string) => void;
     }, id: string): Promise<string | null>;
-    configureServer(server: ViteDevServer): void;
+    configureServer(server: ViteDevServer): Promise<void>;
     hotUpdate: {
         order: "pre";
         handler(context: HotUpdateOptions): never[] | undefined;

package/dist/css/vite/vitePlugin.js

@@ -29,12 +29,19 @@ const findWorkspaceRoot = (startDir) => {
     }
 };
 const createModuleStyleGraph = (options, viteRoot) => {
-    const workspaceRoot = options.workspaceRoot ?? findWorkspaceRoot(viteRoot) ?? process.cwd();
+    const mode = options.mode ?? 'package';
+    const root = options.root ?? resolveGraphRoot(mode, viteRoot);
     return new ModuleStyleGraph({
         ...options,
-        workspaceRoot,
+        mode,
+        root,
     });
 };
+const resolveGraphRoot = (mode, viteRoot) => {
+    if (mode === 'monorepo')
+        return findWorkspaceRoot(viteRoot) ?? process.cwd();
+    return viteRoot;
+};
 const invalidateVirtualModules = (server, graph) => {
     const modules = [];
     for (const packageName of graph.getPackageNames()) {
@@ -92,10 +99,10 @@ export function aukletStylePlugin(options = {}) {
             }
             return result.code;
         },
-        configureServer(server) {
+        async configureServer(server) {
             const graph = getGraph();
             hmr.installFullReloadGuard(server);
-            server.watcher.add(graph.getWatchRoots());
+            server.watcher.add(await graph.getWatchRoots());
             const invalidateStyleGraph = (file) => {
                 if (!graph.isSourceGraphFile(file))
                     return false;

package/dist/css/watch/watcher.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import chokidar from 'chokidar';
 import { aukletConfigFile, aukletDefaultOptions } from '#auklet/config';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
-import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
+import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { ModuleStyleBuilder } from '#auklet/css/production/builder';
 export class ModuleStyleWatcher {
     config;
@@ -82,7 +82,7 @@ export class ModuleStyleWatcher {
     shouldRebuildForFile(file) {
         if (path.basename(file) === aukletConfigFile)
             return true;
-        if (SOURCE_COMPONENT_MODULE_RE.test(file))
+        if (SOURCE_MODULE_RE.test(file))
             return true;
         return this.config.styleExtensions.includes(path.extname(file));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",

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

@@ -1,11 +0,0 @@
-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[];