auklet 0.0.16 → 0.0.18

package/dist/css/core/style/dependencies.js

@@ -2,54 +2,51 @@ import path from 'node:path';
 import { isArray } from 'aidly';
 import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
 export function getGlobalStyleDependencies(config) {
-  const dependencies = [];
-  for (const [packageName, dependency] of Object.entries(
-    config.styles.dependencies,
-  )) {
-    const globalDependencies = isArray(dependency.entry)
-      ? dependency.entry
-      : dependency.entry
-      ? [dependency.entry]
-      : [];
-    for (const globalDependency of globalDependencies) {
-      dependencies.push(joinDependencySpecifier(packageName, globalDependency));
+    const dependencies = [];
+    for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {
+        const globalDependencies = isArray(dependency.entry)
+            ? dependency.entry
+            : dependency.entry
+                ? [dependency.entry]
+                : [];
+        for (const globalDependency of globalDependencies) {
+            dependencies.push(joinDependencySpecifier(packageName, globalDependency));
+        }
     }
-  }
-  return dependencies;
+    return dependencies;
 }
 export function getExternalStyleDependencies(config) {
-  return getGlobalStyleDependencies(config);
+    return getGlobalStyleDependencies(config);
 }
 export function getThemeStyleDependencies(config, themeName) {
-  const dependencies = [];
-  for (const [packageName, dependency] of Object.entries(
-    config.styles.dependencies,
-  )) {
-    const themeDependency = dependency.themes?.[themeName];
-    if (!themeDependency) continue;
-    dependencies.push(joinDependencySpecifier(packageName, themeDependency));
-  }
-  return dependencies;
+    const dependencies = [];
+    for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {
+        const themeDependency = dependency.themes?.[themeName];
+        if (!themeDependency)
+            continue;
+        dependencies.push(joinDependencySpecifier(packageName, themeDependency));
+    }
+    return dependencies;
 }
 export function getThemeNames(config) {
-  const names = new Set(Object.keys(config.styles.themes));
-  for (const dependency of Object.values(config.styles.dependencies)) {
-    for (const themeName of Object.keys(dependency.themes ?? {})) {
-      names.add(themeName);
+    const names = new Set(Object.keys(config.styles.themes));
+    for (const dependency of Object.values(config.styles.dependencies)) {
+        for (const themeName of Object.keys(dependency.themes ?? {})) {
+            names.add(themeName);
+        }
     }
-  }
-  return [...names];
+    return [...names];
 }
 export function getThemeStyleEntries(config) {
-  return Object.entries(config.styles.themes).map(([themeName, file]) => ({
-    themeName,
-    file,
-  }));
+    return Object.entries(config.styles.themes).map(([themeName, file]) => ({
+        themeName,
+        file,
+    }));
 }
 export function resolveThemeStyleFiles(config, packageRoot) {
-  const themeFiles = new Map();
-  for (const { themeName, file } of getThemeStyleEntries(config)) {
-    themeFiles.set(themeName, path.resolve(packageRoot, file));
-  }
-  return themeFiles;
+    const themeFiles = new Map();
+    for (const { themeName, file } of getThemeStyleEntries(config)) {
+        themeFiles.set(themeName, path.resolve(packageRoot, file));
+    }
+    return themeFiles;
 }

package/dist/css/core/style/entries.d.ts

@@ -1,75 +1,52 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 import type { NormalizedAukletConfig } from '#auklet/types';
 type StyleModulePart = {
-  type: 'module';
+    type: 'module';
 };
 type StyleThemesPart = {
-  type: 'themes';
-  themeNames: Array<string>;
+    type: 'themes';
+    themeNames: Array<string>;
 };
 type DependenciesPart = {
-  type: 'dependencies';
-  specifiers: Array<string>;
+    type: 'dependencies';
+    specifiers: Array<string>;
 };
 type ThemePart = {
-  type: 'theme';
-  themeName: string;
+    type: 'theme';
+    themeName: string;
 };
 export type ExternalEntryPart = DependenciesPart;
 export type ThemeEntryPart = DependenciesPart | ThemePart;
-export type StyleEntryPart =
-  | DependenciesPart
-  | StyleThemesPart
-  | StyleModulePart;
-export declare function createStyleEntryParts(config: NormalizedAukletConfig): (
-  | {
-      type: 'dependencies';
-      specifiers: string[];
-    }
-  | {
-      type: 'themes';
-      themeNames: string[];
-    }
-  | {
-      type: 'module';
-      themeNames?: undefined;
-    }
-)[];
-export declare function createThemeEntryParts(
-  config: NormalizedAukletConfig,
-  themeName: string,
-  options?: {
+export type StyleEntryPart = DependenciesPart | StyleThemesPart | StyleModulePart;
+export declare function createStyleEntryParts(config: NormalizedAukletConfig): ({
+    type: "dependencies";
+    specifiers: string[];
+} | {
+    type: "themes";
+    themeNames: string[];
+} | {
+    type: "module";
+    themeNames?: undefined;
+})[];
+export declare function createThemeEntryParts(config: NormalizedAukletConfig, themeName: string, options?: {
     includeDependencies?: boolean;
-  },
-): (
-  | ThemePart
-  | {
-      type: 'dependencies';
-      specifiers: string[];
-    }
-)[];
-export declare function createExternalEntryParts(
-  config: NormalizedAukletConfig,
-): {
-  type: 'dependencies';
-  specifiers: string[];
+}): (ThemePart | {
+    type: "dependencies";
+    specifiers: string[];
+})[];
+export declare function createExternalEntryParts(config: NormalizedAukletConfig): {
+    type: "dependencies";
+    specifiers: string[];
 }[];
-export declare function collectModuleStyleImports(
-  packageContext: StylePackageContext,
-): Map<string, string[]>;
-export declare function createComponentStyleEntryPlan(
-  packageContext: StylePackageContext,
-  sourceDir: string,
-): {
-  sourceDir: string;
-  moduleStyleImports: string[];
-  ownStyleFiles: string[];
+export declare function collectModuleStyleImports(packageContext: StylePackageContext): Map<string, string[]>;
+export declare function createModuleStyleEntryPlan(packageContext: StylePackageContext, sourceDir: string): {
+    sourceDir: string;
+    moduleStyleImports: string[];
+    ownStyleFiles: string[];
 };
-export declare function createComponentStyleEntryPlans(
-  packageContext: StylePackageContext,
-): {
-  sourceDir: string;
-  moduleStyleImports: string[];
-  ownStyleFiles: string[];
+export declare function createModuleStyleEntryPlans(packageContext: StylePackageContext): {
+    sourceDir: string;
+    moduleStyleImports: string[];
+    ownStyleFiles: string[];
 }[];
 export {};

package/dist/css/core/style/entries.js

@@ -1,46 +1,35 @@
-import {
-  getExternalStyleDependencies,
-  getGlobalStyleDependencies,
-  getThemeNames,
-  getThemeStyleDependencies,
-} from '#auklet/css/core/style/dependencies';
+import { getExternalStyleDependencies, getGlobalStyleDependencies, getThemeNames, getThemeStyleDependencies, } from '#auklet/css/core/style/dependencies';
 import { StyleModuleEntryPlanner } from '#auklet/css/core/styleModuleEntryPlanner';
 const dependenciesPart = (specifiers) => ({ type: 'dependencies', specifiers });
 // 环境无关的 style entry graph。production writer 和 Vite/dev renderer 都从这里取入口语义。
 export function createStyleEntryParts(config) {
-  return [
-    dependenciesPart(getGlobalStyleDependencies(config)),
-    { type: 'themes', themeNames: getThemeNames(config) },
-    { type: 'module' },
-  ];
+    return [
+        dependenciesPart(getGlobalStyleDependencies(config)),
+        { type: 'themes', themeNames: getThemeNames(config) },
+        { type: 'module' },
+    ];
 }
 export function createThemeEntryParts(config, themeName, options = {}) {
-  const themePart = { type: 'theme', themeName };
-  if (options.includeDependencies === false) {
-    return [themePart];
-  }
-  return [
-    dependenciesPart(getThemeStyleDependencies(config, themeName)),
-    themePart,
-  ];
+    const themePart = { type: 'theme', themeName };
+    if (options.includeDependencies === false) {
+        return [themePart];
+    }
+    return [
+        dependenciesPart(getThemeStyleDependencies(config, themeName)),
+        themePart,
+    ];
 }
 export function createExternalEntryParts(config) {
-  return [dependenciesPart(getExternalStyleDependencies(config))];
+    return [
+        dependenciesPart(getExternalStyleDependencies(config)),
+    ];
 }
 export function collectModuleStyleImports(packageContext) {
-  return packageContext.importCollector.collect(
-    packageContext.sourceFiles,
-    packageContext.normalizedConfig,
-  );
+    return packageContext.importCollector.collect(packageContext.sourceFiles, packageContext.normalizedConfig);
 }
-export function createComponentStyleEntryPlan(packageContext, sourceDir) {
-  return new StyleModuleEntryPlanner(packageContext).createEntry(
-    sourceDir,
-    collectModuleStyleImports(packageContext),
-  );
+export function createModuleStyleEntryPlan(packageContext, sourceDir) {
+    return new StyleModuleEntryPlanner(packageContext).createEntry(sourceDir, collectModuleStyleImports(packageContext));
 }
-export function createComponentStyleEntryPlans(packageContext) {
-  return new StyleModuleEntryPlanner(packageContext).createEntries(
-    collectModuleStyleImports(packageContext),
-  );
+export function createModuleStyleEntryPlans(packageContext) {
+    return new StyleModuleEntryPlanner(packageContext).createEntries(collectModuleStyleImports(packageContext));
 }

package/dist/css/core/style/files.d.ts

@@ -1,8 +1,3 @@
-export declare function groupStyleFilesByDir(
-  sourceRoot: string,
-  styleFiles: Array<string>,
-): Map<string, string[]>;
-export declare function createStyleFileKeySet(
-  styleFiles: Iterable<string>,
-): Set<string>;
+export declare function groupStyleFilesByDir(sourceRoot: string, styleFiles: Array<string>): Map<string, string[]>;
+export declare function createStyleFileKeySet(styleFiles: Iterable<string>): Set<string>;
 export declare function createStyleFileKey(styleFile: string): string;

package/dist/css/core/style/files.js

@@ -1,19 +1,19 @@
 import path from 'node:path';
 import { getSourceModuleDir, normalizeFileKey } from '#auklet/utils';
 export function groupStyleFilesByDir(sourceRoot, styleFiles) {
-  const styleFilesByDir = new Map();
-  for (const styleFile of styleFiles) {
-    const sourceRelative = path.relative(sourceRoot, styleFile);
-    const sourceDir = getSourceModuleDir(sourceRelative);
-    const values = styleFilesByDir.get(sourceDir) ?? [];
-    values.push(styleFile);
-    styleFilesByDir.set(sourceDir, values);
-  }
-  return styleFilesByDir;
+    const styleFilesByDir = new Map();
+    for (const styleFile of styleFiles) {
+        const sourceRelative = path.relative(sourceRoot, styleFile);
+        const sourceDir = getSourceModuleDir(sourceRelative);
+        const values = styleFilesByDir.get(sourceDir) ?? [];
+        values.push(styleFile);
+        styleFilesByDir.set(sourceDir, values);
+    }
+    return styleFilesByDir;
 }
 export function createStyleFileKeySet(styleFiles) {
-  return new Set(Array.from(styleFiles, normalizeFileKey));
+    return new Set(Array.from(styleFiles, normalizeFileKey));
 }
 export function createStyleFileKey(styleFile) {
-  return normalizeFileKey(styleFile);
+    return normalizeFileKey(styleFile);
 }

package/dist/css/core/style/specifier.d.ts

@@ -1,14 +1,47 @@
 export type PackageStyleSpecifier = {
-  packageName: string;
-  stylePath: string;
+    packageName: string;
+    stylePath: string;
 };
 export declare function parsePackageStyleSpecifier(specifier: string): {
-  packageName: string;
-  stylePath: string;
+    packageName: string;
+    stylePath: string;
 } | null;
-export declare function joinDependencySpecifier(
-  packageName: string,
-  dependencyPath: string,
-): string;
+export declare function joinDependencySpecifier(packageName: string, dependencyPath: string): string;
 export declare function createImportCode(specifiers: Array<string>): string;
 export declare function removeStyleExtension(stylePath: string): string;
+export declare function toRelativeImportSpecifier(fromDir: string, file: string): string;
+export declare function getStylePathOutputFormat(stylePath: string, outputFormats: Array<string>): {
+    format: string;
+    path: string;
+} | null;
+export declare function createOutputStyleSpecifier(specifier: string, options: {
+    currentOutputFormat: string;
+    outputFormats: Array<string>;
+}): string;
+export declare function createExternalStyleSpecifier(specifier: string, options: {
+    currentOutputFormat: string;
+    outputFormats: Array<string>;
+    styleDir: string;
+    indexStyleFile: string;
+    externalStyleFile: string;
+}): string;
+export declare function createDevExternalStyleSpecifier(specifier: string, options: {
+    isKnownPackageName: (packageName: string) => boolean;
+    styleDir: string;
+    indexStyleFile: string;
+    externalStyleFile?: string;
+}): string;
+export declare function createOutputModuleStyleSpecifier(specifier: string, styleDir: string): string;
+export declare function createOutputOwnStyleSpecifier(options: {
+    sourceRoot: string;
+    outputRoot: string;
+    styleDir: string;
+}, styleFile: string): string;
+export declare function createDevModuleStyleSpecifier(specifier: string, options: {
+    sourceStyleDir: string;
+    sourceRoot: string;
+    packageName: string;
+    styleDir: string;
+    indexStyleFile: string;
+    mapExternalSpecifier: (specifier: string) => string;
+}): string;

package/dist/css/core/style/specifier.js

@@ -1,27 +1,116 @@
 import path from 'node:path';
+import { EXTERNAL_ENTRY, STYLE_ENTRY } from '#auklet/css/constants';
+import { POSIX_SEPARATOR, toFsSpecifier, toPosixPath } from '#auklet/utils';
 export function parsePackageStyleSpecifier(specifier) {
-  if (specifier.startsWith('.')) return null;
-  const parts = specifier.split('/');
-  const packageName = specifier.startsWith('@')
-    ? `${parts.shift() ?? ''}/${parts.shift() ?? ''}`
-    : parts.shift() ?? '';
-  if (!packageName) return null;
-  return {
-    packageName,
-    stylePath: parts.join('/'),
-  };
+    if (specifier.startsWith('.'))
+        return null;
+    const parts = specifier.split('/');
+    const packageName = specifier.startsWith('@')
+        ? `${parts.shift() ?? ''}/${parts.shift() ?? ''}`
+        : (parts.shift() ?? '');
+    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}`;
+    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');
+    return Array.from(new Set(specifiers))
+        .map((specifier) => `@import "${specifier}";`)
+        .join('\n');
 }
 export function removeStyleExtension(stylePath) {
-  return stylePath.slice(0, -path.extname(stylePath).length);
+    return stylePath.slice(0, -path.extname(stylePath).length);
+}
+export function toRelativeImportSpecifier(fromDir, file) {
+    const relative = toPosixPath(path.relative(fromDir, file));
+    return relative.startsWith('.') ? relative : `./${relative}`;
+}
+export function getStylePathOutputFormat(stylePath, outputFormats) {
+    for (const format of outputFormats) {
+        const prefix = `${format}${POSIX_SEPARATOR}`;
+        if (!stylePath.startsWith(prefix))
+            continue;
+        return {
+            format,
+            path: stylePath.slice(prefix.length),
+        };
+    }
+    return null;
+}
+export function createOutputStyleSpecifier(specifier, options) {
+    const parsed = parsePackageStyleSpecifier(specifier);
+    if (!parsed)
+        return specifier;
+    const outputFormat = getStylePathOutputFormat(parsed.stylePath, options.outputFormats);
+    if (!outputFormat)
+        return specifier;
+    return [
+        parsed.packageName,
+        options.currentOutputFormat,
+        outputFormat.path,
+    ].join(POSIX_SEPARATOR);
+}
+export function createExternalStyleSpecifier(specifier, options) {
+    const parsed = parsePackageStyleSpecifier(specifier);
+    if (!parsed)
+        return specifier;
+    if (parsed.stylePath === STYLE_ENTRY) {
+        return [parsed.packageName, options.externalStyleFile].join(POSIX_SEPARATOR);
+    }
+    const outputFormat = getStylePathOutputFormat(parsed.stylePath, options.outputFormats);
+    const indexStylePath = [options.styleDir, options.indexStyleFile].join(POSIX_SEPARATOR);
+    if (!outputFormat || outputFormat.path !== indexStylePath)
+        return specifier;
+    return [
+        parsed.packageName,
+        options.currentOutputFormat,
+        options.styleDir,
+        options.externalStyleFile,
+    ].join(POSIX_SEPARATOR);
+}
+export function createDevExternalStyleSpecifier(specifier, options) {
+    const parsed = parsePackageStyleSpecifier(specifier);
+    if (!parsed)
+        return specifier;
+    if (!options.isKnownPackageName(parsed.packageName))
+        return specifier;
+    const indexStylePath = [options.styleDir, options.indexStyleFile].join(POSIX_SEPARATOR);
+    if (parsed.stylePath === STYLE_ENTRY || parsed.stylePath === indexStylePath) {
+        return [
+            parsed.packageName,
+            options.externalStyleFile ?? EXTERNAL_ENTRY,
+        ].join(POSIX_SEPARATOR);
+    }
+    return specifier;
+}
+export function createOutputModuleStyleSpecifier(specifier, styleDir) {
+    if (specifier.startsWith('.'))
+        return specifier;
+    if (!path.isAbsolute(specifier))
+        return specifier;
+    return toRelativeImportSpecifier(styleDir, specifier);
+}
+export function createOutputOwnStyleSpecifier(options, styleFile) {
+    return toRelativeImportSpecifier(options.styleDir, path.join(options.outputRoot, path.relative(options.sourceRoot, styleFile)));
+}
+export function createDevModuleStyleSpecifier(specifier, options) {
+    if (!specifier.startsWith('.')) {
+        return options.mapExternalSpecifier(specifier);
+    }
+    const outputStyleEntry = path.resolve(options.sourceStyleDir, specifier);
+    const styleEntrySuffix = `${path.sep}${options.styleDir}${path.sep}${options.indexStyleFile}`;
+    if (!outputStyleEntry.endsWith(styleEntrySuffix)) {
+        return toFsSpecifier(outputStyleEntry);
+    }
+    const sourceModuleDir = path.relative(options.sourceRoot, outputStyleEntry.slice(0, -styleEntrySuffix.length));
+    return `${options.packageName}/${toPosixPath(sourceModuleDir)}.css`;
 }

package/dist/css/core/styleImports/autoImportRules.d.ts

@@ -0,0 +1,13 @@
+import type { NormalizedAukletConfig } from '#auklet/types';
+export type StyleAutoImportRule = {
+    packageName: string;
+    outputPattern: string;
+};
+export type StyleAutoImportRuleMatch = {
+    rule: StyleAutoImportRule;
+    values: Array<string>;
+};
+export declare function createStyleAutoImportRules(config: NormalizedAukletConfig): StyleAutoImportRule[];
+export declare function matchStyleAutoImportRules(rules: Array<StyleAutoImportRule>, importPath: string): StyleAutoImportRuleMatch[];
+export declare function createStyleAutoImportSpecifier(rule: StyleAutoImportRule, values: Array<string>, importedName: string): string;
+export declare function createDirectStyleAutoImportSpecifier(rule: StyleAutoImportRule, importPath: string): string | null;

package/dist/css/core/styleImports/autoImportRules.js

@@ -0,0 +1,68 @@
+import { isArray } from 'aidly';
+import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
+import { POSIX_SEPARATOR } from '#auklet/utils';
+const GLOBSTAR_TOKEN = '**';
+export function createStyleAutoImportRules(config) {
+    const rules = [];
+    for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {
+        const dependencyPaths = isArray(dependency.components)
+            ? dependency.components
+            : dependency.components
+                ? [dependency.components]
+                : [];
+        for (const dependencyPath of dependencyPaths) {
+            rules.push({
+                packageName,
+                outputPattern: joinDependencySpecifier(packageName, dependencyPath),
+            });
+        }
+    }
+    return rules;
+}
+export function matchStyleAutoImportRules(rules, importPath) {
+    const matches = [];
+    for (const rule of rules) {
+        if (importPath !== rule.packageName &&
+            !importPath.startsWith(`${rule.packageName}${POSIX_SEPARATOR}`)) {
+            continue;
+        }
+        matches.push({
+            rule,
+            values: getImportPathValues(rule.packageName, importPath),
+        });
+    }
+    return matches;
+}
+export function createStyleAutoImportSpecifier(rule, values, importedName) {
+    const pathValues = [...values];
+    return rule.outputPattern.replace(/\*\*|\*/g, (token) => {
+        const matchedValue = pathValues.shift();
+        if (matchedValue)
+            return matchedValue;
+        if (token === GLOBSTAR_TOKEN)
+            return importedName;
+        return matchedValue ?? importedName;
+    });
+}
+export function createDirectStyleAutoImportSpecifier(rule, importPath) {
+    const wildcardIndex = rule.outputPattern.indexOf('*');
+    if (wildcardIndex < 0) {
+        return null;
+    }
+    const wildcardLength = rule.outputPattern.startsWith(GLOBSTAR_TOKEN, wildcardIndex)
+        ? GLOBSTAR_TOKEN.length
+        : 1;
+    const prefix = rule.outputPattern.slice(0, wildcardIndex);
+    const suffix = rule.outputPattern.slice(wildcardIndex + wildcardLength);
+    if (!importPath.startsWith(prefix)) {
+        return null;
+    }
+    return `${importPath}${suffix}`;
+}
+const getImportPathValues = (packageName, importPath) => {
+    return importPath
+        .slice(packageName.length)
+        .replace(new RegExp(`^${POSIX_SEPARATOR}`), '')
+        .split(POSIX_SEPARATOR)
+        .filter(Boolean);
+};

package/dist/css/core/styleImports/collector.d.ts

@@ -1,29 +1,16 @@
 import type { NormalizedAukletConfig } 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;
-  constructor(
-    srcRoot: string,
-    packageRoot: string,
-    resolver: WorkspaceStyleResolver,
-    styleExtensions?: Array<string>,
-  );
-  collect(
-    files: Array<string>,
-    config: NormalizedAukletConfig,
-  ): Map<string, string[]>;
-  private collectSourceImportStyle;
-  private resolveSourceImportStyleEntry;
-  private isInsideSourceRoot;
-  private resolveSourceImportPaths;
-  private toSourceBase;
-  private toRelativeSpecifier;
-  private createAutoImportRules;
-  private matchAutoImportRules;
-  private getImportPathValues;
-  private createStyleSpecifier;
-  private createDirectStyleSpecifier;
+    private readonly srcRoot;
+    private readonly packageRoot;
+    private readonly resolver;
+    private readonly styleExtensions;
+    constructor(srcRoot: string, packageRoot: string, resolver: WorkspaceStyleResolver, styleExtensions?: Array<string>);
+    collect(files: Array<string>, config: NormalizedAukletConfig): Map<string, string[]>;
+    private collectSourceImportStyle;
+    private resolveSourceImportStyleEntry;
+    private isInsideSourceRoot;
+    private resolveSourceImportPaths;
+    private toSourceBase;
+    private toRelativeSpecifier;
 }