auklet 0.0.3 → 0.0.5

package/dist/css/core/stylePackageContext.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+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 { 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)));
+  }
+}

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

@@ -1,15 +1,15 @@
 import postcss, { type Root } from 'postcss';
-import type { ModuleCssBuildConfig } from '#auklet/types';
+import type { ModuleStyleBuildConfig } from '#auklet/types';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
 export declare class StyleProcessor {
   private readonly config;
   private readonly resolver;
-  constructor(config: ModuleCssBuildConfig, resolver: WorkspaceStyleResolver);
+  constructor(config: ModuleStyleBuildConfig, resolver: WorkspaceStyleResolver);
   createRoot(): postcss.Root;
   appendImportRule(root: Root, specifier: string): void;
   stringify(root: Root): string;
   appendStyleContent(target: Root, content: string, from: string): void;
-  readStyleFile(cssPath: string, seen?: Set<string>): string;
+  readStyleFile(stylePath: string, seen?: Set<string>): string;
   collectImportedStyleFiles(styleFiles: Array<string>): Set<string>;
   private parse;
   private parseImportSpecifier;

package/dist/css/core/styleProcessor.js

@@ -1,12 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import postcss from 'postcss';
-import {
-  IMPORT_AT_RULE,
-  LINE_SEPARATOR,
-  RELATIVE_IMPORT_PREFIX,
-} from '#auklet/css/core/constants';
 export class StyleProcessor {
+  config;
+  resolver;
   constructor(config, resolver) {
     this.config = config;
     this.resolver = resolver;
@@ -15,50 +12,43 @@ export class StyleProcessor {
     return postcss.root();
   }
   appendImportRule(root, specifier) {
-    var _a;
     const rule = postcss.atRule({
-      name: IMPORT_AT_RULE,
+      name: 'import',
       params: `"${specifier}"`,
     });
-    if ((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length)
-      rule.raws.before = LINE_SEPARATOR;
+    if (root.nodes?.length) rule.raws.before = '\n';
     root.append(rule);
     root.raws.semicolon = true;
   }
   stringify(root) {
     root.raws.semicolon = true;
-    return `${root}${LINE_SEPARATOR}`;
+    return `${root}\n`;
   }
   appendStyleContent(target, content, from) {
-    var _a, _b, _c;
     const root = this.parse(content, from);
-    if (
-      ((_a = target.nodes) === null || _a === void 0 ? void 0 : _a.length) &&
-      ((_b = root.nodes) === null || _b === void 0 ? void 0 : _b[0])
-    ) {
-      root.nodes[0].raws.before = LINE_SEPARATOR;
+    if (target.nodes?.length && root.nodes?.[0]) {
+      root.nodes[0].raws.before = '\n';
     }
-    target.append(...((_c = root.nodes) !== null && _c !== void 0 ? _c : []));
+    target.append(...(root.nodes ?? []));
   }
-  readStyleFile(cssPath, seen = new Set()) {
-    var _a;
-    if (!fs.existsSync(cssPath)) {
+  readStyleFile(stylePath, seen = new Set()) {
+    if (!fs.existsSync(stylePath)) {
       return '';
     }
-    const normalizedPath = path.resolve(cssPath);
+    const normalizedPath = path.resolve(stylePath);
     if (seen.has(normalizedPath)) return '';
     seen.add(normalizedPath);
-    const css = fs.readFileSync(cssPath, 'utf8');
-    const root = this.parse(css, cssPath);
+    const css = fs.readFileSync(stylePath, 'utf8');
+    const root = this.parse(css, stylePath);
     const imports = [];
-    root.walkAtRules(IMPORT_AT_RULE, (rule) => {
+    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(cssPath),
+        path.dirname(stylePath),
       );
       if (!importedPath) continue;
       const content = this.readStyleFile(importedPath, seen);
@@ -66,12 +56,7 @@ export class StyleProcessor {
         rule.remove();
         continue;
       }
-      rule.replaceWith(
-        ...((_a = this.parse(content, importedPath).nodes) !== null &&
-        _a !== void 0
-          ? _a
-          : []),
-      );
+      rule.replaceWith(...(this.parse(content, importedPath).nodes ?? []));
     }
     return root.toString();
   }
@@ -80,12 +65,10 @@ export class StyleProcessor {
     for (const styleFile of styleFiles) {
       const css = fs.readFileSync(styleFile, 'utf8');
       const root = this.parse(css, styleFile);
-      root.walkAtRules(IMPORT_AT_RULE, (rule) => {
+      root.walkAtRules('import', (rule) => {
         const specifier = this.parseImportSpecifier(rule.params);
         if (
-          !(specifier === null || specifier === void 0
-            ? void 0
-            : specifier.startsWith(RELATIVE_IMPORT_PREFIX)) ||
+          !specifier?.startsWith('.') ||
           !this.config.styleExtensions.includes(path.extname(specifier))
         ) {
           return;

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

@@ -1,18 +1,17 @@
 import type {
-  ModuleCssBuildConfig,
-  ResolvedModuleCssBuildContext,
+  ModuleStyleBuildConfig,
+  ResolvedModuleStyleBuildContext,
 } from '#auklet/types';
 export declare class WorkspaceStyleResolver {
   private readonly config;
   private readonly context;
   private readonly require;
   constructor(
-    config: ModuleCssBuildConfig,
-    context: ResolvedModuleCssBuildContext,
+    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 parsePackageStyleSpecifier;
 }

package/dist/css/core/workspaceStyleResolver.js

@@ -1,9 +1,12 @@
 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';
-const NODE_MODULES_DIR = 'node_modules';
-const PACKAGE_STYLE_FILE = 'style.css';
+import { parsePackageStyleSpecifier } from '#auklet/css/core/style/specifier';
 export class WorkspaceStyleResolver {
+  config;
+  context;
+  require;
   constructor(config, context) {
     this.config = config;
     this.context = context;
@@ -19,7 +22,7 @@ export class WorkspaceStyleResolver {
       return this.require.resolve(specifier, {
         paths: [this.context.packageRoot],
       });
-    } catch (_a) {
+    } catch {
       return path.resolve(
         this.context.packageRoot,
         NODE_MODULES_DIR,
@@ -28,7 +31,7 @@ export class WorkspaceStyleResolver {
     }
   }
   toOutputStyleSpecifier(specifier, outRoot) {
-    const parsed = this.parsePackageStyleSpecifier(specifier);
+    const parsed = parsePackageStyleSpecifier(specifier);
     if (!parsed) return specifier;
     const { packageName, stylePath } = parsed;
     const currentOutputFormat = path.basename(outRoot);
@@ -41,20 +44,20 @@ export class WorkspaceStyleResolver {
     return specifier;
   }
   toExternalStyleSpecifier(specifier, outRoot) {
-    const parsed = this.parsePackageStyleSpecifier(specifier);
+    const parsed = parsePackageStyleSpecifier(specifier);
     if (!parsed) return specifier;
     const { packageName, stylePath } = parsed;
     const currentOutputFormat = path.basename(outRoot);
     const outputFormat = this.getStylePathOutputFormat(stylePath);
-    if (stylePath === PACKAGE_STYLE_FILE) {
-      return [packageName, this.config.output.externalCssFile].join(
+    if (stylePath === STYLE_ENTRY) {
+      return [packageName, this.config.output.externalStyleFile].join(
         POSIX_SEPARATOR,
       );
     }
     if (
       outputFormat &&
       outputFormat.path ===
-        [this.config.output.styleDir, this.config.output.indexCssFile].join(
+        [this.config.output.styleDir, this.config.output.indexStyleFile].join(
           POSIX_SEPARATOR,
         )
     ) {
@@ -62,7 +65,7 @@ export class WorkspaceStyleResolver {
         packageName,
         currentOutputFormat,
         this.config.output.styleDir,
-        this.config.output.externalCssFile,
+        this.config.output.externalStyleFile,
       ].join(POSIX_SEPARATOR);
     }
     return specifier;
@@ -78,23 +81,4 @@ export class WorkspaceStyleResolver {
     }
     return null;
   }
-  parsePackageStyleSpecifier(specifier) {
-    var _a, _b, _c;
-    if (specifier.startsWith('.')) return null;
-    const parts = specifier.split(POSIX_SEPARATOR);
-    const packageName = specifier.startsWith('@')
-      ? `${
-          (_a = parts.shift()) !== null && _a !== void 0 ? _a : ''
-        }${POSIX_SEPARATOR}${
-          (_b = parts.shift()) !== null && _b !== void 0 ? _b : ''
-        }`
-      : (_c = parts.shift()) !== null && _c !== void 0
-      ? _c
-      : '';
-    if (!packageName) return null;
-    return {
-      packageName,
-      stylePath: parts.join(POSIX_SEPARATOR),
-    };
-  }
 }

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

@@ -0,0 +1,18 @@
+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;
+}

package/dist/css/production/builder.js

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import { normalizeAukletConfig } from '#auklet/config';
+import { moduleStyleBuildConfig } from '#auklet/css/config';
+import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
+import { ModuleStyleOutputWriter } from '#auklet/css/production/moduleOutputWriter';
+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());
+    }
+    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,
+    });
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { ModuleStyleEntryPlan } from '#auklet/css/core/styleModuleEntryPlanner';
+import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
+export declare class ComponentStyleEntryWriter {
+  private readonly config;
+  private readonly sourceRoot;
+  private readonly resolver;
+  private readonly styleProcessor;
+  constructor(options: FormatWriterOptions);
+  write(outRoot: string, entries: Array<ModuleStyleEntryPlan>): string[];
+  private getModuleStyleSpecifiers;
+  private getOwnStyleSpecifiers;
+}

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

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { emptyModuleEntryComment } 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 sourceStyleSpecifiers = [
+        ...this.getModuleStyleSpecifiers(entry.moduleStyleImports, 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),
+        );
+      }
+      fs.mkdirSync(styleDir, { recursive: true });
+      fs.writeFileSync(
+        target,
+        root.nodes?.length
+          ? this.styleProcessor.stringify(root)
+          : emptyModuleEntryComment,
+      );
+      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)),
+        ),
+      ),
+    );
+  }
+}

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

@@ -0,0 +1,12 @@
+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;
+}

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

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createStyleEntryParts } from '#auklet/css/core/style/plan';
+import { 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),
+          );
+        }
+        continue;
+      }
+      if (moduleStyle) {
+        this.styleProcessor.appendImportRule(
+          root,
+          toRelativeImportSpecifier(styleDir, moduleStyle),
+        );
+      }
+    }
+    if (!root.nodes?.length) return null;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, this.styleProcessor.stringify(root));
+    return target;
+  }
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createExternalEntryParts } from '#auklet/css/core/style/plan';
+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),
+        );
+      }
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(
+      target,
+      root.nodes?.length ? this.styleProcessor.stringify(root) : '',
+    );
+    return target;
+  }
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import path from 'node:path';
+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);
+      }
+    }
+    if (!root.nodes?.length) return null;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, this.styleProcessor.stringify(root));
+    return target;
+  }
+}

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

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

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

@@ -0,0 +1,8 @@
+import path from 'node:path';
+import { toPosixPath } from '#auklet/utils';
+export const emptyModuleEntryComment =
+  '/* Empty style entry kept so automated tooling can resolve this module CSS path. */\n';
+export function toRelativeImportSpecifier(fromDir, file) {
+  const relative = toPosixPath(path.relative(fromDir, file));
+  return relative.startsWith('.') ? relative : `./${relative}`;
+}

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

@@ -0,0 +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;
+}