auklet 0.1.3 → 0.1.5

package/dist/cli/parse/build.js

@@ -0,0 +1,161 @@
+import { hasTsdownConfigArg } from '#auklet/build/runTsdown';
+import { aukletCliConfigOverridesEnv, encodeAukletCliConfigOverrides, } from '#auklet/build/cliOverrides';
+import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/parse/values';
+import { readFlagValue, readOptionalFlagValue } from '#auklet/cli/parse/core';
+import { parseWorkspaceSelectionArgs } from '#auklet/cli/parse/workspace';
+const buildFormats = new Set(['cjs', 'esm', 'iife']);
+const buildPlatforms = new Set(['node', 'neutral', 'browser']);
+const hasAukletConfig = (config) => {
+    return Object.keys(config).length > 0;
+};
+export function parseBuildCommand(args, options) {
+    const workspaceArgs = parseWorkspaceSelectionArgs(args, options.envContext);
+    const buildArgs = parseBuildOverrideArgs(workspaceArgs.remainingArgs, options.envContext);
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        workspace: workspaceArgs.workspace,
+        overrides: buildArgs.config,
+        passthroughArgs: buildArgs.args,
+        workspaceScriptArgs: workspaceArgs.remainingArgs,
+    };
+}
+export function parseBuildJsCommand(args, options) {
+    const buildArgs = parseBuildOverrideArgs(args, options.envContext);
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: buildArgs.config,
+        passthroughArgs: buildArgs.args,
+    };
+}
+export function parseBuildCssCommand(args, options) {
+    const buildArgs = parseBuildOverrideArgs(args, options.envContext);
+    const remainingArgs = buildArgs.args.filter((arg) => arg !== '--watch' && arg !== '-w');
+    if (remainingArgs.length) {
+        throw new Error(`[build-css] unknown build-css argument: ${remainingArgs[0]}`);
+    }
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: buildArgs.config,
+        watch: buildArgs.args.includes('--watch') || buildArgs.args.includes('-w'),
+    };
+}
+export function parseBuildOverrideArgs(args, envContext) {
+    const remainingArgs = [];
+    const config = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const [name, inlineValue] = arg.split('=', 2);
+        if (name === '--source') {
+            config.source = getResolvedFlagValue(args, index, inlineValue, name, envContext);
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--output') {
+            config.output = getResolvedFlagValue(args, index, inlineValue, name, envContext);
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--modules') {
+            const value = readOptionalFlagValue(args, index, inlineValue);
+            config.modules =
+                value === undefined
+                    ? true
+                    : resolveCliBoolean(value, { label: name, context: envContext });
+            if (inlineValue === undefined && value !== undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--no-modules') {
+            config.modules = false;
+            continue;
+        }
+        if (name === '--build.formats') {
+            config.build = {
+                ...config.build,
+                formats: parseBuildFormats(inlineValue === undefined
+                    ? getResolvedFlagValue(args, index, inlineValue, name, envContext)
+                    : (resolveCliValue(inlineValue, {
+                        label: name,
+                        context: envContext,
+                    }) ?? inlineValue)),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--build.target') {
+            config.build = {
+                ...config.build,
+                target: getResolvedFlagValue(args, index, inlineValue, name, envContext),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--build.platform') {
+            config.build = {
+                ...config.build,
+                platform: parseBuildPlatform(getResolvedFlagValue(args, index, inlineValue, name, envContext)),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--build.tsconfig') {
+            config.build = {
+                ...config.build,
+                tsconfig: getResolvedFlagValue(args, index, inlineValue, name, envContext),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    if (hasAukletConfig(config) && hasTsdownConfigArg(remainingArgs)) {
+        throw new Error('Auklet build config flags cannot be used with tsdown --config, -c, or --no-config.');
+    }
+    return {
+        args: remainingArgs,
+        config,
+    };
+}
+export function createBuildEnv(config) {
+    if (!hasAukletConfig(config))
+        return undefined;
+    return {
+        [aukletCliConfigOverridesEnv]: encodeAukletCliConfigOverrides(config),
+    };
+}
+const getResolvedFlagValue = (args, index, inlineValue, flag, envContext) => {
+    return resolveCliValue(readFlagValue(args, index, inlineValue, flag), {
+        label: flag,
+        context: envContext,
+    });
+};
+const parseBuildFormats = (value) => {
+    const formats = value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (!formats.length) {
+        throw new Error('--build.formats requires at least one format.');
+    }
+    for (const format of formats) {
+        if (!buildFormats.has(format)) {
+            throw new Error(`Unknown build format: ${format}`);
+        }
+    }
+    return formats;
+};
+const parseBuildPlatform = (value) => {
+    if (!buildPlatforms.has(value)) {
+        throw new Error(`Unknown build platform: ${value}`);
+    }
+    return value;
+};

package/dist/cli/parse/core.d.ts

@@ -0,0 +1,14 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function stripArgsSeparator(args: Array<string>): string[];
+export declare function readFlagValue(args: Array<string>, index: number, inlineValue: string | undefined, flag: string): string;
+export declare function readOptionalFlagValue(args: Array<string>, index: number, inlineValue: string | undefined): string | undefined;
+export declare function dedupe<T>(items: Array<T>): T[];
+export declare function stringOption(value: unknown, label: string, envContext: AukletEnvContext): string | undefined;
+export declare function deferredStringOption(value: unknown, label: string): {
+    raw: string;
+    resolve(context: AukletEnvContext): string | undefined;
+} | undefined;
+export declare function booleanOption(value: unknown, label: string, envContext: AukletEnvContext, defaultValue?: boolean): boolean;
+export declare function stringArrayOption(value: unknown, label: string, envContext: AukletEnvContext): string[];
+export declare function validateUnknownFlags(argv: Record<string, unknown>, allowedFlags: Set<string>, scope: string): void;
+export declare function validateNoPrefixedFlags(args: Array<string>, allowedFlags: Set<string>, scope: string): void;

package/dist/cli/parse/core.js

@@ -0,0 +1,68 @@
+import { isArray } from 'aidly';
+import { createDeferredCliValue, resolveCliBoolean, resolveCliValue, } from '#auklet/cli/parse/values';
+export function stripArgsSeparator(args) {
+    return args.filter((arg) => arg !== '--');
+}
+export function readFlagValue(args, index, inlineValue, flag) {
+    const value = inlineValue ?? args[index + 1];
+    if (!value || value.startsWith('--')) {
+        throw new Error(`${flag} requires a value.`);
+    }
+    return value;
+}
+export function readOptionalFlagValue(args, index, inlineValue) {
+    if (inlineValue !== undefined)
+        return inlineValue;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--'))
+        return undefined;
+    return value;
+}
+export function dedupe(items) {
+    return [...new Set(items)];
+}
+export function stringOption(value, label, envContext) {
+    if (value === undefined)
+        return undefined;
+    if (isArray(value))
+        return stringOption(value.at(-1), label, envContext);
+    return resolveCliValue(String(value), { label, context: envContext });
+}
+export function deferredStringOption(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (isArray(value))
+        return deferredStringOption(value.at(-1), label);
+    return createDeferredCliValue(String(value), { label });
+}
+export function booleanOption(value, label, envContext, defaultValue = false) {
+    if (value === undefined)
+        return defaultValue;
+    if (isArray(value)) {
+        return booleanOption(value.at(-1), label, envContext, defaultValue);
+    }
+    if (typeof value === 'boolean')
+        return value;
+    return resolveCliBoolean(String(value), { label, context: envContext });
+}
+export function stringArrayOption(value, label, envContext) {
+    if (value === undefined)
+        return [];
+    const values = isArray(value)
+        ? value.map((item) => stringOption(item, label, envContext)).filter(Boolean)
+        : [stringOption(value, label, envContext)].filter(Boolean);
+    return values.filter((item) => Boolean(item));
+}
+export function validateUnknownFlags(argv, allowedFlags, scope) {
+    for (const flag of Object.keys(argv)) {
+        if (!allowedFlags.has(flag)) {
+            throw new Error(`[${scope}] unknown option: --${flag}`);
+        }
+    }
+}
+export function validateNoPrefixedFlags(args, allowedFlags, scope) {
+    const flag = args.find((arg) => arg.startsWith('--no-') && !allowedFlags.has(arg));
+    if (flag) {
+        throw new Error(`[${scope}] unknown option: ${flag}`);
+    }
+}

package/dist/cli/parse/dev.d.ts

@@ -0,0 +1,17 @@
+import type { AukletEnvContext } from '#auklet/env';
+import type { BuildCommandOptions } from '#auklet/cli/parse/build';
+export type DevCommandOptions = BuildCommandOptions;
+export declare function parseDevCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+    };
+    overrides: import("../..").AukletConfig;
+    passthroughArgs: string[];
+    workspaceScriptArgs: string[];
+};

package/dist/cli/parse/dev.js

@@ -0,0 +1,4 @@
+import { parseBuildCommand } from '#auklet/cli/parse/build';
+export function parseDevCommand(args, options) {
+    return parseBuildCommand(args, options);
+}

package/dist/cli/parse/owner.d.ts

@@ -0,0 +1,11 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function parseOwnerCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    users: string[];
+    filters: string[];
+    packages: string[];
+    otp: string | undefined;
+};

package/dist/cli/parse/owner.js

@@ -0,0 +1,25 @@
+import minimist from 'minimist';
+import { stringArrayOption, stringOption, stripArgsSeparator, validateNoPrefixedFlags, validateUnknownFlags, } from '#auklet/cli/parse/core';
+const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
+export function parseOwnerCommand(args, options) {
+    const cliArgs = stripArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(), 'publish');
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'package', 'otp'],
+    });
+    validateUnknownFlags(argv, ownerFlags, 'publish');
+    const [subcommand, ...users] = argv._;
+    if (subcommand !== 'add') {
+        throw new Error('[publish] expected owner command: auk owner add <user...>');
+    }
+    if (!users.length) {
+        throw new Error('[publish] owner add requires at least one user.');
+    }
+    return {
+        cwd: options.cwd,
+        users,
+        filters: stringArrayOption(argv.filter, '--filter', options.envContext),
+        packages: stringArrayOption(argv.package, '--package', options.envContext),
+        otp: stringOption(argv.otp, '--otp', options.envContext),
+    };
+}

package/dist/cli/parse/publish.d.ts

@@ -0,0 +1,19 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function parsePublishCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    otp: string | undefined;
+    filters: string[];
+    version: string | undefined;
+    git: boolean;
+    format: boolean;
+    dryRun: boolean;
+    allowDirty: boolean;
+    ignoreScripts: boolean;
+    token: {
+        raw: string;
+        resolve(context: AukletEnvContext): string | undefined;
+    } | undefined;
+};

package/dist/cli/parse/publish.js

@@ -0,0 +1,60 @@
+import minimist from 'minimist';
+import { booleanOption, deferredStringOption, dedupe, stringArrayOption, stringOption, stripArgsSeparator, validateNoPrefixedFlags, validateUnknownFlags, } from '#auklet/cli/parse/core';
+const publishFlags = new Set([
+    '_',
+    'filter',
+    'workspace',
+    'version',
+    'dry-run',
+    'format',
+    'git',
+    'otp',
+    'token',
+    'ignore-scripts',
+    'allow-dirty',
+]);
+export function parsePublishCommand(args, options) {
+    const argv = parsePublishArgs(args);
+    if (argv._.length) {
+        throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
+    }
+    return {
+        cwd: options.cwd,
+        otp: stringOption(argv.otp, '--otp', options.envContext),
+        filters: resolvePublishFilters(argv, options.envContext),
+        version: stringOption(argv.version, '--version', options.envContext),
+        git: booleanOption(argv.git, '--git', options.envContext, true),
+        format: booleanOption(argv.format, '--format', options.envContext, true),
+        dryRun: booleanOption(argv['dry-run'], '--dry-run', options.envContext),
+        allowDirty: booleanOption(argv['allow-dirty'], '--allow-dirty', options.envContext),
+        ignoreScripts: booleanOption(argv['ignore-scripts'], '--ignore-scripts', options.envContext),
+        token: deferredStringOption(argv.token, '--token'),
+    };
+}
+const parsePublishArgs = (args) => {
+    const cliArgs = stripArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']), 'publish');
+    const argv = minimist(cliArgs, {
+        string: [
+            'filter',
+            'version',
+            'otp',
+            'token',
+            'dry-run',
+            'format',
+            'git',
+            'ignore-scripts',
+            'allow-dirty',
+        ],
+        boolean: ['workspace'],
+    });
+    validateUnknownFlags(argv, publishFlags, 'publish');
+    return argv;
+};
+const resolvePublishFilters = (argv, envContext) => {
+    const filters = stringArrayOption(argv.filter, '--filter', envContext);
+    if (booleanOption(argv.workspace, '--workspace', envContext)) {
+        filters.push('*');
+    }
+    return dedupe(filters);
+};

package/dist/cli/parse/values.d.ts

@@ -0,0 +1,17 @@
+import type { AukletEnvContext } from '#auklet/env';
+export type CliValueOptions = {
+    label: string;
+    context: AukletEnvContext;
+};
+export type DeferredCliValue = {
+    raw: string;
+    resolve(context: AukletEnvContext): string | undefined;
+};
+export declare function createDeferredCliValue(value: string, options: {
+    label: string;
+}): {
+    raw: string;
+    resolve(context: AukletEnvContext): string | undefined;
+};
+export declare function resolveCliValue(value: string | undefined, options: CliValueOptions): string | undefined;
+export declare function resolveCliBoolean(value: boolean | string | undefined, options: CliValueOptions): boolean;

package/dist/cli/parse/values.js

@@ -0,0 +1,14 @@
+export function createDeferredCliValue(value, options) {
+    return {
+        raw: value,
+        resolve(context) {
+            return resolveCliValue(value, { label: options.label, context });
+        },
+    };
+}
+export function resolveCliValue(value, options) {
+    return options.context.resolveValue(value, { label: options.label });
+}
+export function resolveCliBoolean(value, options) {
+    return options.context.resolveBoolean(value, { label: options.label });
+}

package/dist/cli/parse/workspace.d.ts

@@ -0,0 +1,12 @@
+import type { AukletEnvContext } from '#auklet/env';
+export type WorkspaceSelection = {
+    filters: Array<string>;
+    includeDependencies: boolean;
+};
+export declare function parseWorkspaceSelectionArgs(args: Array<string>, envContext: AukletEnvContext): {
+    remainingArgs: string[];
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+    };
+};

package/dist/cli/parse/workspace.js

@@ -0,0 +1,45 @@
+import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/parse/values';
+import { dedupe, readFlagValue, readOptionalFlagValue, } from '#auklet/cli/parse/core';
+export function parseWorkspaceSelectionArgs(args, envContext) {
+    const remainingArgs = [];
+    const filters = [];
+    let includeDependencies = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const [name, inlineValue] = arg.split('=', 2);
+        if (name === '--workspace') {
+            if (inlineValue !== undefined) {
+                throw new Error('--workspace does not accept a value.');
+            }
+            filters.push('*');
+            continue;
+        }
+        if (name === '--filter') {
+            filters.push(resolveCliValue(readFlagValue(args, index, inlineValue, name), {
+                label: name,
+                context: envContext,
+            }));
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--deps') {
+            const value = readOptionalFlagValue(args, index, inlineValue);
+            includeDependencies =
+                value === undefined
+                    ? true
+                    : resolveCliBoolean(value, { label: name, context: envContext });
+            if (inlineValue === undefined && value !== undefined)
+                index += 1;
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    return {
+        remainingArgs,
+        workspace: {
+            filters: dedupe(filters),
+            includeDependencies,
+        },
+    };
+}

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

@@ -1,6 +1,5 @@
 import type { NormalizedAukletConfig } from '#auklet/types';
 export declare function getGlobalStyleDependencies(config: NormalizedAukletConfig): string[];
-export declare function getExternalStyleDependencies(config: NormalizedAukletConfig): string[];
 export declare function getThemeStyleDependencies(config: NormalizedAukletConfig, themeName: string): string[];
 export declare function getThemeNames(config: NormalizedAukletConfig): string[];
 export declare function getThemeStyleEntries(config: NormalizedAukletConfig): {

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

@@ -15,9 +15,6 @@ export function getGlobalStyleDependencies(config) {
     }
     return dependencies;
 }
-export function getExternalStyleDependencies(config) {
-    return getGlobalStyleDependencies(config);
-}
 export function getThemeStyleDependencies(config, themeName) {
     const dependencies = [];
     for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {

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

@@ -1,4 +1,4 @@
-import { getExternalStyleDependencies, getGlobalStyleDependencies, getThemeNames, getThemeStyleDependencies, } from '#auklet/css/core/style/dependencies';
+import { 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 都从这里取入口语义。
@@ -21,7 +21,7 @@ export function createThemeEntryParts(config, themeName, options = {}) {
 }
 export function createExternalEntryParts(config) {
     return [
-        dependenciesPart(getExternalStyleDependencies(config)),
+        dependenciesPart(getGlobalStyleDependencies(config)),
     ];
 }
 export function collectModuleStyleImports(packageContext) {

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

@@ -1,3 +1,2 @@
 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

@@ -14,6 +14,3 @@ export function groupStyleFilesByDir(sourceRoot, styleFiles) {
 export function createStyleFileKeySet(styleFiles) {
     return new Set(Array.from(styleFiles, normalizeFileKey));
 }
-export function createStyleFileKey(styleFile) {
-    return normalizeFileKey(styleFile);
-}

package/dist/css/core/stylePackageContext.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
 import { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
-import { createStyleFileKey, createStyleFileKeySet, } from '#auklet/css/core/style/files';
+import { createStyleFileKeySet } from '#auklet/css/core/style/files';
 import { getThemeNames, resolveThemeStyleFiles, } from '#auklet/css/core/style/dependencies';
-import { fileWalker } from '#auklet/utils';
+import { fileWalker, normalizeFileKey } from '#auklet/utils';
 export class StylePackageContext {
     options;
     normalizedConfig;
@@ -36,6 +36,6 @@ export class StylePackageContext {
         const themeFileKeys = createStyleFileKeySet(this.themeFiles.values());
         return files
             .filter((file) => this.options.config.styleExtensions.includes(path.extname(file)))
-            .filter((styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)));
+            .filter((styleFile) => !themeFileKeys.has(normalizeFileKey(styleFile)));
     }
 }

package/dist/css/inspect.js

@@ -3,7 +3,8 @@ import { readFileSync } from 'node:fs';
 import { isPlainObject, isString } from 'aidly';
 import { normalizeAukletConfig } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
-import { resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { parseBuildOverrideArgs } from '#auklet/cli/parse/build';
+import { AukletEnvContext } from '#auklet/env';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
 import { createExternalEntryParts, createModuleStyleEntryPlans, createStyleEntryParts, createThemeEntryParts, } from '#auklet/css/core/style/entries';
@@ -20,11 +21,11 @@ export async function runInspectCssCli(args) {
     return 0;
 }
 export async function resolveInspectCssOptions(args) {
-    const buildArgs = resolveBuildCliArgs(args.filter((arg) => arg !== '--'));
+    const cwd = process.cwd();
+    const buildArgs = parseBuildOverrideArgs(args.filter((arg) => arg !== '--'), new AukletEnvContext(cwd));
     if (buildArgs.args.length) {
         throw new Error(`[inspect] unknown inspect css argument: ${buildArgs.args[0]}`);
     }
-    const cwd = process.cwd();
     const workspaceRoot = findWorkspaceRoot(cwd);
     const packageRoots = workspaceRoot === cwd
         ? (await readPnpmWorkspacePackageInfo(cwd))

package/dist/css/vite/hmr.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import { isString } from 'aidly';
 import { normalizeFileKey } from '#auklet/utils';
-import { createScopedAukletLogger } from '#auklet/logger';
+import { createAukletLogger } from '#auklet/logger';
 const FULL_RELOAD_SUPPRESS_MS = 100;
 const DUPLICATE_UPDATE_IGNORE_MS = 500;
-const logger = createScopedAukletLogger('css:vite');
+const logger = createAukletLogger({ scope: 'css:vite' });
 const toBrowserVirtualPath = (id) => {
     return `/@id/${id.replace('\0', '__x00__')}`;
 };

package/dist/css/vite/moduleGraph/packageSource/monorepo.d.ts

@@ -1,4 +1,4 @@
-import type { WorkspacePackageInfo } from '#auklet/workspace/packages';
+import { type WorkspacePackageInfo } from '#auklet/workspace/packages';
 import type { StylePackageInfo, StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
 export type MonorepoPackageSourceOptions = {
     root: string;

package/dist/css/vite/moduleGraph/packageSource/monorepo.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
+import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 import { normalizeFileKey, toPosixPath, toWatchPath } from '#auklet/utils';
-import { readPnpmWorkspacePackageInfoSync } from '#auklet/workspace/packages';
+import { readPnpmWorkspacePackageInfoSync, } from '#auklet/workspace/packages';
 export class MonorepoPackageSource {
     options;
     packages;

package/dist/env.d.ts

@@ -0,0 +1,22 @@
+export declare class AukletEnvContext {
+    private readonly packageRoot;
+    private readonly root?;
+    private readonly env;
+    private readonly processEnv;
+    constructor(packageRoot: string, root?: string | undefined, options?: {
+        processEnv?: Record<string, string | undefined>;
+    });
+    get values(): Record<string, string | undefined>;
+    get normalizedValues(): Record<string, string | undefined> | undefined;
+    createPackageContext(packageRoot: string): AukletEnvContext;
+    resolveValue(value: string | undefined, options: {
+        label: string;
+    }): string | undefined;
+    resolveBoolean(value: boolean | string | undefined, options: {
+        label: string;
+    }): boolean;
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    private readEnv;
+    private findEnvFiles;
+    private createProcessEnvOverrides;
+}