auklet 0.0.1 → 0.0.3

package/dist/configLoader.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import ts from 'typescript';
+import { aukletConfigFile } from '#auklet/config';
+const importAukletConfigModule = async (configPath, href) => {
+  try {
+    return await import(href);
+  } catch (error) {
+    if (!isUnknownTsExtensionError(error) || !configPath.endsWith('.ts')) {
+      throw error;
+    }
+    return importTsOptionsModule(href);
+  }
+};
+const importTsOptionsModule = async (href) => {
+  const configPath = fileURLToPath(href);
+  const source = fs.readFileSync(configPath, 'utf8');
+  const output = ts.transpileModule(source, {
+    compilerOptions: {
+      esModuleInterop: true,
+      module: ts.ModuleKind.ESNext,
+      target: ts.ScriptTarget.ES2020,
+    },
+    fileName: configPath,
+  });
+  const tempFile = path.join(
+    path.dirname(configPath),
+    `.auklet.config.${process.pid}.${Date.now()}.mjs`,
+  );
+  fs.writeFileSync(tempFile, output.outputText);
+  try {
+    return await import(pathToFileURL(tempFile).href);
+  } finally {
+    fs.rmSync(tempFile, { force: true });
+  }
+};
+const isUnknownTsExtensionError = (error) => {
+  return (
+    error instanceof TypeError &&
+    'code' in error &&
+    error.code === 'ERR_UNKNOWN_FILE_EXTENSION'
+  );
+};
+const asRecord = (value) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+};
+export function resolveAukletConfigModule(module) {
+  const candidates = [
+    module,
+    asRecord(module.default),
+    asRecord(module['module.exports']),
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const config = asRecord(candidate.config);
+    if (config) {
+      return config;
+    }
+  }
+  return {};
+}
+export async function loadAukletConfig(packageRoot, options = {}) {
+  var _a;
+  const configPath = path.join(
+    packageRoot,
+    (_a = options.configFile) !== null && _a !== void 0 ? _a : aukletConfigFile,
+  );
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  const url = pathToFileURL(configPath);
+  if (options.cacheBust) {
+    url.searchParams.set('t', Date.now().toString());
+  }
+  if (configPath.endsWith('.ts')) {
+    const module = await importTsOptionsModule(url.href);
+    return resolveAukletConfigModule(module);
+  }
+  const module = await importAukletConfigModule(configPath, url.href);
+  return resolveAukletConfigModule(module);
+}

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

@@ -0,0 +1,2 @@
+import type { ModuleCssBuildConfig } from '#auklet/types';
+export declare const moduleCssBuildConfig: ModuleCssBuildConfig;

package/dist/css/core/config.js

@@ -0,0 +1,11 @@
+const CSS_EXTENSION = '.css';
+export const moduleCssBuildConfig = {
+  output: {
+    styleDir: 'style',
+    indexCssFile: 'index.css',
+    moduleCssFile: 'module.css',
+    externalCssFile: 'external.css',
+    outputFormats: ['es', 'lib'],
+  },
+  styleExtensions: [CSS_EXTENSION],
+};

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

@@ -0,0 +1,3 @@
+export declare const IMPORT_AT_RULE = 'import';
+export declare const LINE_SEPARATOR = '\n';
+export declare const RELATIVE_IMPORT_PREFIX = '.';

package/dist/css/core/constants.js

@@ -0,0 +1,3 @@
+export const IMPORT_AT_RULE = 'import';
+export const LINE_SEPARATOR = '\n';
+export const RELATIVE_IMPORT_PREFIX = '.';

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

@@ -0,0 +1,51 @@
+import type { AukletConfig, ModuleCssBuildConfig } from '#auklet/types';
+export interface ModuleCssGraphOptions {
+  workspaceRoot: string;
+  packagesDir?: string;
+  config?: ModuleCssBuildConfig;
+  loadAukletConfig?: (
+    packageRoot: string,
+    options?: {
+      cacheBust?: boolean;
+    },
+  ) => Promise<AukletConfig>;
+}
+export type PackageCssId = {
+  packageName: string;
+  cssPath: string;
+};
+export type PackageCssLoadResult = {
+  code: string;
+  watchFiles: Array<string>;
+};
+export declare class ModuleCssGraph {
+  private readonly config;
+  private readonly workspaceRoot;
+  private readonly packagesDir;
+  private readonly loadAukletConfig;
+  constructor(options: ModuleCssGraphOptions);
+  parsePackageCssId(id: string): PackageCssId | null;
+  isWorkspaceSourceGraphFile(file: string): boolean;
+  isCssConfigFile(file: string): boolean;
+  isStyleFile(file: string): boolean;
+  getWorkspacePackageNames(): string[];
+  getWatchRoots(): string[];
+  createPackageCssCode(parsed: PackageCssId): Promise<PackageCssLoadResult>;
+  private createContext;
+  private createStyleCssCode;
+  private createStyleDependencyCssCode;
+  private createExternalCssCode;
+  private createThemeCssCode;
+  private getThemeStyleFiles;
+  private createModuleCssCode;
+  private createSourceModuleCssCode;
+  private getStyleFiles;
+  private toDevModuleImportSpecifier;
+  private toDevExternalStyleSpecifier;
+  private isWorkspacePackageName;
+  private getWorkspacePackages;
+}
+export declare function parsePackageCssId(
+  id: string,
+  packageNames: Array<string>,
+): PackageCssId | null;

package/dist/css/core/moduleCssGraph.js

@@ -0,0 +1,416 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { aukletConfigFile, aukletDefaultCssOptions } from '#auklet/config';
+import { loadAukletConfig } from '#auklet/configLoader';
+import { moduleCssBuildConfig } from '#auklet/css/core/config';
+import { ModuleStyleImportCollector } from '#auklet/css/core/moduleStyleImportCollector';
+import {
+  normalizeCssFileKey,
+  toCssFsSpecifier,
+  toCssWatchPath,
+} from '#auklet/css/core/path';
+import {
+  createImportCode,
+  EXTERNAL_ENTRY,
+  createStyleFileKey,
+  createStyleFileKeySet,
+  getExternalStyleDependencies,
+  getGlobalStyleDependencies,
+  getThemeStyleDependencies,
+  groupStyleFilesByDir,
+  MODULE_ENTRY,
+  parsePackageStyleSpecifier,
+  removeCssExtension,
+  resolveThemeStyleFiles,
+  STYLE_ENTRY,
+  THEMES_ENTRY_PREFIX,
+} from '#auklet/css/core/styleEntry';
+import { StyleProcessor } from '#auklet/css/core/styleProcessor';
+import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+import { fileWalker, toPosixPath } from '#auklet/utils';
+const mergeLoadResults = (...results) => {
+  return {
+    code: results
+      .map((result) => result.code)
+      .filter((code) => code.trim())
+      .join('\n'),
+    watchFiles: Array.from(
+      new Set(results.flatMap((result) => result.watchFiles)),
+    ),
+  };
+};
+export class ModuleCssGraph {
+  constructor(options) {
+    var _a, _b, _c;
+    this.config =
+      (_a = options.config) !== null && _a !== void 0
+        ? _a
+        : moduleCssBuildConfig;
+    this.workspaceRoot = normalizeCssFileKey(options.workspaceRoot);
+    this.packagesDir =
+      (_b = options.packagesDir) !== null && _b !== void 0 ? _b : 'packages';
+    this.loadAukletConfig =
+      (_c = options.loadAukletConfig) !== null && _c !== void 0
+        ? _c
+        : loadAukletConfig;
+  }
+  parsePackageCssId(id) {
+    return parsePackageCssId(id, this.getWorkspacePackageNames());
+  }
+  isWorkspaceSourceGraphFile(file) {
+    const normalizedFile = normalizeCssFileKey(file);
+    const packagesRoot = normalizeCssFileKey(
+      path.join(this.workspaceRoot, this.packagesDir),
+    );
+    if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
+      return false;
+    }
+    if (normalizedFile.endsWith(aukletConfigFile)) return true;
+    if (normalizedFile.endsWith('.ts') || normalizedFile.endsWith('.tsx')) {
+      return true;
+    }
+    return this.config.styleExtensions.some((extension) =>
+      normalizedFile.endsWith(extension),
+    );
+  }
+  isCssConfigFile(file) {
+    return normalizeCssFileKey(file).endsWith(aukletConfigFile);
+  }
+  isStyleFile(file) {
+    return this.config.styleExtensions.includes(path.extname(file));
+  }
+  getWorkspacePackageNames() {
+    return this.getWorkspacePackages().map((item) => item.packageName);
+  }
+  getWatchRoots() {
+    const packagesRoot = path.join(this.workspaceRoot, this.packagesDir);
+    return [
+      toCssWatchPath(packagesRoot, '*', 'src'),
+      toCssWatchPath(packagesRoot, '*', aukletConfigFile),
+    ];
+  }
+  async createPackageCssCode(parsed) {
+    const context = await this.createContext(parsed);
+    if (!context) {
+      return {
+        code: '',
+        watchFiles: [],
+      };
+    }
+    if (parsed.cssPath === STYLE_ENTRY) {
+      return this.createStyleCssCode(context);
+    }
+    if (parsed.cssPath === EXTERNAL_ENTRY) {
+      return this.createExternalCssCode(context);
+    }
+    if (parsed.cssPath === MODULE_ENTRY) {
+      return this.createModuleCssCode(context);
+    }
+    if (parsed.cssPath.startsWith(THEMES_ENTRY_PREFIX)) {
+      return this.createThemeCssCode(context, parsed.cssPath);
+    }
+    return this.createSourceModuleCssCode(context, parsed.cssPath);
+  }
+  async createContext(parsed) {
+    var _a, _b;
+    const workspacePackage = this.getWorkspacePackages().find(
+      (item) => item.packageName === parsed.packageName,
+    );
+    if (!workspacePackage) return null;
+    const packageRoot = workspacePackage.packageRoot;
+    if (!fs.existsSync(packageRoot)) return null;
+    const cssOptions = await this.loadAukletConfig(packageRoot, {
+      cacheBust: true,
+    });
+    const context = {
+      packageRoot,
+      sourceDir:
+        (_a = cssOptions.sourceDir) !== null && _a !== void 0
+          ? _a
+          : aukletDefaultCssOptions.sourceDir,
+      outputDir:
+        (_b = cssOptions.outputDir) !== null && _b !== void 0
+          ? _b
+          : aukletDefaultCssOptions.outputDir,
+    };
+    const sourceRoot = path.join(packageRoot, context.sourceDir);
+    const resolver = new WorkspaceStyleResolver(this.config, context);
+    const styleProcessor = new StyleProcessor(this.config, resolver);
+    return {
+      cssOptions,
+      context,
+      packageName: parsed.packageName,
+      configPath: path.join(packageRoot, aukletConfigFile),
+      resolver,
+      sourceRoot,
+      styleProcessor,
+    };
+  }
+  async createStyleCssCode(context) {
+    const dependencies = await this.createStyleDependencyCssCode(context);
+    const themes = await this.createThemeCssCode(context, undefined, false);
+    const module = this.createModuleCssCode(context);
+    return mergeLoadResults(dependencies, themes, module);
+  }
+  async createStyleDependencyCssCode(context) {
+    const results = [];
+    const imports = [];
+    for (const specifier of getGlobalStyleDependencies(context.cssOptions)) {
+      const parsed = this.parsePackageCssId(specifier);
+      if (parsed) {
+        results.push(await this.createPackageCssCode(parsed));
+        continue;
+      }
+      imports.push(specifier);
+    }
+    return mergeLoadResults(
+      {
+        code: createImportCode(imports),
+        watchFiles: [context.configPath],
+      },
+      ...results,
+    );
+  }
+  async createExternalCssCode(context) {
+    const results = [];
+    const imports = [];
+    for (const specifier of getExternalStyleDependencies(context.cssOptions)) {
+      const external = this.toDevExternalStyleSpecifier(specifier);
+      const parsed = this.parsePackageCssId(external);
+      if (parsed) {
+        results.push(await this.createPackageCssCode(parsed));
+        continue;
+      }
+      imports.push(external);
+    }
+    return mergeLoadResults(
+      {
+        code: createImportCode(imports),
+        watchFiles: [context.configPath],
+      },
+      ...results,
+    );
+  }
+  async createThemeCssCode(context, cssPath, includeDependencies = true) {
+    var _a;
+    const themeFiles = this.getThemeStyleFiles(context);
+    const targetThemeName = cssPath
+      ? removeCssExtension(cssPath.slice(THEMES_ENTRY_PREFIX.length))
+      : null;
+    const root = context.styleProcessor.createRoot();
+    const watchFiles = [context.configPath, ...themeFiles.values()];
+    const dependencyResults = [];
+    const imports = [];
+    for (const [themeName, themeFile] of themeFiles) {
+      if (targetThemeName && themeName !== targetThemeName) continue;
+      if (includeDependencies) {
+        for (const specifier of getThemeStyleDependencies(
+          context.cssOptions,
+          themeName,
+        )) {
+          const parsed = this.parsePackageCssId(specifier);
+          if (!parsed) {
+            imports.push(specifier);
+            continue;
+          }
+          dependencyResults.push(await this.createPackageCssCode(parsed));
+        }
+      }
+      const content = context.styleProcessor.readStyleFile(themeFile);
+      if (content.trim()) {
+        context.styleProcessor.appendStyleContent(root, content, themeFile);
+      }
+    }
+    return mergeLoadResults(
+      {
+        code: createImportCode(imports),
+        watchFiles,
+      },
+      ...dependencyResults,
+      {
+        code: ((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length)
+          ? context.styleProcessor.stringify(root)
+          : '',
+        watchFiles: [],
+      },
+    );
+  }
+  getThemeStyleFiles(context) {
+    return resolveThemeStyleFiles(
+      context.cssOptions,
+      context.context.packageRoot,
+    );
+  }
+  createModuleCssCode(context) {
+    var _a;
+    const themeFiles = this.getThemeStyleFiles(context);
+    const themeFileKeys = createStyleFileKeySet(themeFiles.values());
+    const styleFiles = this.getStyleFiles(context.sourceRoot).filter(
+      (styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)),
+    );
+    const root = context.styleProcessor.createRoot();
+    const seen = new Set();
+    for (const styleFile of styleFiles) {
+      const content = context.styleProcessor.readStyleFile(styleFile, seen);
+      if (content.trim()) {
+        context.styleProcessor.appendStyleContent(root, content, styleFile);
+      }
+    }
+    return {
+      code: ((_a = root.nodes) === null || _a === void 0 ? void 0 : _a.length)
+        ? context.styleProcessor.stringify(root)
+        : '',
+      watchFiles: [context.configPath, ...styleFiles],
+    };
+  }
+  async createSourceModuleCssCode(context, cssPath) {
+    var _a, _b, _c;
+    const sourceModuleDir = removeCssExtension(cssPath);
+    const themeFiles = this.getThemeStyleFiles(context);
+    const themeFileKeys = createStyleFileKeySet(themeFiles.values());
+    const styleFiles = this.getStyleFiles(context.sourceRoot).filter(
+      (styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)),
+    );
+    const styleFilesByDir = groupStyleFilesByDir(
+      context.sourceRoot,
+      styleFiles,
+    );
+    const importedStyleFiles =
+      context.styleProcessor.collectImportedStyleFiles(styleFiles);
+    const importCollector = new ModuleStyleImportCollector(
+      context.sourceRoot,
+      context.context.packageRoot,
+      context.resolver,
+      this.config.styleExtensions,
+    );
+    const sourceFiles = fileWalker(context.sourceRoot);
+    const moduleStyleImports = importCollector.collect(
+      sourceFiles,
+      context.cssOptions,
+    );
+    const sourceStyleDir = path.join(
+      context.sourceRoot,
+      sourceModuleDir,
+      this.config.output.styleDir,
+    );
+    const moduleStyleResults = [];
+    const moduleStyleSpecifiers = [];
+    for (const specifier of (_a = moduleStyleImports.get(sourceModuleDir)) !==
+      null && _a !== void 0
+      ? _a
+      : []) {
+      const result = this.toDevModuleImportSpecifier(
+        context,
+        sourceStyleDir,
+        specifier,
+      );
+      const parsed = this.parsePackageCssId(result);
+      if (parsed) {
+        moduleStyleResults.push(await this.createPackageCssCode(parsed));
+        continue;
+      }
+      moduleStyleSpecifiers.push(result);
+    }
+    const ownStyleFiles = (
+      (_b = styleFilesByDir.get(sourceModuleDir)) !== null && _b !== void 0
+        ? _b
+        : []
+    ).filter((styleFile) => !importedStyleFiles.has(path.resolve(styleFile)));
+    const root = context.styleProcessor.createRoot();
+    const seen = new Set();
+    for (const ownStyleFile of ownStyleFiles) {
+      const content = context.styleProcessor.readStyleFile(ownStyleFile, seen);
+      if (content.trim()) {
+        context.styleProcessor.appendStyleContent(root, content, ownStyleFile);
+      }
+    }
+    const ownStyleCode = (
+      (_c = root.nodes) === null || _c === void 0 ? void 0 : _c.length
+    )
+      ? context.styleProcessor.stringify(root)
+      : '';
+    return mergeLoadResults(...moduleStyleResults, {
+      code: [createImportCode(moduleStyleSpecifiers), ownStyleCode]
+        .filter((code) => code.trim())
+        .join('\n'),
+      watchFiles: [
+        context.configPath,
+        ...styleFiles,
+        ...sourceFiles.filter((file) => /\.(ts|tsx)$/.test(file)),
+      ],
+    });
+  }
+  getStyleFiles(sourceRoot) {
+    if (!fs.existsSync(sourceRoot)) return [];
+    return fileWalker(sourceRoot).filter((file) =>
+      this.config.styleExtensions.includes(path.extname(file)),
+    );
+  }
+  toDevModuleImportSpecifier(context, sourceStyleDir, specifier) {
+    if (!specifier.startsWith('.')) {
+      return this.toDevExternalStyleSpecifier(specifier);
+    }
+    const outputStyleEntry = path.resolve(sourceStyleDir, specifier);
+    const styleEntrySuffix = `${path.sep}${this.config.output.styleDir}${path.sep}${this.config.output.indexCssFile}`;
+    if (!outputStyleEntry.endsWith(styleEntrySuffix)) {
+      return toCssFsSpecifier(outputStyleEntry);
+    }
+    const sourceModuleDir = path.relative(
+      context.sourceRoot,
+      outputStyleEntry.slice(0, -styleEntrySuffix.length),
+    );
+    return `${context.packageName}/${toPosixPath(sourceModuleDir)}.css`;
+  }
+  toDevExternalStyleSpecifier(specifier) {
+    const parsed = parsePackageStyleSpecifier(specifier);
+    if (!parsed) return specifier;
+    if (this.isWorkspacePackageName(parsed.packageName)) {
+      if (parsed.stylePath === STYLE_ENTRY) {
+        return `${parsed.packageName}/${EXTERNAL_ENTRY}`;
+      }
+      if (
+        parsed.stylePath ===
+        [this.config.output.styleDir, this.config.output.indexCssFile].join('/')
+      ) {
+        return `${parsed.packageName}/${EXTERNAL_ENTRY}`;
+      }
+    }
+    return specifier;
+  }
+  isWorkspacePackageName(packageName) {
+    return this.getWorkspacePackageNames().includes(packageName);
+  }
+  getWorkspacePackages() {
+    const packagesRoot = path.join(this.workspaceRoot, this.packagesDir);
+    if (!fs.existsSync(packagesRoot)) return [];
+    return fs
+      .readdirSync(packagesRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .flatMap((entry) => {
+        const packageRoot = path.join(packagesRoot, entry.name);
+        const packageJsonPath = path.join(packageRoot, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) return [];
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (!pkg.name) return [];
+        return [
+          {
+            packageName: pkg.name,
+            packageRoot,
+          },
+        ];
+      });
+  }
+}
+export function parsePackageCssId(id, packageNames) {
+  if (!id.endsWith('.css')) {
+    return null;
+  }
+  const packageName = [...packageNames]
+    .sort((left, right) => right.length - left.length)
+    .find((name) => id.startsWith(`${name}/`));
+  if (!packageName) return null;
+  return {
+    packageName,
+    cssPath: id.slice(packageName.length + 1),
+  };
+}

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

@@ -0,0 +1,29 @@
+import type { CssOptions } from '#auklet/types';
+import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+export declare class ModuleStyleImportCollector {
+  private readonly srcRoot;
+  private readonly packageRoot;
+  private readonly resolver;
+  private readonly styleExtensions;
+  private readonly sourceImportAliasRules;
+  constructor(
+    srcRoot: string,
+    packageRoot: string,
+    resolver: WorkspaceStyleResolver,
+    styleExtensions?: Array<string>,
+  );
+  collect(files: Array<string>, cssOptions: CssOptions): Map<string, string[]>;
+  private getImportDeclarations;
+  private collectSourceImportStyle;
+  private resolveSourceImportStyleEntry;
+  private resolveSourceImportPath;
+  private createSourceImportAliasRules;
+  private toRelativeSpecifier;
+  private createAutoImportRules;
+  private matchAutoImportRules;
+  private getImportPathValues;
+  private createStyleSpecifier;
+  private createDirectStyleSpecifier;
+  private joinDependencySpecifier;
+  private getImportedNames;
+}