auklet 0.0.16 → 0.0.18

package/dist/css/core/styleModuleEntryPlanner.js

@@ -1,67 +1,50 @@
 import path from 'node:path';
-import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
+import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { groupStyleFilesByDir } from '#auklet/css/core/style/files';
 import { getSourceModuleDir, toPosixPath } from '#auklet/utils';
 export class StyleModuleEntryPlanner {
-  packageContext;
-  styleFilesByDir;
-  importedStyleFiles;
-  constructor(packageContext) {
-    this.packageContext = packageContext;
-    this.styleFilesByDir = groupStyleFilesByDir(
-      this.packageContext.sourceRoot,
-      this.packageContext.styleFiles,
-    );
-    this.importedStyleFiles =
-      this.packageContext.styleProcessor.collectImportedStyleFiles(
-        this.packageContext.styleFiles,
-      );
-  }
-  createEntries(moduleStyleImports) {
-    return this.getSourceDirs(moduleStyleImports).map((sourceDir) =>
-      this.createEntry(sourceDir, moduleStyleImports),
-    );
-  }
-  createEntry(sourceDir, moduleStyleImports) {
-    return {
-      sourceDir,
-      moduleStyleImports: moduleStyleImports.get(sourceDir) ?? [],
-      ownStyleFiles: this.getOwnStyleFiles(sourceDir),
-    };
-  }
-  getSourceDirs(moduleStyleImports) {
-    return Array.from(
-      new Set([
-        ...this.getSourceModuleDirs(),
-        ...this.getOwnStyleDirs(),
-        ...moduleStyleImports.keys(),
-      ]),
-    ).filter((sourceDir) => sourceDir !== '.');
-  }
-  getSourceModuleDirs() {
-    return this.packageContext.sourceFiles
-      .filter((sourceFile) => SOURCE_COMPONENT_MODULE_RE.test(sourceFile))
-      .map((sourceFile) => {
-        return getSourceModuleDir(
-          path.relative(this.packageContext.sourceRoot, sourceFile),
-        );
-      })
-      .filter((sourceModuleDir) => {
-        return toPosixPath(sourceModuleDir).split('/').length === 2;
-      });
-  }
-  getOwnStyleDirs() {
-    return Array.from(this.styleFilesByDir.entries())
-      .filter(([, dirStyleFiles]) =>
-        dirStyleFiles.some(
-          (styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)),
-        ),
-      )
-      .map(([sourceDir]) => sourceDir);
-  }
-  getOwnStyleFiles(sourceDir) {
-    return (this.styleFilesByDir.get(sourceDir) ?? []).filter(
-      (styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)),
-    );
-  }
+    packageContext;
+    importedStyleFiles;
+    styleFilesByDir;
+    constructor(packageContext) {
+        this.packageContext = packageContext;
+        this.styleFilesByDir = groupStyleFilesByDir(this.packageContext.sourceRoot, this.packageContext.styleFiles);
+        this.importedStyleFiles =
+            this.packageContext.styleProcessor.collectImportedStyleFiles(this.packageContext.styleFiles);
+    }
+    createEntries(moduleStyleImports) {
+        return this.getSourceDirs(moduleStyleImports).map((sourceDir) => this.createEntry(sourceDir, moduleStyleImports));
+    }
+    createEntry(sourceDir, moduleStyleImports) {
+        return {
+            sourceDir,
+            moduleStyleImports: moduleStyleImports.get(sourceDir) ?? [],
+            ownStyleFiles: this.getOwnStyleFiles(sourceDir),
+        };
+    }
+    getSourceDirs(moduleStyleImports) {
+        return Array.from(new Set([
+            ...this.getSourceModuleDirs(),
+            ...this.getOwnStyleDirs(),
+            ...moduleStyleImports.keys(),
+        ])).filter((sourceDir) => sourceDir !== '.');
+    }
+    getSourceModuleDirs() {
+        return this.packageContext.sourceFiles
+            .filter((sourceFile) => SOURCE_MODULE_RE.test(sourceFile))
+            .map((sourceFile) => {
+            return getSourceModuleDir(path.relative(this.packageContext.sourceRoot, sourceFile));
+        })
+            .filter((sourceModuleDir) => {
+            return toPosixPath(sourceModuleDir).split('/').length === 2;
+        });
+    }
+    getOwnStyleDirs() {
+        return Array.from(this.styleFilesByDir.entries())
+            .filter(([, dirStyleFiles]) => dirStyleFiles.some((styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile))))
+            .map(([sourceDir]) => sourceDir);
+    }
+    getOwnStyleFiles(sourceDir) {
+        return (this.styleFilesByDir.get(sourceDir) ?? []).filter((styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)));
+    }
 }

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

@@ -1,27 +1,23 @@
 import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
 import { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
-import type {
-  ModuleStyleBuildConfig,
-  NormalizedAukletConfig,
-  ResolvedModuleStyleBuildContext,
-} from '#auklet/types';
+import type { ModuleStyleBuildConfig, NormalizedAukletConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
 export type StylePackageContextOptions = {
-  config: ModuleStyleBuildConfig;
-  context: ResolvedModuleStyleBuildContext;
-  normalizedConfig: NormalizedAukletConfig;
+    config: ModuleStyleBuildConfig;
+    context: ResolvedModuleStyleBuildContext;
+    normalizedConfig: NormalizedAukletConfig;
 };
 export declare class StylePackageContext {
-  private readonly options;
-  readonly normalizedConfig: NormalizedAukletConfig;
-  readonly sourceRoot: string;
-  readonly resolver: WorkspaceStyleResolver;
-  readonly styleProcessor: StyleProcessor;
-  readonly importCollector: ModuleStyleImportCollector;
-  readonly sourceFiles: Array<string>;
-  readonly themeFiles: Map<string, string>;
-  readonly themeNames: Array<string>;
-  readonly styleFiles: Array<string>;
-  constructor(options: StylePackageContextOptions);
-  getStyleFiles(files: Array<string>): string[];
+    private readonly options;
+    readonly normalizedConfig: NormalizedAukletConfig;
+    readonly sourceRoot: string;
+    readonly resolver: WorkspaceStyleResolver;
+    readonly styleProcessor: StyleProcessor;
+    readonly importCollector: ModuleStyleImportCollector;
+    readonly sourceFiles: Array<string>;
+    readonly themeFiles: Map<string, string>;
+    readonly themeNames: Array<string>;
+    readonly styleFiles: Array<string>;
+    constructor(options: StylePackageContextOptions);
+    getStyleFiles(files: Array<string>): string[];
 }

package/dist/css/core/stylePackageContext.js

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

package/dist/css/core/styleProcessor.js

@@ -2,117 +2,118 @@ import fs from 'node:fs';
 import path from 'node:path';
 import postcss from 'postcss';
 export class StyleProcessor {
-  config;
-  resolver;
-  constructor(config, resolver) {
-    this.config = config;
-    this.resolver = resolver;
-  }
-  createRoot() {
-    return postcss.root();
-  }
-  appendImportRule(root, specifier) {
-    const rule = postcss.atRule({
-      name: 'import',
-      params: `"${specifier}"`,
-    });
-    if (root.nodes?.length) rule.raws.before = '\n';
-    root.append(rule);
-    root.raws.semicolon = true;
-  }
-  stringify(root) {
-    root.raws.semicolon = true;
-    return `${root}\n`;
-  }
-  appendStyleContent(target, content, from) {
-    const root = this.parse(content, from);
-    if (target.nodes?.length && root.nodes?.[0]) {
-      root.nodes[0].raws.before = '\n';
+    config;
+    resolver;
+    constructor(config, resolver) {
+        this.config = config;
+        this.resolver = resolver;
     }
-    target.append(...(root.nodes ?? []));
-  }
-  readStyleFile(stylePath, seen = new Set()) {
-    if (!fs.existsSync(stylePath)) {
-      return '';
+    createRoot() {
+        return postcss.root();
     }
-    const normalizedPath = path.resolve(stylePath);
-    if (seen.has(normalizedPath)) return '';
-    seen.add(normalizedPath);
-    const css = fs.readFileSync(stylePath, 'utf8');
-    const root = this.parse(css, stylePath);
-    const imports = [];
-    root.walkAtRules('import', (rule) => {
-      const specifier = this.parseImportSpecifier(rule.params);
-      if (specifier) imports.push({ rule, specifier });
-    });
-    for (const { rule, specifier } of imports) {
-      const importedPath = this.resolver.resolveStyleDependency(
-        specifier,
-        path.dirname(stylePath),
-      );
-      if (!importedPath) continue;
-      const content = this.readStyleFile(importedPath, seen);
-      if (!content.trim()) {
-        rule.remove();
-        continue;
-      }
-      rule.replaceWith(...(this.parse(content, importedPath).nodes ?? []));
+    appendImportRule(root, specifier) {
+        const rule = postcss.atRule({
+            name: 'import',
+            params: `"${specifier}"`,
+        });
+        if (root.nodes?.length)
+            rule.raws.before = '\n';
+        root.append(rule);
+        root.raws.semicolon = true;
     }
-    return root.toString();
-  }
-  collectImportedStyleFiles(styleFiles) {
-    const imported = new Set();
-    for (const styleFile of styleFiles) {
-      const css = fs.readFileSync(styleFile, 'utf8');
-      const root = this.parse(css, styleFile);
-      root.walkAtRules('import', (rule) => {
-        const specifier = this.parseImportSpecifier(rule.params);
-        if (
-          !specifier?.startsWith('.') ||
-          !this.config.styleExtensions.includes(path.extname(specifier))
-        ) {
-          return;
+    stringify(root) {
+        root.raws.semicolon = true;
+        return `${root}\n`;
+    }
+    appendStyleContent(target, content, from) {
+        const root = this.parse(content, from);
+        if (target.nodes?.length && root.nodes?.[0]) {
+            root.nodes[0].raws.before = '\n';
         }
-        imported.add(path.resolve(path.dirname(styleFile), specifier));
-      });
+        target.append(...(root.nodes ?? []));
     }
-    return imported;
-  }
-  collectStyleImportSpecifiers(styleFiles) {
-    const specifiers = new Set();
-    for (const styleFile of styleFiles) {
-      const css = fs.readFileSync(styleFile, 'utf8');
-      const root = this.parse(css, styleFile);
-      root.walkAtRules('import', (rule) => {
-        const specifier = this.parseImportSpecifier(rule.params);
-        if (specifier) specifiers.add(specifier);
-      });
+    readStyleFile(stylePath, seen = new Set()) {
+        if (!fs.existsSync(stylePath)) {
+            return '';
+        }
+        const normalizedPath = path.resolve(stylePath);
+        if (seen.has(normalizedPath))
+            return '';
+        seen.add(normalizedPath);
+        const css = fs.readFileSync(stylePath, 'utf8');
+        const root = this.parse(css, stylePath);
+        const imports = [];
+        root.walkAtRules('import', (rule) => {
+            const specifier = this.parseImportSpecifier(rule.params);
+            if (specifier)
+                imports.push({ rule, specifier });
+        });
+        for (const { rule, specifier } of imports) {
+            const importedPath = this.resolver.resolveStyleDependency(specifier, path.dirname(stylePath));
+            if (!importedPath)
+                continue;
+            const content = this.readStyleFile(importedPath, seen);
+            if (!content.trim()) {
+                rule.remove();
+                continue;
+            }
+            rule.replaceWith(...(this.parse(content, importedPath).nodes ?? []));
+        }
+        return root.toString();
     }
-    return specifiers;
-  }
-  parse(code, from) {
-    // Keep parsing behind one method so future style languages can transform
-    // to CSS before PostCSS reads the final stylesheet.
-    return postcss.parse(code, { from });
-  }
-  parseImportSpecifier(params) {
-    const value = params.trim();
-    const first = value[0];
-    if (first === '"' || first === "'") {
-      const end = value.indexOf(first, 1);
-      return end > 0 ? value.slice(1, end) : null;
+    collectImportedStyleFiles(styleFiles) {
+        const imported = new Set();
+        for (const styleFile of styleFiles) {
+            const css = fs.readFileSync(styleFile, 'utf8');
+            const root = this.parse(css, styleFile);
+            root.walkAtRules('import', (rule) => {
+                const specifier = this.parseImportSpecifier(rule.params);
+                if (!specifier?.startsWith('.') ||
+                    !this.config.styleExtensions.includes(path.extname(specifier))) {
+                    return;
+                }
+                imported.add(path.resolve(path.dirname(styleFile), specifier));
+            });
+        }
+        return imported;
     }
-    if (!value.startsWith('url(')) {
-      return null;
+    collectStyleImportSpecifiers(styleFiles) {
+        const specifiers = new Set();
+        for (const styleFile of styleFiles) {
+            const css = fs.readFileSync(styleFile, 'utf8');
+            const root = this.parse(css, styleFile);
+            root.walkAtRules('import', (rule) => {
+                const specifier = this.parseImportSpecifier(rule.params);
+                if (specifier)
+                    specifiers.add(specifier);
+            });
+        }
+        return specifiers;
     }
-    const end = value.indexOf(')', 4);
-    if (end < 0) return null;
-    const url = value.slice(4, end).trim();
-    const quote = url[0];
-    if (quote === '"' || quote === "'") {
-      const quoteEnd = url.indexOf(quote, 1);
-      return quoteEnd > 0 ? url.slice(1, quoteEnd) : null;
+    parse(code, from) {
+        // Keep parsing behind one method so future style languages can transform
+        // to CSS before PostCSS reads the final stylesheet.
+        return postcss.parse(code, { from });
+    }
+    parseImportSpecifier(params) {
+        const value = params.trim();
+        const first = value[0];
+        if (first === '"' || first === "'") {
+            const end = value.indexOf(first, 1);
+            return end > 0 ? value.slice(1, end) : null;
+        }
+        if (!value.startsWith('url(')) {
+            return null;
+        }
+        const end = value.indexOf(')', 4);
+        if (end < 0)
+            return null;
+        const url = value.slice(4, end).trim();
+        const quote = url[0];
+        if (quote === '"' || quote === "'") {
+            const quoteEnd = url.indexOf(quote, 1);
+            return quoteEnd > 0 ? url.slice(1, quoteEnd) : null;
+        }
+        return url || null;
     }
-    return url || null;
-  }
 }

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

@@ -1,17 +1,10 @@
-import type {
-  ModuleStyleBuildConfig,
-  ResolvedModuleStyleBuildContext,
-} from '#auklet/types';
+import type { ModuleStyleBuildConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
 export declare class WorkspaceStyleResolver {
-  private readonly config;
-  private readonly context;
-  private readonly require;
-  constructor(
-    config: ModuleStyleBuildConfig,
-    context: ResolvedModuleStyleBuildContext,
-  );
-  resolveStyleDependency(specifier: string, fromDir?: string): string;
-  toOutputStyleSpecifier(specifier: string, outRoot: string): string;
-  toExternalStyleSpecifier(specifier: string, outRoot: string): string;
-  private getStylePathOutputFormat;
+    private readonly config;
+    private readonly context;
+    private readonly require;
+    constructor(config: ModuleStyleBuildConfig, context: ResolvedModuleStyleBuildContext);
+    resolveStyleDependency(specifier: string, fromDir?: string): string;
+    toOutputStyleSpecifier(specifier: string, outRoot: string): string;
+    toExternalStyleSpecifier(specifier: string, outRoot: string): string;
 }

package/dist/css/core/workspaceStyleResolver.js

@@ -1,84 +1,42 @@
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { NODE_MODULES_DIR, STYLE_ENTRY } from '#auklet/css/constants';
-import { POSIX_SEPARATOR } from '#auklet/utils';
-import { parsePackageStyleSpecifier } from '#auklet/css/core/style/specifier';
+import { NODE_MODULES_DIR } from '#auklet/css/constants';
+import { createExternalStyleSpecifier, createOutputStyleSpecifier, } from '#auklet/css/core/style/specifier';
 export class WorkspaceStyleResolver {
-  config;
-  context;
-  require;
-  constructor(config, context) {
-    this.config = config;
-    this.context = context;
-    this.require = createRequire(
-      path.join(this.context.packageRoot, 'package.json'),
-    );
-  }
-  resolveStyleDependency(specifier, fromDir = this.context.packageRoot) {
-    if (specifier.startsWith('.')) {
-      return path.resolve(fromDir, specifier);
+    config;
+    context;
+    require;
+    constructor(config, context) {
+        this.config = config;
+        this.context = context;
+        this.require = createRequire(path.join(this.context.packageRoot, 'package.json'));
     }
-    try {
-      return this.require.resolve(specifier, {
-        paths: [this.context.packageRoot],
-      });
-    } catch {
-      return path.resolve(
-        this.context.packageRoot,
-        NODE_MODULES_DIR,
-        specifier,
-      );
+    resolveStyleDependency(specifier, fromDir = this.context.packageRoot) {
+        if (specifier.startsWith('.')) {
+            return path.resolve(fromDir, specifier);
+        }
+        try {
+            return this.require.resolve(specifier, {
+                paths: [this.context.packageRoot],
+            });
+        }
+        catch {
+            return path.resolve(this.context.packageRoot, NODE_MODULES_DIR, specifier);
+        }
     }
-  }
-  toOutputStyleSpecifier(specifier, outRoot) {
-    const parsed = parsePackageStyleSpecifier(specifier);
-    if (!parsed) return specifier;
-    const { packageName, stylePath } = parsed;
-    const currentOutputFormat = path.basename(outRoot);
-    const outputFormat = this.getStylePathOutputFormat(stylePath);
-    if (outputFormat) {
-      return [packageName, currentOutputFormat, outputFormat.path].join(
-        POSIX_SEPARATOR,
-      );
+    toOutputStyleSpecifier(specifier, outRoot) {
+        return createOutputStyleSpecifier(specifier, {
+            currentOutputFormat: path.basename(outRoot),
+            outputFormats: this.config.output.outputFormats,
+        });
     }
-    return specifier;
-  }
-  toExternalStyleSpecifier(specifier, outRoot) {
-    const parsed = parsePackageStyleSpecifier(specifier);
-    if (!parsed) return specifier;
-    const { packageName, stylePath } = parsed;
-    const currentOutputFormat = path.basename(outRoot);
-    const outputFormat = this.getStylePathOutputFormat(stylePath);
-    if (stylePath === STYLE_ENTRY) {
-      return [packageName, this.config.output.externalStyleFile].join(
-        POSIX_SEPARATOR,
-      );
+    toExternalStyleSpecifier(specifier, outRoot) {
+        return createExternalStyleSpecifier(specifier, {
+            currentOutputFormat: path.basename(outRoot),
+            outputFormats: this.config.output.outputFormats,
+            styleDir: this.config.output.styleDir,
+            indexStyleFile: this.config.output.indexStyleFile,
+            externalStyleFile: this.config.output.externalStyleFile,
+        });
     }
-    if (
-      outputFormat &&
-      outputFormat.path ===
-        [this.config.output.styleDir, this.config.output.indexStyleFile].join(
-          POSIX_SEPARATOR,
-        )
-    ) {
-      return [
-        packageName,
-        currentOutputFormat,
-        this.config.output.styleDir,
-        this.config.output.externalStyleFile,
-      ].join(POSIX_SEPARATOR);
-    }
-    return specifier;
-  }
-  getStylePathOutputFormat(stylePath) {
-    for (const format of this.config.output.outputFormats) {
-      const prefix = `${format}${POSIX_SEPARATOR}`;
-      if (!stylePath.startsWith(prefix)) continue;
-      return {
-        format,
-        path: stylePath.slice(prefix.length),
-      };
-    }
-    return null;
-  }
 }

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

@@ -1,18 +1,11 @@
-import type {
-  ModuleStyleBuildConfig,
-  ModuleStyleBuildContext,
-  ModuleStyleBuildOptions,
-} from '#auklet/types';
+import type { ModuleStyleBuildConfig, ModuleStyleBuildContext, ModuleStyleBuildOptions } from '#auklet/types';
 export declare class ModuleStyleBuilder {
-  private readonly config;
-  private readonly context;
-  private readonly logger?;
-  constructor(
-    context?: ModuleStyleBuildContext,
-    config?: ModuleStyleBuildConfig,
-  );
-  build(options?: ModuleStyleBuildOptions): Promise<void>;
-  private logOutputs;
-  private createBuildContext;
-  private createPackageContext;
+    private readonly config;
+    private readonly context;
+    private readonly logger?;
+    constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig);
+    build(options?: ModuleStyleBuildOptions): Promise<void>;
+    private logOutputs;
+    private createBuildContext;
+    private createPackageContext;
 }