auklet 0.0.16 → 0.0.18

package/dist/css/production/builder.js

@@ -6,63 +6,57 @@ import { ModuleStyleOutputWriter } from '#auklet/css/production/moduleOutputWrit
 import { PackageStyleEntryWriter } from '#auklet/css/production/packageEntryWriter';
 import { toPosixPath } from '#auklet/utils';
 export class ModuleStyleBuilder {
-  config;
-  context;
-  logger;
-  constructor(context = {}, config = moduleStyleBuildConfig) {
-    this.config = config;
-    this.context = {
-      packageRoot: process.cwd(),
-      source: context.source,
-      output: context.output,
-      ...context,
-    };
-    this.logger = context.logger;
-  }
-  async build(options = {}) {
-    const rawConfig = options.aukletConfig ?? this.context.aukletConfig ?? {};
-    const normalizedConfig = normalizeAukletConfig(rawConfig);
-    const logger = options.logger ?? this.logger;
-    const context = this.createBuildContext(normalizedConfig);
-    const packageContext = this.createPackageContext(context, normalizedConfig);
-    const writerOptions = {
-      config: this.config,
-      context,
-      packageContext,
-    };
-    const packageWriter = new PackageStyleEntryWriter(writerOptions);
-    const packageOutput = packageWriter.write();
-    const outputs = packageOutput ? [packageOutput] : [];
-    logger?.log?.(`[auklet:css] build ${path.basename(context.packageRoot)}`);
-    if (normalizedConfig.modules) {
-      outputs.push(...new ModuleStyleOutputWriter(writerOptions).write());
+    config;
+    context;
+    logger;
+    constructor(context = {}, config = moduleStyleBuildConfig) {
+        this.config = config;
+        this.context = {
+            packageRoot: process.cwd(),
+            source: context.source,
+            output: context.output,
+            ...context,
+        };
+        this.logger = context.logger;
     }
-    this.logOutputs(context, packageContext.styleFiles, outputs, logger);
-  }
-  logOutputs(context, styleFiles, outputs, logger) {
-    logger?.log?.(
-      `[auklet:css] ${styleFiles.length} source style file(s), ${outputs.length} output entry file(s)`,
-    );
-    for (const output of outputs) {
-      logger?.log?.(
-        `[auklet:css] + ${toPosixPath(
-          path.relative(context.packageRoot, output),
-        )}`,
-      );
+    async build(options = {}) {
+        const rawConfig = options.aukletConfig ?? this.context.aukletConfig ?? {};
+        const normalizedConfig = normalizeAukletConfig(rawConfig);
+        const logger = options.logger ?? this.logger;
+        const context = this.createBuildContext(normalizedConfig);
+        const packageContext = this.createPackageContext(context, normalizedConfig);
+        const writerOptions = {
+            config: this.config,
+            context,
+            packageContext,
+        };
+        const packageWriter = new PackageStyleEntryWriter(writerOptions);
+        const packageOutput = packageWriter.write();
+        const outputs = packageOutput ? [packageOutput] : [];
+        logger?.log?.(`[auklet:css] build ${path.basename(context.packageRoot)}`);
+        if (normalizedConfig.modules) {
+            outputs.push(...new ModuleStyleOutputWriter(writerOptions).write());
+        }
+        this.logOutputs(context, packageContext.styleFiles, outputs, logger);
+    }
+    logOutputs(context, styleFiles, outputs, logger) {
+        logger?.log?.(`[auklet:css] ${styleFiles.length} source style file(s), ${outputs.length} output entry file(s)`);
+        for (const output of outputs) {
+            logger?.log?.(`[auklet:css] + ${toPosixPath(path.relative(context.packageRoot, output))}`);
+        }
+    }
+    createBuildContext(config) {
+        return {
+            packageRoot: this.context.packageRoot,
+            sourceDir: this.context.source ?? config.source,
+            outputDir: this.context.output ?? config.output,
+        };
+    }
+    createPackageContext(context, normalizedConfig) {
+        return new StylePackageContext({
+            config: this.config,
+            context,
+            normalizedConfig,
+        });
     }
-  }
-  createBuildContext(config) {
-    return {
-      packageRoot: this.context.packageRoot,
-      sourceDir: this.context.source ?? config.source,
-      outputDir: this.context.output ?? config.output,
-    };
-  }
-  createPackageContext(context, normalizedConfig) {
-    return new StylePackageContext({
-      config: this.config,
-      context,
-      normalizedConfig,
-    });
-  }
 }

package/dist/css/production/format/entryWriter.js

@@ -1,55 +1,42 @@
 import path from 'node:path';
 import { createStyleEntryParts } from '#auklet/css/core/style/entries';
-import {
-  writeStyleFile,
-  toRelativeImportSpecifier,
-} from '#auklet/css/production/format/shared';
+import { writeStyleFile, toRelativeImportSpecifier, } from '#auklet/css/production/format/shared';
 export class StyleEntryWriter {
-  config;
-  packageContext;
-  styleProcessor;
-  constructor(options) {
-    this.config = options.config;
-    this.packageContext = options.packageContext;
-    this.styleProcessor = options.packageContext.styleProcessor;
-  }
-  write(outRoot, themeStyles, moduleStyle) {
-    const target = path.join(
-      outRoot,
-      this.config.output.styleDir,
-      this.config.output.indexStyleFile,
-    );
-    const root = this.styleProcessor.createRoot();
-    const styleDir = path.dirname(target);
-    for (const part of createStyleEntryParts(
-      this.packageContext.normalizedConfig,
-    )) {
-      if (part.type === 'dependencies') {
-        for (const specifier of part.specifiers) {
-          this.styleProcessor.appendImportRule(root, specifier);
-        }
-        continue;
-      }
-      if (part.type === 'themes') {
-        for (const themeName of part.themeNames) {
-          const themeStyle = themeStyles.get(themeName);
-          if (!themeStyle) continue;
-          this.styleProcessor.appendImportRule(
-            root,
-            toRelativeImportSpecifier(styleDir, themeStyle),
-          );
+    config;
+    packageContext;
+    styleProcessor;
+    constructor(options) {
+        this.config = options.config;
+        this.packageContext = options.packageContext;
+        this.styleProcessor = options.packageContext.styleProcessor;
+    }
+    write(outRoot, themeStyles, moduleStyle) {
+        const target = path.join(outRoot, this.config.output.styleDir, this.config.output.indexStyleFile);
+        const root = this.styleProcessor.createRoot();
+        const styleDir = path.dirname(target);
+        for (const part of createStyleEntryParts(this.packageContext.normalizedConfig)) {
+            if (part.type === 'dependencies') {
+                for (const specifier of part.specifiers) {
+                    this.styleProcessor.appendImportRule(root, specifier);
+                }
+                continue;
+            }
+            if (part.type === 'themes') {
+                for (const themeName of part.themeNames) {
+                    const themeStyle = themeStyles.get(themeName);
+                    if (!themeStyle)
+                        continue;
+                    this.styleProcessor.appendImportRule(root, toRelativeImportSpecifier(styleDir, themeStyle));
+                }
+                continue;
+            }
+            if (moduleStyle) {
+                this.styleProcessor.appendImportRule(root, toRelativeImportSpecifier(styleDir, moduleStyle));
+            }
         }
-        continue;
-      }
-      if (moduleStyle) {
-        this.styleProcessor.appendImportRule(
-          root,
-          toRelativeImportSpecifier(styleDir, moduleStyle),
-        );
-      }
+        if (!root.nodes?.length)
+            return null;
+        writeStyleFile(target, this.styleProcessor.stringify(root));
+        return target;
     }
-    if (!root.nodes?.length) return null;
-    writeStyleFile(target, this.styleProcessor.stringify(root));
-    return target;
-  }
 }

package/dist/css/production/format/externalWriter.js

@@ -1,38 +1,26 @@
 import path from 'node:path';
 import { createExternalEntryParts } from '#auklet/css/core/style/entries';
-import { writeStyleFile } from '#auklet/css/production/format/shared';
+import { writeStyleFile, } from '#auklet/css/production/format/shared';
 export class ExternalStyleWriter {
-  config;
-  packageContext;
-  resolver;
-  styleProcessor;
-  constructor(options) {
-    this.config = options.config;
-    this.packageContext = options.packageContext;
-    this.resolver = options.packageContext.resolver;
-    this.styleProcessor = options.packageContext.styleProcessor;
-  }
-  write(outRoot) {
-    const target = path.join(
-      outRoot,
-      this.config.output.styleDir,
-      this.config.output.externalStyleFile,
-    );
-    const root = this.styleProcessor.createRoot();
-    for (const part of createExternalEntryParts(
-      this.packageContext.normalizedConfig,
-    )) {
-      for (const specifier of part.specifiers) {
-        this.styleProcessor.appendImportRule(
-          root,
-          this.resolver.toExternalStyleSpecifier(specifier, outRoot),
-        );
-      }
+    config;
+    packageContext;
+    resolver;
+    styleProcessor;
+    constructor(options) {
+        this.config = options.config;
+        this.packageContext = options.packageContext;
+        this.resolver = options.packageContext.resolver;
+        this.styleProcessor = options.packageContext.styleProcessor;
+    }
+    write(outRoot) {
+        const target = path.join(outRoot, this.config.output.styleDir, this.config.output.externalStyleFile);
+        const root = this.styleProcessor.createRoot();
+        for (const part of createExternalEntryParts(this.packageContext.normalizedConfig)) {
+            for (const specifier of part.specifiers) {
+                this.styleProcessor.appendImportRule(root, this.resolver.toExternalStyleSpecifier(specifier, outRoot));
+            }
+        }
+        writeStyleFile(target, root.nodes?.length ? this.styleProcessor.stringify(root) : '');
+        return target;
     }
-    writeStyleFile(
-      target,
-      root.nodes?.length ? this.styleProcessor.stringify(root) : '',
-    );
-    return target;
-  }
 }

package/dist/css/production/format/{componentWriter.d.ts → moduleEntryWriter.d.ts}

@@ -1,6 +1,6 @@
 import type { ModuleStyleEntryPlan } from '#auklet/css/core/styleModuleEntryPlanner';
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
-export declare class ComponentStyleEntryWriter {
+export declare class ModuleStyleEntryWriter {
     private readonly config;
     private readonly sourceRoot;
     private readonly resolver;

package/dist/css/production/format/moduleEntryWriter.js

@@ -0,0 +1,48 @@
+import path from 'node:path';
+import { createOutputModuleStyleSpecifier, createOutputOwnStyleSpecifier, } from '#auklet/css/core/style/specifier';
+import { writeStyleFile, } from '#auklet/css/production/format/shared';
+export class ModuleStyleEntryWriter {
+    config;
+    sourceRoot;
+    resolver;
+    styleProcessor;
+    constructor(options) {
+        this.config = options.config;
+        this.sourceRoot = options.packageContext.sourceRoot;
+        this.resolver = options.packageContext.resolver;
+        this.styleProcessor = options.packageContext.styleProcessor;
+    }
+    write(outRoot, entries) {
+        const outputs = [];
+        for (const entry of entries) {
+            const styleDir = path.join(outRoot, entry.sourceDir, this.config.output.styleDir);
+            const target = path.join(styleDir, this.config.output.indexStyleFile);
+            const ownImports = this.styleProcessor.collectStyleImportSpecifiers(entry.ownStyleFiles);
+            const sourceStyleSpecifiers = [
+                ...this.getModuleStyleSpecifiers(entry.moduleStyleImports.filter((specifier) => !ownImports.has(specifier)), styleDir),
+                ...this.getOwnStyleSpecifiers(entry.ownStyleFiles, styleDir, outRoot),
+            ];
+            const root = this.styleProcessor.createRoot();
+            const seen = new Set();
+            for (const specifier of sourceStyleSpecifiers) {
+                if (seen.has(specifier))
+                    continue;
+                seen.add(specifier);
+                this.styleProcessor.appendImportRule(root, this.resolver.toOutputStyleSpecifier(specifier, outRoot));
+            }
+            writeStyleFile(target, root.nodes?.length ? this.styleProcessor.stringify(root) : '');
+            outputs.push(target);
+        }
+        return outputs;
+    }
+    getModuleStyleSpecifiers(specifiers, styleDir) {
+        return specifiers.map((specifier) => createOutputModuleStyleSpecifier(specifier, styleDir));
+    }
+    getOwnStyleSpecifiers(ownStyleFiles, styleDir, outRoot) {
+        return ownStyleFiles.map((styleFile) => createOutputOwnStyleSpecifier({
+            sourceRoot: this.sourceRoot,
+            outputRoot: outRoot,
+            styleDir,
+        }, styleFile));
+    }
+}

package/dist/css/production/format/moduleWriter.js

@@ -1,30 +1,27 @@
 import path from 'node:path';
-import { writeStyleFile } from '#auklet/css/production/format/shared';
+import { writeStyleFile, } from '#auklet/css/production/format/shared';
 export class ModuleStyleWriter {
-  config;
-  packageContext;
-  styleProcessor;
-  constructor(options) {
-    this.config = options.config;
-    this.packageContext = options.packageContext;
-    this.styleProcessor = options.packageContext.styleProcessor;
-  }
-  write(outRoot) {
-    const target = path.join(
-      outRoot,
-      this.config.output.styleDir,
-      this.config.output.moduleStyleFile,
-    );
-    const seen = new Set();
-    const root = this.styleProcessor.createRoot();
-    for (const styleFile of this.packageContext.styleFiles) {
-      const content = this.styleProcessor.readStyleFile(styleFile, seen);
-      if (content.trim()) {
-        this.styleProcessor.appendStyleContent(root, content, styleFile);
-      }
+    config;
+    packageContext;
+    styleProcessor;
+    constructor(options) {
+        this.config = options.config;
+        this.packageContext = options.packageContext;
+        this.styleProcessor = options.packageContext.styleProcessor;
+    }
+    write(outRoot) {
+        const target = path.join(outRoot, this.config.output.styleDir, this.config.output.moduleStyleFile);
+        const seen = new Set();
+        const root = this.styleProcessor.createRoot();
+        for (const styleFile of this.packageContext.styleFiles) {
+            const content = this.styleProcessor.readStyleFile(styleFile, seen);
+            if (content.trim()) {
+                this.styleProcessor.appendStyleContent(root, content, styleFile);
+            }
+        }
+        if (!root.nodes?.length)
+            return null;
+        writeStyleFile(target, this.styleProcessor.stringify(root));
+        return target;
     }
-    if (!root.nodes?.length) return null;
-    writeStyleFile(target, this.styleProcessor.stringify(root));
-    return target;
-  }
 }

package/dist/css/production/format/shared.d.ts

@@ -1,21 +1,14 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
-import type {
-  ModuleStyleBuildConfig,
-  ResolvedModuleStyleBuildContext,
-} from '#auklet/types';
-export declare const emptyStyleFileComment =
-  '/* Empty style file kept so automated tooling can resolve this CSS path. */\n';
+export { toRelativeImportSpecifier } from '#auklet/css/core/style/specifier';
+import type { ModuleStyleBuildConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
+export declare const emptyStyleFileComment = "/* Empty style file kept so automated tooling can resolve this CSS path. */\n";
 export type FormatWriterOptions = {
-  config: ModuleStyleBuildConfig;
-  context: ResolvedModuleStyleBuildContext;
-  packageContext: StylePackageContext;
+    config: ModuleStyleBuildConfig;
+    context: ResolvedModuleStyleBuildContext;
+    packageContext: StylePackageContext;
 };
 export type ThemeStyleOutput = {
-  themeName: string;
-  file: string;
+    themeName: string;
+    file: string;
 };
-export declare function toRelativeImportSpecifier(
-  fromDir: string,
-  file: string,
-): string;
 export declare function writeStyleFile(file: string, code: string): void;

package/dist/css/production/format/shared.js

@@ -1,13 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { toPosixPath } from '#auklet/utils';
-export const emptyStyleFileComment =
-  '/* Empty style file kept so automated tooling can resolve this CSS path. */\n';
-export function toRelativeImportSpecifier(fromDir, file) {
-  const relative = toPosixPath(path.relative(fromDir, file));
-  return relative.startsWith('.') ? relative : `./${relative}`;
-}
+export { toRelativeImportSpecifier } from '#auklet/css/core/style/specifier';
+export const emptyStyleFileComment = '/* Empty style file kept so automated tooling can resolve this CSS path. */\n';
 export function writeStyleFile(file, code) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, code.trim() ? code : emptyStyleFileComment);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, code.trim() ? code : emptyStyleFileComment);
 }

package/dist/css/production/format/sourceWriter.js

@@ -1,16 +1,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { writeStyleFile } from '#auklet/css/production/format/shared';
+import { writeStyleFile, } from '#auklet/css/production/format/shared';
 export class SourceStyleFileWriter {
-  sourceRoot;
-  constructor(options) {
-    this.sourceRoot = options.packageContext.sourceRoot;
-  }
-  copy(files, outRoot) {
-    for (const sourceFile of files) {
-      const relative = path.relative(this.sourceRoot, sourceFile);
-      const target = path.join(outRoot, relative);
-      writeStyleFile(target, fs.readFileSync(sourceFile, 'utf8'));
+    sourceRoot;
+    constructor(options) {
+        this.sourceRoot = options.packageContext.sourceRoot;
+    }
+    copy(files, outRoot) {
+        for (const sourceFile of files) {
+            const relative = path.relative(this.sourceRoot, sourceFile);
+            const target = path.join(outRoot, relative);
+            writeStyleFile(target, fs.readFileSync(sourceFile, 'utf8'));
+        }
     }
-  }
 }

package/dist/css/production/format/themeWriter.js

@@ -2,80 +2,65 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { THEMES_DIR } from '#auklet/css/constants';
 import { createThemeEntryParts } from '#auklet/css/core/style/entries';
-import {
-  writeStyleFile,
-  toRelativeImportSpecifier,
-} from '#auklet/css/production/format/shared';
+import { writeStyleFile, toRelativeImportSpecifier, } from '#auklet/css/production/format/shared';
 export class ThemeStyleWriter {
-  config;
-  packageContext;
-  styleProcessor;
-  constructor(options) {
-    this.config = options.config;
-    this.packageContext = options.packageContext;
-    this.styleProcessor = options.packageContext.styleProcessor;
-  }
-  clean(outRoot) {
-    fs.rmSync(path.join(outRoot, THEMES_DIR), {
-      recursive: true,
-      force: true,
-    });
-    fs.rmSync(path.join(outRoot, this.config.output.styleDir, THEMES_DIR), {
-      recursive: true,
-      force: true,
-    });
-  }
-  writeThemeStyles(outRoot) {
-    const outputs = [];
-    const themesDir = path.join(
-      outRoot,
-      this.config.output.styleDir,
-      THEMES_DIR,
-    );
-    for (const [themeName, stylePath] of this.packageContext.themeFiles) {
-      const root = this.styleProcessor.createRoot();
-      const content = this.styleProcessor.readStyleFile(stylePath);
-      if (content.trim()) {
-        this.styleProcessor.appendStyleContent(root, content, stylePath);
-      }
-      const target = path.join(themesDir, `${themeName}.css`);
-      writeStyleFile(
-        target,
-        root.nodes?.length ? this.styleProcessor.stringify(root) : '',
-      );
-      outputs.push({ themeName, file: target });
+    config;
+    packageContext;
+    styleProcessor;
+    constructor(options) {
+        this.config = options.config;
+        this.packageContext = options.packageContext;
+        this.styleProcessor = options.packageContext.styleProcessor;
     }
-    return outputs;
-  }
-  writeThemeEntries(themeStyles, outRoot) {
-    const outputs = [];
-    const themesDir = path.join(outRoot, THEMES_DIR);
-    for (const themeName of this.packageContext.themeNames) {
-      const target = path.join(themesDir, `${themeName}.css`);
-      const root = this.styleProcessor.createRoot();
-      const targetDir = path.dirname(target);
-      const themeStyle = themeStyles.get(themeName);
-      for (const part of createThemeEntryParts(
-        this.packageContext.normalizedConfig,
-        themeName,
-      )) {
-        if (part.type === 'dependencies') {
-          for (const specifier of part.specifiers) {
-            this.styleProcessor.appendImportRule(root, specifier);
-          }
-          continue;
+    clean(outRoot) {
+        fs.rmSync(path.join(outRoot, THEMES_DIR), {
+            recursive: true,
+            force: true,
+        });
+        fs.rmSync(path.join(outRoot, this.config.output.styleDir, THEMES_DIR), {
+            recursive: true,
+            force: true,
+        });
+    }
+    writeThemeStyles(outRoot) {
+        const outputs = [];
+        const themesDir = path.join(outRoot, this.config.output.styleDir, THEMES_DIR);
+        for (const [themeName, stylePath] of this.packageContext.themeFiles) {
+            const root = this.styleProcessor.createRoot();
+            const content = this.styleProcessor.readStyleFile(stylePath);
+            if (content.trim()) {
+                this.styleProcessor.appendStyleContent(root, content, stylePath);
+            }
+            const target = path.join(themesDir, `${themeName}.css`);
+            writeStyleFile(target, root.nodes?.length ? this.styleProcessor.stringify(root) : '');
+            outputs.push({ themeName, file: target });
         }
-        if (themeStyle) {
-          this.styleProcessor.appendImportRule(
-            root,
-            toRelativeImportSpecifier(targetDir, themeStyle),
-          );
+        return outputs;
+    }
+    writeThemeEntries(themeStyles, outRoot) {
+        const outputs = [];
+        const themesDir = path.join(outRoot, THEMES_DIR);
+        for (const themeName of this.packageContext.themeNames) {
+            const target = path.join(themesDir, `${themeName}.css`);
+            const root = this.styleProcessor.createRoot();
+            const targetDir = path.dirname(target);
+            const themeStyle = themeStyles.get(themeName);
+            for (const part of createThemeEntryParts(this.packageContext.normalizedConfig, themeName)) {
+                if (part.type === 'dependencies') {
+                    for (const specifier of part.specifiers) {
+                        this.styleProcessor.appendImportRule(root, specifier);
+                    }
+                    continue;
+                }
+                if (themeStyle) {
+                    this.styleProcessor.appendImportRule(root, toRelativeImportSpecifier(targetDir, themeStyle));
+                }
+            }
+            if (!root.nodes?.length)
+                continue;
+            writeStyleFile(target, this.styleProcessor.stringify(root));
+            outputs.push(target);
         }
-      }
-      if (!root.nodes?.length) continue;
-      writeStyleFile(target, this.styleProcessor.stringify(root));
-      outputs.push(target);
+        return outputs;
     }
-    return outputs;
-  }
 }

package/dist/css/production/moduleOutputWriter.d.ts

@@ -1,26 +1,23 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
-import type {
-  ModuleStyleBuildConfig,
-  ResolvedModuleStyleBuildContext,
-} from '#auklet/types';
+import type { ModuleStyleBuildConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
 export type ModuleStyleOutputWriterOptions = {
-  config: ModuleStyleBuildConfig;
-  context: ResolvedModuleStyleBuildContext;
-  packageContext: StylePackageContext;
+    config: ModuleStyleBuildConfig;
+    context: ResolvedModuleStyleBuildContext;
+    packageContext: StylePackageContext;
 };
 export declare class ModuleStyleOutputWriter {
-  private readonly config;
-  private readonly context;
-  private readonly packageContext;
-  private readonly sourceWriter;
-  private readonly themeWriter;
-  private readonly externalWriter;
-  private readonly moduleWriter;
-  private readonly entryWriter;
-  private readonly componentWriter;
-  constructor(options: ModuleStyleOutputWriterOptions);
-  write(): string[];
-  private get outputRoot();
-  private createComponentEntries;
-  private writeFormat;
+    private readonly config;
+    private readonly context;
+    private readonly packageContext;
+    private readonly sourceWriter;
+    private readonly themeWriter;
+    private readonly externalWriter;
+    private readonly moduleWriter;
+    private readonly entryWriter;
+    private readonly moduleEntryWriter;
+    constructor(options: ModuleStyleOutputWriterOptions);
+    write(): string[];
+    private get outputRoot();
+    private createModuleEntries;
+    private writeFormat;
 }