auklet 0.0.2 → 0.0.4

package/dist/css/core/moduleCssGraph.js

@@ -1,412 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { aukletConfigFile } 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 Object.keys(this.config.styleExtensions).some((extension) =>
-      normalizedFile.endsWith(extension),
-    );
-  }
-  isCssConfigFile(file) {
-    return normalizeCssFileKey(file).endsWith(aukletConfigFile);
-  }
-  isStyleFile(file) {
-    return Boolean(this.config.styleExtensions[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 : 'src',
-      outputDir:
-        (_b = cssOptions.outputDir) !== null && _b !== void 0 ? _b : 'dist',
-    };
-    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,
-      Object.keys(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) =>
-      Boolean(this.config.styleExtensions[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/path.d.ts

@@ -1,4 +0,0 @@
-export declare function isWindowsAbsolutePath(file: string): boolean;
-export declare function normalizeCssFileKey(file: string): string;
-export declare function toCssFsSpecifier(file: string): string;
-export declare function toCssWatchPath(...parts: Array<string>): string;

package/dist/css/core/path.js

@@ -1,26 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { toPosixPath } from '#auklet/utils';
-const WINDOWS_ABSOLUTE_PATH_RE = /^[a-zA-Z]:[\\/]/;
-export function isWindowsAbsolutePath(file) {
-  return WINDOWS_ABSOLUTE_PATH_RE.test(file);
-}
-export function normalizeCssFileKey(file) {
-  if (process.platform !== 'win32' && isWindowsAbsolutePath(file)) {
-    return toPosixPath(file);
-  }
-  const resolved = path.resolve(file);
-  const realpath = fs.existsSync(resolved)
-    ? fs.realpathSync.native(resolved)
-    : resolved;
-  return toPosixPath(realpath);
-}
-export function toCssFsSpecifier(file) {
-  return path.posix.join('/@fs', normalizeCssFileKey(file));
-}
-export function toCssWatchPath(...parts) {
-  if (parts[0] && isWindowsAbsolutePath(parts[0])) {
-    return toPosixPath(path.win32.join(...parts));
-  }
-  return toPosixPath(path.join(...parts));
-}

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

@@ -1,45 +0,0 @@
-import type { CssOptions } from '#auklet/types';
-export declare const STYLE_ENTRY = 'style.css';
-export declare const EXTERNAL_ENTRY = 'external.css';
-export declare const MODULE_ENTRY = 'module.css';
-export declare const THEMES_DIR = 'themes';
-export declare const THEMES_ENTRY_PREFIX = 'themes/';
-export type PackageStyleSpecifier = {
-  packageName: string;
-  stylePath: string;
-};
-export declare function groupStyleFilesByDir(
-  sourceRoot: string,
-  styleFiles: Array<string>,
-): Map<string, string[]>;
-export declare function getGlobalStyleDependencies(
-  cssOptions: CssOptions,
-): string[];
-export declare function getExternalStyleDependencies(
-  cssOptions: CssOptions,
-): string[];
-export declare function getThemeStyleDependencies(
-  cssOptions: CssOptions,
-  themeName: string,
-): string[];
-export declare function getThemeStyleEntries(cssOptions: CssOptions): {
-  themeName: string;
-  file: string;
-}[];
-export declare function resolveThemeStyleFiles(
-  cssOptions: CssOptions,
-  packageRoot: string,
-): Map<string, string>;
-export declare function createStyleFileKeySet(
-  styleFiles: Iterable<string>,
-): Set<string>;
-export declare function createStyleFileKey(styleFile: string): string;
-export declare function parsePackageStyleSpecifier(
-  specifier: string,
-): PackageStyleSpecifier | null;
-export declare function joinDependencySpecifier(
-  packageName: string,
-  dependencyPath: string,
-): string;
-export declare function createImportCode(specifiers: Array<string>): string;
-export declare function removeCssExtension(cssPath: string): string;

package/dist/css/core/styleEntry.js

@@ -1,108 +0,0 @@
-import path from 'node:path';
-import { isArray } from 'aidly';
-import { getSourceModuleDir } from '#auklet/utils';
-import { normalizeCssFileKey } from '#auklet/css/core/path';
-export const STYLE_ENTRY = 'style.css';
-export const EXTERNAL_ENTRY = 'external.css';
-export const MODULE_ENTRY = 'module.css';
-export const THEMES_DIR = 'themes';
-export const THEMES_ENTRY_PREFIX = 'themes/';
-export function groupStyleFilesByDir(sourceRoot, styleFiles) {
-  var _a;
-  const styleFilesByDir = new Map();
-  for (const styleFile of styleFiles) {
-    const sourceRelative = path.relative(sourceRoot, styleFile);
-    const sourceDir = getSourceModuleDir(sourceRelative);
-    const values =
-      (_a = styleFilesByDir.get(sourceDir)) !== null && _a !== void 0 ? _a : [];
-    values.push(styleFile);
-    styleFilesByDir.set(sourceDir, values);
-  }
-  return styleFilesByDir;
-}
-export function getGlobalStyleDependencies(cssOptions) {
-  var _a;
-  const dependencies = [];
-  for (const [packageName, dependency] of Object.entries(
-    (_a = cssOptions.cssDependencies) !== null && _a !== void 0 ? _a : {},
-  )) {
-    const globalDependencies = isArray(dependency.global)
-      ? dependency.global
-      : [dependency.global].filter((value) => Boolean(value));
-    for (const globalDependency of globalDependencies) {
-      dependencies.push(joinDependencySpecifier(packageName, globalDependency));
-    }
-  }
-  return dependencies;
-}
-export function getExternalStyleDependencies(cssOptions) {
-  return getGlobalStyleDependencies(cssOptions);
-}
-export function getThemeStyleDependencies(cssOptions, themeName) {
-  var _a, _b;
-  const dependencies = [];
-  for (const [packageName, dependency] of Object.entries(
-    (_a = cssOptions.cssDependencies) !== null && _a !== void 0 ? _a : {},
-  )) {
-    const themeDependency =
-      (_b = dependency.themes) === null || _b === void 0
-        ? void 0
-        : _b[themeName];
-    if (!themeDependency) continue;
-    dependencies.push(joinDependencySpecifier(packageName, themeDependency));
-  }
-  return dependencies;
-}
-export function getThemeStyleEntries(cssOptions) {
-  var _a;
-  return Object.entries(
-    (_a = cssOptions.themes) !== null && _a !== void 0 ? _a : {},
-  ).map(([themeName, file]) => ({
-    themeName,
-    file,
-  }));
-}
-export function resolveThemeStyleFiles(cssOptions, packageRoot) {
-  const themeFiles = new Map();
-  for (const { themeName, file } of getThemeStyleEntries(cssOptions)) {
-    themeFiles.set(themeName, path.resolve(packageRoot, file));
-  }
-  return themeFiles;
-}
-export function createStyleFileKeySet(styleFiles) {
-  return new Set(Array.from(styleFiles, normalizeCssFileKey));
-}
-export function createStyleFileKey(styleFile) {
-  return normalizeCssFileKey(styleFile);
-}
-export function parsePackageStyleSpecifier(specifier) {
-  var _a, _b, _c;
-  if (specifier.startsWith('.')) return null;
-  const parts = specifier.split('/');
-  const packageName = specifier.startsWith('@')
-    ? `${(_a = parts.shift()) !== null && _a !== void 0 ? _a : ''}/${
-        (_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('/'),
-  };
-}
-export function joinDependencySpecifier(packageName, dependencyPath) {
-  if (!dependencyPath) return packageName;
-  return dependencyPath.startsWith('/')
-    ? `${packageName}${dependencyPath}`
-    : `${packageName}/${dependencyPath}`;
-}
-export function createImportCode(specifiers) {
-  return Array.from(new Set(specifiers))
-    .map((specifier) => `@import "${specifier}";`)
-    .join('\n');
-}
-export function removeCssExtension(cssPath) {
-  return cssPath.slice(0, -path.extname(cssPath).length);
-}

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

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