auklet 0.0.16 → 0.0.17

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/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.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 componentWriter;
+    constructor(options: ModuleStyleOutputWriterOptions);
+    write(): string[];
+    private get outputRoot();
+    private createComponentEntries;
+    private writeFormat;
 }

package/dist/css/production/moduleOutputWriter.js

@@ -8,70 +8,61 @@ import { SourceStyleFileWriter } from '#auklet/css/production/format/sourceWrite
 import { ThemeStyleWriter } from '#auklet/css/production/format/themeWriter';
 // Coordinates all module-mode style output under format directories such as `dist/es` and `dist/lib`.
 export class ModuleStyleOutputWriter {
-  config;
-  context;
-  packageContext;
-  sourceWriter;
-  themeWriter;
-  externalWriter;
-  moduleWriter;
-  entryWriter;
-  componentWriter;
-  constructor(options) {
-    this.config = options.config;
-    this.context = options.context;
-    this.packageContext = options.packageContext;
-    this.sourceWriter = new SourceStyleFileWriter(options);
-    this.themeWriter = new ThemeStyleWriter(options);
-    this.externalWriter = new ExternalStyleWriter(options);
-    this.moduleWriter = new ModuleStyleWriter(options);
-    this.entryWriter = new StyleEntryWriter(options);
-    this.componentWriter = new ComponentStyleEntryWriter(options);
-  }
-  write() {
-    const componentEntries = this.createComponentEntries();
-    const outputs = [];
-    for (const format of this.config.output.outputFormats) {
-      outputs.push(...this.writeFormat(format, componentEntries));
+    config;
+    context;
+    packageContext;
+    sourceWriter;
+    themeWriter;
+    externalWriter;
+    moduleWriter;
+    entryWriter;
+    componentWriter;
+    constructor(options) {
+        this.config = options.config;
+        this.context = options.context;
+        this.packageContext = options.packageContext;
+        this.sourceWriter = new SourceStyleFileWriter(options);
+        this.themeWriter = new ThemeStyleWriter(options);
+        this.externalWriter = new ExternalStyleWriter(options);
+        this.moduleWriter = new ModuleStyleWriter(options);
+        this.entryWriter = new StyleEntryWriter(options);
+        this.componentWriter = new ComponentStyleEntryWriter(options);
+    }
+    write() {
+        const componentEntries = this.createComponentEntries();
+        const outputs = [];
+        for (const format of this.config.output.outputFormats) {
+            outputs.push(...this.writeFormat(format, componentEntries));
+        }
+        return outputs;
+    }
+    get outputRoot() {
+        return path.join(this.context.packageRoot, this.context.outputDir);
+    }
+    createComponentEntries() {
+        return createComponentStyleEntryPlans(this.packageContext);
+    }
+    writeFormat(format, componentEntries) {
+        const outRoot = path.join(this.outputRoot, format);
+        const outputs = [];
+        this.themeWriter.clean(outRoot);
+        this.sourceWriter.copy(this.packageContext.styleFiles, outRoot);
+        const themeStyles = this.themeWriter.writeThemeStyles(outRoot);
+        const themeStyleMap = new Map(themeStyles.map((themeStyle) => [themeStyle.themeName, themeStyle.file]));
+        const themeEntries = this.themeWriter.writeThemeEntries(themeStyleMap, outRoot);
+        const externalStyle = this.externalWriter.write(outRoot);
+        const moduleStyle = this.moduleWriter.write(outRoot);
+        const entryStyle = this.entryWriter.write(outRoot, themeStyleMap, moduleStyle);
+        const componentStyles = this.componentWriter.write(outRoot, componentEntries);
+        outputs.push(...themeStyles.map((themeStyle) => themeStyle.file));
+        outputs.push(...themeEntries);
+        if (externalStyle)
+            outputs.push(externalStyle);
+        if (moduleStyle)
+            outputs.push(moduleStyle);
+        if (entryStyle)
+            outputs.push(entryStyle);
+        outputs.push(...componentStyles);
+        return outputs;
     }
-    return outputs;
-  }
-  get outputRoot() {
-    return path.join(this.context.packageRoot, this.context.outputDir);
-  }
-  createComponentEntries() {
-    return createComponentStyleEntryPlans(this.packageContext);
-  }
-  writeFormat(format, componentEntries) {
-    const outRoot = path.join(this.outputRoot, format);
-    const outputs = [];
-    this.themeWriter.clean(outRoot);
-    this.sourceWriter.copy(this.packageContext.styleFiles, outRoot);
-    const themeStyles = this.themeWriter.writeThemeStyles(outRoot);
-    const themeStyleMap = new Map(
-      themeStyles.map((themeStyle) => [themeStyle.themeName, themeStyle.file]),
-    );
-    const themeEntries = this.themeWriter.writeThemeEntries(
-      themeStyleMap,
-      outRoot,
-    );
-    const externalStyle = this.externalWriter.write(outRoot);
-    const moduleStyle = this.moduleWriter.write(outRoot);
-    const entryStyle = this.entryWriter.write(
-      outRoot,
-      themeStyleMap,
-      moduleStyle,
-    );
-    const componentStyles = this.componentWriter.write(
-      outRoot,
-      componentEntries,
-    );
-    outputs.push(...themeStyles.map((themeStyle) => themeStyle.file));
-    outputs.push(...themeEntries);
-    if (externalStyle) outputs.push(externalStyle);
-    if (moduleStyle) outputs.push(moduleStyle);
-    if (entryStyle) outputs.push(entryStyle);
-    outputs.push(...componentStyles);
-    return outputs;
-  }
 }

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

@@ -1,20 +1,17 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
-import type {
-  ModuleStyleBuildConfig,
-  ResolvedModuleStyleBuildContext,
-} from '#auklet/types';
+import type { ModuleStyleBuildConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
 export type PackageStyleEntryWriterOptions = {
-  config: ModuleStyleBuildConfig;
-  context: ResolvedModuleStyleBuildContext;
-  packageContext: StylePackageContext;
+    config: ModuleStyleBuildConfig;
+    context: ResolvedModuleStyleBuildContext;
+    packageContext: StylePackageContext;
 };
 export declare class PackageStyleEntryWriter {
-  private readonly config;
-  private readonly context;
-  private readonly packageContext;
-  private readonly resolver;
-  private readonly styleProcessor;
-  constructor(options: PackageStyleEntryWriterOptions);
-  write(): string | null;
-  private get outputRoot();
+    private readonly config;
+    private readonly context;
+    private readonly packageContext;
+    private readonly resolver;
+    private readonly styleProcessor;
+    constructor(options: PackageStyleEntryWriterOptions);
+    write(): string | null;
+    private get outputRoot();
 }