auklet 0.0.1 → 0.0.3

package/dist/css/core/workspaceStyleResolver.js

@@ -0,0 +1,100 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { POSIX_SEPARATOR } from '#auklet/utils';
+const NODE_MODULES_DIR = 'node_modules';
+const PACKAGE_STYLE_FILE = 'style.css';
+export class WorkspaceStyleResolver {
+  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);
+    }
+    try {
+      return this.require.resolve(specifier, {
+        paths: [this.context.packageRoot],
+      });
+    } catch (_a) {
+      return path.resolve(
+        this.context.packageRoot,
+        NODE_MODULES_DIR,
+        specifier,
+      );
+    }
+  }
+  toOutputStyleSpecifier(specifier, outRoot) {
+    const parsed = this.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;
+  }
+  toExternalStyleSpecifier(specifier, outRoot) {
+    const parsed = this.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(
+        POSIX_SEPARATOR,
+      );
+    }
+    if (
+      outputFormat &&
+      outputFormat.path ===
+        [this.config.output.styleDir, this.config.output.indexCssFile].join(
+          POSIX_SEPARATOR,
+        )
+    ) {
+      return [
+        packageName,
+        currentOutputFormat,
+        this.config.output.styleDir,
+        this.config.output.externalCssFile,
+      ].join(POSIX_SEPARATOR);
+    }
+    return specifier;
+  }
+  getStylePathOutputFormat(stylePath) {
+    for (const format of this.config.output.outputFormats) {
+      const prefix = `${format}${POSIX_SEPARATOR}`;
+      if (!stylePath.startsWith(prefix)) continue;
+      return {
+        format,
+        path: stylePath.slice(prefix.length),
+      };
+    }
+    return null;
+  }
+  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/moduleCssBuilder.d.ts

@@ -0,0 +1,33 @@
+import type {
+  ModuleCssBuildConfig,
+  ModuleCssBuildContext,
+  ModuleCssBuildOptions,
+} from '#auklet/types';
+export declare class ModuleCssBuilder {
+  private readonly config;
+  private readonly context;
+  private readonly logger?;
+  private srcRoot;
+  private resolver;
+  private styleProcessor;
+  private importCollector;
+  constructor(context?: ModuleCssBuildContext, config?: ModuleCssBuildConfig);
+  build(options?: ModuleCssBuildOptions): Promise<void>;
+  private getStyleFiles;
+  private createBuildContext;
+  private applyContext;
+  private copyStyleFiles;
+  private writePackageStyles;
+  private writeEntryStyle;
+  private writeThemeStyles;
+  private writeThemeEntries;
+  private cleanThemeStyles;
+  private writeModuleStyle;
+  private writeExternalStyle;
+  private writeComponentStyleEntries;
+  private getSourceModuleDirs;
+  private getOwnStyleDirs;
+  private getModuleStyleSpecifiers;
+  private getDirStyleSpecifiers;
+  private toRelativeImportSpecifier;
+}

package/dist/css/production/moduleCssBuilder.js

@@ -0,0 +1,445 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { moduleCssBuildConfig } from '#auklet/css/core/config';
+import { aukletDefaultCssOptions } from '#auklet/config';
+import { StyleProcessor } from '#auklet/css/core/styleProcessor';
+import { ModuleStyleImportCollector } from '#auklet/css/core/moduleStyleImportCollector';
+import {
+  THEMES_DIR,
+  createStyleFileKey,
+  createStyleFileKeySet,
+  groupStyleFilesByDir,
+  getExternalStyleDependencies,
+  getGlobalStyleDependencies,
+  getThemeStyleDependencies,
+  resolveThemeStyleFiles,
+} from '#auklet/css/core/styleEntry';
+import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+import { fileWalker, getSourceModuleDir, toPosixPath } from '#auklet/utils';
+const EMPTY_MODULE_STYLE_ENTRY_COMMENT =
+  '/* Empty style entry kept so automated tooling can resolve this module CSS path. */\n';
+export class ModuleCssBuilder {
+  constructor(context = {}, config = moduleCssBuildConfig) {
+    this.config = config;
+    this.context = {
+      packageRoot: process.cwd(),
+      sourceDir: context.sourceDir,
+      outputDir: context.outputDir,
+      ...context,
+    };
+    this.logger = context.logger;
+    this.applyContext(this.createBuildContext({}));
+  }
+  async build(options = {}) {
+    var _a, _b, _c, _d, _e, _f;
+    const cssOptions =
+      (_b =
+        (_a = options.aukletConfig) !== null && _a !== void 0
+          ? _a
+          : this.context.aukletConfig) !== null && _b !== void 0
+        ? _b
+        : {};
+    const logger =
+      (_c = options.logger) !== null && _c !== void 0 ? _c : this.logger;
+    const context = this.createBuildContext(cssOptions);
+    this.applyContext(context);
+    (_d = logger === null || logger === void 0 ? void 0 : logger.log) ===
+      null || _d === void 0
+      ? void 0
+      : _d.call(
+          logger,
+          `[auklet:css] build ${path.basename(context.packageRoot)}`,
+        );
+    const sourceFiles = fileWalker(this.srcRoot);
+    const themeFiles = resolveThemeStyleFiles(cssOptions, context.packageRoot);
+    const themeFileKeys = createStyleFileKeySet(themeFiles.values());
+    const styleFiles = this.getStyleFiles(sourceFiles).filter(
+      (styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)),
+    );
+    const moduleStyleImports = this.importCollector.collect(
+      sourceFiles,
+      cssOptions,
+    );
+    const outputs = [];
+    const packageStyle = this.writePackageStyles(
+      styleFiles,
+      themeFiles,
+      cssOptions,
+      context,
+    );
+    if (packageStyle) outputs.push(packageStyle);
+    for (const format of this.config.output.outputFormats) {
+      const outRoot = path.join(context.packageRoot, context.outputDir, format);
+      this.cleanThemeStyles(outRoot);
+      this.copyStyleFiles(styleFiles, outRoot);
+      const themeStyles = this.writeThemeStyles(themeFiles, outRoot);
+      const themeEntries = this.writeThemeEntries(
+        themeStyles,
+        outRoot,
+        cssOptions,
+      );
+      const externalStyle = this.writeExternalStyle(outRoot, cssOptions);
+      const moduleStyle = this.writeModuleStyle(styleFiles, outRoot);
+      const entryStyle = this.writeEntryStyle(
+        outRoot,
+        cssOptions,
+        themeStyles.map((themeStyle) => themeStyle.file),
+        moduleStyle,
+      );
+      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(
+        ...this.writeComponentStyleEntries(
+          sourceFiles,
+          styleFiles,
+          outRoot,
+          moduleStyleImports,
+        ),
+      );
+    }
+    (_e = logger === null || logger === void 0 ? void 0 : logger.log) ===
+      null || _e === void 0
+      ? void 0
+      : _e.call(
+          logger,
+          `[auklet:css] ${styleFiles.length} source style file(s), ${outputs.length} output entry file(s)`,
+        );
+    for (const output of outputs) {
+      (_f = logger === null || logger === void 0 ? void 0 : logger.log) ===
+        null || _f === void 0
+        ? void 0
+        : _f.call(
+            logger,
+            `[auklet:css] + ${toPosixPath(
+              path.relative(context.packageRoot, output),
+            )}`,
+          );
+    }
+  }
+  getStyleFiles(files) {
+    return files.filter((file) =>
+      this.config.styleExtensions.includes(path.extname(file)),
+    );
+  }
+  createBuildContext(cssOptions) {
+    var _a, _b, _c, _d;
+    return {
+      packageRoot: this.context.packageRoot,
+      sourceDir:
+        (_b =
+          (_a = cssOptions.sourceDir) !== null && _a !== void 0
+            ? _a
+            : this.context.sourceDir) !== null && _b !== void 0
+          ? _b
+          : aukletDefaultCssOptions.sourceDir,
+      outputDir:
+        (_d =
+          (_c = cssOptions.outputDir) !== null && _c !== void 0
+            ? _c
+            : this.context.outputDir) !== null && _d !== void 0
+          ? _d
+          : aukletDefaultCssOptions.outputDir,
+    };
+  }
+  applyContext(context) {
+    this.srcRoot = path.join(context.packageRoot, context.sourceDir);
+    this.resolver = new WorkspaceStyleResolver(this.config, context);
+    this.styleProcessor = new StyleProcessor(this.config, this.resolver);
+    this.importCollector = new ModuleStyleImportCollector(
+      this.srcRoot,
+      context.packageRoot,
+      this.resolver,
+      this.config.styleExtensions,
+    );
+  }
+  copyStyleFiles(files, outRoot) {
+    for (const sourceFile of files) {
+      const relative = path.relative(this.srcRoot, sourceFile);
+      const target = path.join(outRoot, relative);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.copyFileSync(sourceFile, target);
+    }
+  }
+  writePackageStyles(styleFiles, themeFiles, buildConfig, context) {
+    var _a;
+    const seen = new Set();
+    const root = this.styleProcessor.createRoot();
+    for (const cssPath of themeFiles.values()) {
+      const content = this.styleProcessor.readStyleFile(cssPath, seen);
+      if (content.trim()) {
+        this.styleProcessor.appendStyleContent(root, content, cssPath);
+      }
+    }
+    for (const specifier of getGlobalStyleDependencies(buildConfig)) {
+      const cssPath = this.resolver.resolveStyleDependency(specifier);
+      if (!cssPath) continue;
+      const content = this.styleProcessor.readStyleFile(cssPath, seen);
+      if (content.trim()) {
+        this.styleProcessor.appendStyleContent(root, content, cssPath);
+      }
+    }
+    for (const styleFile of styleFiles) {
+      const content = this.styleProcessor.readStyleFile(styleFile, seen);
+      if (content.trim()) {
+        this.styleProcessor.appendStyleContent(root, content, styleFile);
+      }
+    }
+    if (!((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length))
+      return null;
+    fs.mkdirSync(path.join(context.packageRoot, context.outputDir), {
+      recursive: true,
+    });
+    const target = path.join(
+      context.packageRoot,
+      context.outputDir,
+      this.config.output.indexCssFile,
+    );
+    fs.writeFileSync(target, this.styleProcessor.stringify(root));
+    return target;
+  }
+  writeEntryStyle(outRoot, buildConfig, themeStyles, moduleStyle) {
+    var _a;
+    const target = path.join(
+      outRoot,
+      this.config.output.styleDir,
+      this.config.output.indexCssFile,
+    );
+    const root = this.styleProcessor.createRoot();
+    const styleDir = path.dirname(target);
+    for (const specifier of getGlobalStyleDependencies(buildConfig)) {
+      this.styleProcessor.appendImportRule(root, specifier);
+    }
+    for (const style of [...themeStyles, moduleStyle]) {
+      if (!style) continue;
+      this.styleProcessor.appendImportRule(
+        root,
+        this.toRelativeImportSpecifier(styleDir, style),
+      );
+    }
+    if (!((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length))
+      return null;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, this.styleProcessor.stringify(root));
+    return target;
+  }
+  writeThemeStyles(themeFiles, outRoot) {
+    var _a;
+    const outputs = [];
+    const themesDir = path.join(
+      outRoot,
+      this.config.output.styleDir,
+      THEMES_DIR,
+    );
+    for (const [themeName, cssPath] of themeFiles) {
+      const root = this.styleProcessor.createRoot();
+      const content = this.styleProcessor.readStyleFile(cssPath);
+      if (content.trim()) {
+        this.styleProcessor.appendStyleContent(root, content, cssPath);
+      }
+      const target = path.join(themesDir, `${themeName}.css`);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(
+        target,
+        ((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length)
+          ? this.styleProcessor.stringify(root)
+          : '',
+      );
+      outputs.push({ themeName, file: target });
+    }
+    return outputs;
+  }
+  writeThemeEntries(themeStyles, outRoot, buildConfig) {
+    const outputs = [];
+    const themesDir = path.join(outRoot, THEMES_DIR);
+    for (const { themeName, file } of themeStyles) {
+      const target = path.join(themesDir, `${themeName}.css`);
+      const root = this.styleProcessor.createRoot();
+      const targetDir = path.dirname(target);
+      for (const specifier of getThemeStyleDependencies(
+        buildConfig,
+        themeName,
+      )) {
+        this.styleProcessor.appendImportRule(root, specifier);
+      }
+      this.styleProcessor.appendImportRule(
+        root,
+        this.toRelativeImportSpecifier(targetDir, file),
+      );
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(target, this.styleProcessor.stringify(root));
+      outputs.push(target);
+    }
+    return outputs;
+  }
+  cleanThemeStyles(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,
+    });
+  }
+  writeModuleStyle(styleFiles, outRoot) {
+    var _a;
+    const target = path.join(
+      outRoot,
+      this.config.output.styleDir,
+      this.config.output.moduleCssFile,
+    );
+    const seen = new Set();
+    const root = this.styleProcessor.createRoot();
+    for (const styleFile of styleFiles) {
+      const content = this.styleProcessor.readStyleFile(styleFile, seen);
+      if (content.trim()) {
+        this.styleProcessor.appendStyleContent(root, content, styleFile);
+      }
+    }
+    if (!((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length))
+      return null;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, this.styleProcessor.stringify(root));
+    return target;
+  }
+  writeExternalStyle(outRoot, buildConfig) {
+    var _a;
+    const target = path.join(
+      outRoot,
+      this.config.output.styleDir,
+      this.config.output.externalCssFile,
+    );
+    const root = this.styleProcessor.createRoot();
+    for (const specifier of getExternalStyleDependencies(buildConfig)) {
+      this.styleProcessor.appendImportRule(
+        root,
+        this.resolver.toExternalStyleSpecifier(specifier, outRoot),
+      );
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(
+      target,
+      ((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length)
+        ? this.styleProcessor.stringify(root)
+        : '',
+    );
+    return target;
+  }
+  writeComponentStyleEntries(
+    sourceFiles,
+    styleFiles,
+    outRoot,
+    moduleStyleImports,
+  ) {
+    var _a, _b, _c;
+    const styleFilesByDir = groupStyleFilesByDir(this.srcRoot, styleFiles);
+    const importedStyleFiles =
+      this.styleProcessor.collectImportedStyleFiles(styleFiles);
+    const sourceModuleDirs = this.getSourceModuleDirs(sourceFiles);
+    const ownStyleDirs = this.getOwnStyleDirs(
+      styleFilesByDir,
+      importedStyleFiles,
+    );
+    const sourceDirs = Array.from(
+      new Set([
+        ...sourceModuleDirs,
+        ...ownStyleDirs,
+        ...moduleStyleImports.keys(),
+      ]),
+    );
+    const outputs = [];
+    for (const sourceDir of sourceDirs) {
+      if (sourceDir === '.') continue;
+      const dirStyleFiles =
+        (_a = styleFilesByDir.get(sourceDir)) !== null && _a !== void 0
+          ? _a
+          : [];
+      const styleDir = path.join(
+        outRoot,
+        sourceDir,
+        this.config.output.styleDir,
+      );
+      const target = path.join(styleDir, this.config.output.indexCssFile);
+      const moduleStyleSpecifiers = this.getModuleStyleSpecifiers(
+        (_b = moduleStyleImports.get(sourceDir)) !== null && _b !== void 0
+          ? _b
+          : [],
+        styleDir,
+      );
+      const dirStyleSpecifiers = this.getDirStyleSpecifiers(
+        dirStyleFiles,
+        importedStyleFiles,
+        styleDir,
+        outRoot,
+      );
+      const sourceStyleSpecifiers = [
+        ...moduleStyleSpecifiers,
+        ...dirStyleSpecifiers,
+      ];
+      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,
+        ((_c = root.nodes) === null || _c === void 0 ? void 0 : _c.length)
+          ? this.styleProcessor.stringify(root)
+          : EMPTY_MODULE_STYLE_ENTRY_COMMENT,
+      );
+      outputs.push(target);
+    }
+    return outputs;
+  }
+  getSourceModuleDirs(sourceFiles) {
+    return sourceFiles
+      .filter((sourceFile) => sourceFile.endsWith('.tsx'))
+      .map((sourceFile) => {
+        return getSourceModuleDir(path.relative(this.srcRoot, sourceFile));
+      })
+      .filter((sourceModuleDir) => {
+        return toPosixPath(sourceModuleDir).split('/').length === 2;
+      });
+  }
+  getOwnStyleDirs(styleFilesByDir, importedStyleFiles) {
+    return Array.from(styleFilesByDir.entries())
+      .filter(([, dirStyleFiles]) =>
+        dirStyleFiles.some(
+          (styleFile) => !importedStyleFiles.has(path.resolve(styleFile)),
+        ),
+      )
+      .map(([sourceDir]) => sourceDir);
+  }
+  getModuleStyleSpecifiers(specifiers, styleDir) {
+    return specifiers.map((specifier) => {
+      if (specifier.startsWith('.')) return specifier;
+      if (!path.isAbsolute(specifier)) return specifier;
+      return toPosixPath(path.relative(styleDir, specifier));
+    });
+  }
+  getDirStyleSpecifiers(dirStyleFiles, importedStyleFiles, styleDir, outRoot) {
+    return dirStyleFiles
+      .filter((styleFile) => !importedStyleFiles.has(path.resolve(styleFile)))
+      .map((styleFile) =>
+        toPosixPath(
+          path.relative(
+            styleDir,
+            path.join(outRoot, path.relative(this.srcRoot, styleFile)),
+          ),
+        ),
+      );
+  }
+  toRelativeImportSpecifier(fromDir, file) {
+    const relative = toPosixPath(path.relative(fromDir, file));
+    return relative.startsWith('.') ? relative : `./${relative}`;
+  }
+}

package/dist/css/vite/hmr.d.ts

@@ -0,0 +1,15 @@
+import type { HotUpdateOptions, ViteDevServer } from 'vite';
+import type { ModuleCssGraph } from '#auklet/css/core/moduleCssGraph';
+export declare class AukletCssHmr {
+  private readonly graph;
+  private readonly lastUpdateTimes;
+  private suppressFullReloadUntil;
+  private readonly virtualIdsByDependency;
+  constructor(graph: () => ModuleCssGraph);
+  trackVirtualCssDependency(file: string, virtualId: string): void;
+  installFullReloadGuard(server: Pick<ViteDevServer, 'ws'>): void;
+  handleStyleHotUpdate(context: HotUpdateOptions): never[] | undefined;
+  private suppressFullReload;
+  private shouldSuppressFullReload;
+  private isDuplicateUpdate;
+}