auklet 0.0.16 → 0.0.17

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,11 @@
-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;
+    private getStylePathOutputFormat;
 }

package/dist/css/core/workspaceStyleResolver.js

@@ -4,81 +4,71 @@ import { NODE_MODULES_DIR, STYLE_ENTRY } from '#auklet/css/constants';
 import { POSIX_SEPARATOR } from '#auklet/utils';
 import { parsePackageStyleSpecifier } 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) {
+        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);
+        }
+        return specifier;
     }
-    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) {
+        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);
+        }
+        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;
     }
-    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);
+    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;
     }
-    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;
 }

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/componentWriter.js

@@ -1,71 +1,50 @@
 import path from 'node:path';
-import { writeStyleFile } from '#auklet/css/production/format/shared';
+import { writeStyleFile, } from '#auklet/css/production/format/shared';
 import { toPosixPath } from '#auklet/utils';
 export class ComponentStyleEntryWriter {
-  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);
+    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) => {
+            if (specifier.startsWith('.'))
+                return specifier;
+            if (!path.isAbsolute(specifier))
+                return specifier;
+            return toPosixPath(path.relative(styleDir, specifier));
+        });
+    }
+    getOwnStyleSpecifiers(ownStyleFiles, styleDir, outRoot) {
+        return ownStyleFiles.map((styleFile) => toPosixPath(path.relative(styleDir, path.join(outRoot, path.relative(this.sourceRoot, styleFile)))));
     }
-    return outputs;
-  }
-  getModuleStyleSpecifiers(specifiers, styleDir) {
-    return specifiers.map((specifier) => {
-      if (specifier.startsWith('.')) return specifier;
-      if (!path.isAbsolute(specifier)) return specifier;
-      return toPosixPath(path.relative(styleDir, specifier));
-    });
-  }
-  getOwnStyleSpecifiers(ownStyleFiles, styleDir, outRoot) {
-    return ownStyleFiles.map((styleFile) =>
-      toPosixPath(
-        path.relative(
-          styleDir,
-          path.join(outRoot, path.relative(this.sourceRoot, styleFile)),
-        ),
-      ),
-    );
-  }
 }