auklet 0.0.17 → 0.0.19

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

@@ -27,9 +27,9 @@ export function createExternalEntryParts(config) {
 export function collectModuleStyleImports(packageContext) {
     return packageContext.importCollector.collect(packageContext.sourceFiles, packageContext.normalizedConfig);
 }
-export function createComponentStyleEntryPlan(packageContext, sourceDir) {
+export function createModuleStyleEntryPlan(packageContext, sourceDir) {
     return new StyleModuleEntryPlanner(packageContext).createEntry(sourceDir, collectModuleStyleImports(packageContext));
 }
-export function createComponentStyleEntryPlans(packageContext) {
+export function createModuleStyleEntryPlans(packageContext) {
     return new StyleModuleEntryPlanner(packageContext).createEntries(collectModuleStyleImports(packageContext));
 }

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

@@ -9,3 +9,39 @@ export declare function parsePackageStyleSpecifier(specifier: 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,4 +1,6 @@
 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;
@@ -28,3 +30,87 @@ export function createImportCode(specifiers) {
 export function removeStyleExtension(stylePath) {
     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

@@ -13,9 +13,4 @@ export declare class ModuleStyleImportCollector {
     private resolveSourceImportPaths;
     private toSourceBase;
     private toRelativeSpecifier;
-    private createAutoImportRules;
-    private matchAutoImportRules;
-    private getImportPathValues;
-    private createStyleSpecifier;
-    private createDirectStyleSpecifier;
 }

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

@@ -1,14 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { isArray } from 'aidly';
-import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
-import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
-import { appendUniqueMapValue, getSourceModuleDir, POSIX_SEPARATOR, } from '#auklet/utils';
-import { collectModuleStyleSourceReferences, getSourceReferenceImportedNames, isTypeOnlySourceReference, } from '#auklet/css/core/styleImports/sourceReference';
+import { SOURCE_MODULE_RE } from '#auklet/css/constants';
+import { appendUniqueMapValue, getSourceModuleDir } from '#auklet/utils';
+import { isTypeOnlyModuleReference, collectModuleImportReferences, getModuleReferenceImportedNames, } from '#auklet/css/core/styleImports/sourceImportExportAnalyzer';
 import { resolveRelativeSourceImport } from '#auklet/css/core/resolvers/relative';
 import { resolvePackageImportsSourceImport } from '#auklet/css/core/resolvers/packageImports';
 import { resolveTsconfigPathsSourceImport } from '#auklet/css/core/resolvers/tsconfigPaths';
-const GLOBSTAR_TOKEN = '**';
+import { matchStyleAutoImportRules, createStyleAutoImportRules, createStyleAutoImportSpecifier, createDirectStyleAutoImportSpecifier, } from '#auklet/css/core/styleImports/autoImportRules';
 const SOURCE_EXTENSION_RE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
 const SOURCE_INDEX_RE = new RegExp(`[/\\\\]index${SOURCE_EXTENSION_RE.source}`);
 export class ModuleStyleImportCollector {
@@ -24,26 +22,26 @@ export class ModuleStyleImportCollector {
     }
     collect(files, config) {
         const entries = new Map();
-        const rules = this.createAutoImportRules(config);
+        const rules = createStyleAutoImportRules(config);
         for (const file of files) {
-            if (!SOURCE_COMPONENT_MODULE_RE.test(file)) {
+            if (!SOURCE_MODULE_RE.test(file)) {
                 continue;
             }
             const sourceRelative = path.relative(this.srcRoot, file);
             const sourceDir = path.dirname(sourceRelative);
             const sourceModuleDir = getSourceModuleDir(sourceRelative);
             const code = fs.readFileSync(file, 'utf8');
-            const imports = collectModuleStyleSourceReferences(file, code);
+            const imports = collectModuleImportReferences(file, code);
             for (const item of imports) {
                 this.collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item);
-                if (isTypeOnlySourceReference(item))
+                if (isTypeOnlyModuleReference(item))
                     continue;
                 const importPath = item.importPath;
-                const ruleMatches = this.matchAutoImportRules(rules, importPath);
+                const ruleMatches = matchStyleAutoImportRules(rules, importPath);
                 if (!ruleMatches.length)
                     continue;
                 const directSpecifiers = ruleMatches.flatMap((ruleMatch) => {
-                    const specifier = this.createDirectStyleSpecifier(ruleMatch.rule, importPath);
+                    const specifier = createDirectStyleAutoImportSpecifier(ruleMatch.rule, importPath);
                     return specifier ? [specifier] : [];
                 });
                 if (directSpecifiers.length) {
@@ -56,9 +54,9 @@ export class ModuleStyleImportCollector {
                     continue;
                 }
                 for (const ruleMatch of ruleMatches) {
-                    const importedNames = getSourceReferenceImportedNames(file, item);
+                    const importedNames = getModuleReferenceImportedNames(file, item);
                     for (const importedName of importedNames) {
-                        const specifier = this.createStyleSpecifier(ruleMatch.rule, ruleMatch.values, importedName);
+                        const specifier = createStyleAutoImportSpecifier(ruleMatch.rule, ruleMatch.values, importedName);
                         const cssFile = this.resolver.resolveStyleDependency(specifier);
                         if (!fs.existsSync(cssFile)) {
                             continue;
@@ -71,7 +69,7 @@ export class ModuleStyleImportCollector {
         return entries;
     }
     collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item) {
-        if (isTypeOnlySourceReference(item))
+        if (isTypeOnlyModuleReference(item))
             return;
         const importedStyleEntry = this.resolveSourceImportStyleEntry(sourceDir, item.importPath);
         if (!importedStyleEntry)
@@ -119,68 +117,4 @@ export class ModuleStyleImportCollector {
         const relative = path.relative(fromDir, file).split(path.sep).join('/');
         return relative.startsWith('.') ? relative : `./${relative}`;
     }
-    createAutoImportRules(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;
-    }
-    matchAutoImportRules(rules, importPath) {
-        const matches = [];
-        for (const rule of rules) {
-            if (importPath !== rule.packageName &&
-                !importPath.startsWith(`${rule.packageName}${POSIX_SEPARATOR}`)) {
-                continue;
-            }
-            matches.push({
-                rule,
-                values: this.getImportPathValues(rule.packageName, importPath),
-            });
-        }
-        return matches;
-    }
-    getImportPathValues(packageName, importPath) {
-        return importPath
-            .slice(packageName.length)
-            .replace(new RegExp(`^${POSIX_SEPARATOR}`), '')
-            .split(POSIX_SEPARATOR)
-            .filter(Boolean);
-    }
-    createStyleSpecifier(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;
-        });
-    }
-    createDirectStyleSpecifier(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}`;
-    }
 }

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

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+export type ModuleImportReference = {
+    importPath: string;
+    importClause?: ts.ImportClause;
+    importedNames?: Array<string>;
+    isTypeOnly?: boolean;
+    hasNamespaceImport?: boolean;
+};
+export declare function collectModuleImportReferences(file: string, code: string): ModuleImportReference[];
+export declare function isTypeOnlyModuleReference(item: ModuleImportReference): boolean | undefined;
+export declare function getModuleReferenceImportedNames(file: string, item: ModuleImportReference): string[];

package/dist/css/core/styleImports/{sourceReference.js → sourceImportExportAnalyzer.js}

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-export function collectModuleStyleSourceReferences(file, code) {
+export function collectModuleImportReferences(file, code) {
     const imports = [];
     const importBindings = new Map();
     const localDeclarations = new Set();
@@ -27,10 +27,10 @@ export function collectModuleStyleSourceReferences(file, code) {
     });
     return imports;
 }
-export function isTypeOnlySourceReference(item) {
+export function isTypeOnlyModuleReference(item) {
     return isTypeOnlyImportClause(item.importClause) || item.isTypeOnly;
 }
-export function getSourceReferenceImportedNames(file, item) {
+export function getModuleReferenceImportedNames(file, item) {
     if (item.importedNames) {
         if (item.isTypeOnly)
             return [];

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

@@ -6,8 +6,8 @@ export type ModuleStyleEntryPlan = {
 };
 export declare class StyleModuleEntryPlanner {
     private readonly packageContext;
-    private readonly styleFilesByDir;
     private readonly importedStyleFiles;
+    private readonly styleFilesByDir;
     constructor(packageContext: StylePackageContext);
     createEntries(moduleStyleImports: Map<string, Array<string>>): {
         sourceDir: string;

package/dist/css/core/styleModuleEntryPlanner.js

@@ -1,11 +1,11 @@
 import path from 'node:path';
-import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
+import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { groupStyleFilesByDir } from '#auklet/css/core/style/files';
 import { getSourceModuleDir, toPosixPath } from '#auklet/utils';
 export class StyleModuleEntryPlanner {
     packageContext;
-    styleFilesByDir;
     importedStyleFiles;
+    styleFilesByDir;
     constructor(packageContext) {
         this.packageContext = packageContext;
         this.styleFilesByDir = groupStyleFilesByDir(this.packageContext.sourceRoot, this.packageContext.styleFiles);
@@ -31,7 +31,7 @@ export class StyleModuleEntryPlanner {
     }
     getSourceModuleDirs() {
         return this.packageContext.sourceFiles
-            .filter((sourceFile) => SOURCE_COMPONENT_MODULE_RE.test(sourceFile))
+            .filter((sourceFile) => SOURCE_MODULE_RE.test(sourceFile))
             .map((sourceFile) => {
             return getSourceModuleDir(path.relative(this.packageContext.sourceRoot, sourceFile));
         })

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

@@ -7,5 +7,4 @@ export declare class WorkspaceStyleResolver {
     resolveStyleDependency(specifier: string, fromDir?: string): string;
     toOutputStyleSpecifier(specifier: string, outRoot: string): string;
     toExternalStyleSpecifier(specifier: string, outRoot: string): string;
-    private getStylePathOutputFormat;
 }

package/dist/css/core/workspaceStyleResolver.js

@@ -1,8 +1,7 @@
 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';
-import { parsePackageStyleSpecifier } from '#auklet/css/core/style/specifier';
+import { NODE_MODULES_DIR } from '#auklet/css/constants';
+import { createExternalStyleSpecifier, createOutputStyleSpecifier, } from '#auklet/css/core/style/specifier';
 export class WorkspaceStyleResolver {
     config;
     context;
@@ -26,49 +25,18 @@ export class WorkspaceStyleResolver {
         }
     }
     toOutputStyleSpecifier(specifier, outRoot) {
-        const parsed = 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;
+        return createOutputStyleSpecifier(specifier, {
+            currentOutputFormat: path.basename(outRoot),
+            outputFormats: this.config.output.outputFormats,
+        });
     }
     toExternalStyleSpecifier(specifier, outRoot) {
-        const parsed = parsePackageStyleSpecifier(specifier);
-        if (!parsed)
-            return specifier;
-        const { packageName, stylePath } = parsed;
-        const currentOutputFormat = path.basename(outRoot);
-        const outputFormat = this.getStylePathOutputFormat(stylePath);
-        if (stylePath === STYLE_ENTRY) {
-            return [packageName, this.config.output.externalStyleFile].join(POSIX_SEPARATOR);
-        }
-        if (outputFormat &&
-            outputFormat.path ===
-                [this.config.output.styleDir, this.config.output.indexStyleFile].join(POSIX_SEPARATOR)) {
-            return [
-                packageName,
-                currentOutputFormat,
-                this.config.output.styleDir,
-                this.config.output.externalStyleFile,
-            ].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;
+        return createExternalStyleSpecifier(specifier, {
+            currentOutputFormat: path.basename(outRoot),
+            outputFormats: this.config.output.outputFormats,
+            styleDir: this.config.output.styleDir,
+            indexStyleFile: this.config.output.indexStyleFile,
+            externalStyleFile: this.config.output.externalStyleFile,
+        });
     }
 }

package/dist/css/production/format/{componentWriter.d.ts → moduleEntryWriter.d.ts}

@@ -1,6 +1,6 @@
 import type { ModuleStyleEntryPlan } from '#auklet/css/core/styleModuleEntryPlanner';
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
-export declare class ComponentStyleEntryWriter {
+export declare class ModuleStyleEntryWriter {
     private readonly config;
     private readonly sourceRoot;
     private readonly resolver;

package/dist/css/production/format/{componentWriter.js → moduleEntryWriter.js}

@@ -1,7 +1,7 @@
 import path from 'node:path';
+import { createOutputModuleStyleSpecifier, createOutputOwnStyleSpecifier, } from '#auklet/css/core/style/specifier';
 import { writeStyleFile, } from '#auklet/css/production/format/shared';
-import { toPosixPath } from '#auklet/utils';
-export class ComponentStyleEntryWriter {
+export class ModuleStyleEntryWriter {
     config;
     sourceRoot;
     resolver;
@@ -36,15 +36,13 @@ export class ComponentStyleEntryWriter {
         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));
-        });
+        return specifiers.map((specifier) => createOutputModuleStyleSpecifier(specifier, styleDir));
     }
     getOwnStyleSpecifiers(ownStyleFiles, styleDir, outRoot) {
-        return ownStyleFiles.map((styleFile) => toPosixPath(path.relative(styleDir, path.join(outRoot, path.relative(this.sourceRoot, styleFile)))));
+        return ownStyleFiles.map((styleFile) => createOutputOwnStyleSpecifier({
+            sourceRoot: this.sourceRoot,
+            outputRoot: outRoot,
+            styleDir,
+        }, styleFile));
     }
 }

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

@@ -1,4 +1,5 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
+export { toRelativeImportSpecifier } from '#auklet/css/core/style/specifier';
 import type { ModuleStyleBuildConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
 export declare const emptyStyleFileComment = "/* Empty style file kept so automated tooling can resolve this CSS path. */\n";
 export type FormatWriterOptions = {
@@ -10,5 +11,4 @@ export type ThemeStyleOutput = {
     themeName: string;
     file: string;
 };
-export declare function toRelativeImportSpecifier(fromDir: string, file: string): string;
 export declare function writeStyleFile(file: string, code: string): void;

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

@@ -1,11 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { toPosixPath } from '#auklet/utils';
+export { toRelativeImportSpecifier } from '#auklet/css/core/style/specifier';
 export const emptyStyleFileComment = '/* Empty style file kept so automated tooling can resolve this CSS path. */\n';
-export function toRelativeImportSpecifier(fromDir, file) {
-    const relative = toPosixPath(path.relative(fromDir, file));
-    return relative.startsWith('.') ? relative : `./${relative}`;
-}
 export function writeStyleFile(file, code) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, code.trim() ? code : emptyStyleFileComment);

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

@@ -14,10 +14,10 @@ export declare class ModuleStyleOutputWriter {
     private readonly externalWriter;
     private readonly moduleWriter;
     private readonly entryWriter;
-    private readonly componentWriter;
+    private readonly moduleEntryWriter;
     constructor(options: ModuleStyleOutputWriterOptions);
     write(): string[];
     private get outputRoot();
-    private createComponentEntries;
+    private createModuleEntries;
     private writeFormat;
 }