auklet 0.0.15 → 0.0.17

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)),
-        ),
-      ),
-    );
-  }
 }

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

@@ -1,12 +1,8 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class StyleEntryWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  write(
-    outRoot: string,
-    themeStyles: Map<string, string>,
-    moduleStyle: string | null,
-  ): string | null;
+    private readonly config;
+    private readonly packageContext;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    write(outRoot: string, themeStyles: Map<string, string>, moduleStyle: string | null): string | null;
 }

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.d.ts

@@ -1,9 +1,9 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class ExternalStyleWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly resolver;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  write(outRoot: string): string;
+    private readonly config;
+    private readonly packageContext;
+    private readonly resolver;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    write(outRoot: string): string;
 }

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/moduleWriter.d.ts

@@ -1,8 +1,8 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class ModuleStyleWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  write(outRoot: string): string | null;
+    private readonly config;
+    private readonly packageContext;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    write(outRoot: string): string | null;
 }

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';
+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 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,12 @@
 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 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}`;
+    const relative = toPosixPath(path.relative(fromDir, file));
+    return relative.startsWith('.') ? relative : `./${relative}`;
 }
 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.d.ts

@@ -1,6 +1,6 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class SourceStyleFileWriter {
-  private readonly sourceRoot;
-  constructor(options: FormatWriterOptions);
-  copy(files: Array<string>, outRoot: string): void;
+    private readonly sourceRoot;
+    constructor(options: FormatWriterOptions);
+    copy(files: Array<string>, outRoot: string): void;
 }

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.d.ts

@@ -1,16 +1,10 @@
-import {
-  type FormatWriterOptions,
-  type ThemeStyleOutput,
-} from '#auklet/css/production/format/shared';
+import { type FormatWriterOptions, type ThemeStyleOutput } from '#auklet/css/production/format/shared';
 export declare class ThemeStyleWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  clean(outRoot: string): void;
-  writeThemeStyles(outRoot: string): ThemeStyleOutput[];
-  writeThemeEntries(
-    themeStyles: Map<string, string>,
-    outRoot: string,
-  ): string[];
+    private readonly config;
+    private readonly packageContext;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    clean(outRoot: string): void;
+    writeThemeStyles(outRoot: string): ThemeStyleOutput[];
+    writeThemeEntries(themeStyles: Map<string, string>, outRoot: string): string[];
 }

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;
-  }
 }