@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.5 → 3.2.0-ultramodern.51

package/dist/types/plugins/deploy/utils/generator.d.ts

@@ -0,0 +1,24 @@
+import type { ProdServerOptions } from '@modern-js/prod-server';
+import type { AppToolsNormalizedConfig } from '../../../types';
+import type { AppToolsContext } from '../../../types/plugin';
+export declare const serverAppContextTemplate: (appContext: AppToolsContext) => {
+    sharedDirectory: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    metaName: any;
+    bffRuntimeFramework: any;
+};
+export type PluginItem = [string, Record<string, any> | undefined];
+export declare const genPluginImportsCode: (plugins: PluginItem[], isESM?: boolean) => string;
+export declare const getPluginsCode: (plugins: PluginItem[]) => string;
+export declare const getServerConfigPath: (meta: string) => string;
+export interface GenerateHandlerOptions {
+    template: string;
+    appContext: AppToolsContext;
+    config: AppToolsNormalizedConfig;
+    serverConfig?: Partial<ProdServerOptions>;
+    genAppContextTemplate?: typeof serverAppContextTemplate;
+    genPluginImports?: typeof genPluginImportsCode;
+    isESM?: boolean;
+}
+export declare const generateHandler: ({ template, appContext, config, serverConfig: modifyServerConfig, genAppContextTemplate, genPluginImports, isESM, }: GenerateHandlerOptions) => Promise<string>;

package/dist/types/plugins/deploy/utils/index.d.ts

@@ -0,0 +1,16 @@
+export type ServerAppContext = {
+    sharedDirectory: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    metaName: string;
+    bffRuntimeFramework: string;
+};
+export declare const normalizePath: (filePath: string) => string;
+export declare const getProjectUsage: (appDirectory: string, distDirectory: string, metaName: string) => {
+    useSSR: boolean;
+    useAPI: boolean;
+    useWebServer: boolean;
+};
+export declare const getTemplatePath: (file: string) => string;
+export declare const readTemplate: (file: string) => Promise<any>;
+export declare const resolveESMDependency: (entry: string) => Promise<string | undefined>;

package/dist/types/plugins/initialize/index.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools, CliPlugin } from '../../types';
+declare const _default: () => CliPlugin<AppTools>;
+export default _default;

package/dist/types/plugins/serverBuild.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools, CliPlugin } from '../types';
+declare const _default: () => CliPlugin<AppTools>;
+export default _default;

package/dist/types/plugins/serverRuntime.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools, CliPlugin } from '../types';
+declare const _default: () => CliPlugin<AppTools>;
+export default _default;

package/dist/types/presetUltramodern.d.ts

@@ -0,0 +1,6 @@
+import { type AppBaselineOptions } from './baseline';
+import type { AppUserConfig } from './types';
+export interface PresetUltramodernOptions extends AppBaselineOptions {
+}
+export declare const createPresetUltramodernConfig: (options?: PresetUltramodernOptions) => AppUserConfig;
+export declare const presetUltramodern: (config: AppUserConfig, options?: PresetUltramodernOptions) => AppUserConfig;

package/dist/types/rsbuild.d.ts

@@ -0,0 +1,12 @@
+import type { AppUserConfig } from './types';
+type ResolveModernRsbuildConfigOptions = {
+    command: string;
+    configPath?: string;
+    cwd?: string;
+    metaName?: string;
+    modifyModernConfig?: (config: AppUserConfig) => AppUserConfig | Promise<AppUserConfig>;
+};
+export declare function resolveModernRsbuildConfig(options: ResolveModernRsbuildConfigOptions): Promise<{
+    rsbuildConfig: any;
+}>;
+export type { ResolveModernRsbuildConfigOptions };

package/dist/types/run/index.d.ts

@@ -0,0 +1,20 @@
+import type { InternalPlugins } from '@modern-js/types';
+import { handleSetupResult } from '../compat/hooks';
+export interface RunOptions {
+    cwd?: string;
+    configFile?: string;
+    metaName?: string;
+    statePluginName?: string;
+    internalPlugins?: InternalPlugins;
+    initialLog?: string;
+    version: string;
+}
+export declare function createRunOptions({ cwd, initialLog, metaName, version, internalPlugins, configFile, }: RunOptions): Promise<{
+    cwd: string | undefined;
+    initialLog: string;
+    configFile: string;
+    metaName: string;
+    internalPlugins: any;
+    handleSetupResult: typeof handleSetupResult;
+}>;
+export declare function run(options: RunOptions): Promise<void>;

package/dist/types/types/config/deploy.d.ts

@@ -0,0 +1,46 @@
+export interface MicroFrontend {
+    /**
+     * Specifies whether to enable the HTML entry.
+     * When set to `true`, the current child application will be externalized for `react` and `react-dom`.
+     * @default true
+     */
+    enableHtmlEntry?: boolean;
+    /**
+     * Specifies whether to use the external base library.
+     * @default false
+     */
+    externalBasicLibrary?: boolean;
+    moduleApp?: string;
+    /**
+     * Runtime compatibility digest exposed in remote contracts (manifest / remote entry).
+     */
+    runtimeDigest?: string;
+    /**
+     * SRI-style integrity token for the remote entry contract.
+     * Example: `sha256-<base64Digest>`.
+     */
+    integrity?: string;
+    /**
+     * Opaque attestation token exposed in remote runtime metadata.
+     * Can be validated by the host via runtime `remoteTrust.attestations`.
+     */
+    attestation?: string;
+}
+export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
+export interface DeployUserConfig {
+    /**
+     * Selects the deploy output preset.
+     * `MODERNJS_DEPLOY` still overrides provider auto-detection when set.
+     * @default node
+     */
+    target?: DeployTarget;
+    /**
+     * Used to configure micro-frontend sub-application information.
+     * @default false
+     */
+    microFrontend?: boolean | MicroFrontend;
+    worker?: {
+        name?: string;
+        ssr?: boolean;
+    };
+}

package/dist/types/types/config/dev.d.ts

@@ -0,0 +1,55 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { CorsOptions, SetupMiddlewares } from '@modern-js/server';
+import type { ServerConfig } from '@rsbuild/core';
+type BuilderDevConfig = NonNullable<BuilderConfig['dev']>;
+export type DevProxyOptions = string | Record<string, string>;
+export interface DevServerUserConfig {
+    /**
+     * Configure CORS for the dev server.
+     * - object: enable CORS with the specified options.
+     * - true: enable CORS with default options (allow all origins, not recommended).
+     * - false: disable CORS.
+     * @default
+     * ```js
+     * { origin: defaultAllowedOrigins }
+     * ```
+     * where `defaultAllowedOrigins` includes:
+     * - `localhost`
+     * - `127.0.0.1`
+     *
+     * @link https://github.com/expressjs/cors
+     */
+    cors?: boolean | CorsOptions;
+    /**
+     * Whether to enable gzip compression for served static assets.
+     */
+    compress?: ServerConfig['compress'];
+    /**
+     * Adds headers to all responses.
+     */
+    headers?: ServerConfig['headers'];
+    /**
+     * The index.html page will likely have to be served in place of any 404 responses.
+     */
+    historyApiFallback?: ServerConfig['historyApiFallback'];
+    /**
+     * Proxying some URLs.
+     */
+    proxy?: ServerConfig['proxy'];
+    /**
+     * Whether to watch files change in directories such as `mock/`, `server/`, `api/`.
+     */
+    watch?: boolean;
+}
+/**
+ * setupMiddlewares is a special field, it will not be passed to Rsbuild.
+ * Although its name is the same as in Rsbuild, it is consumed by Modern.js.
+ */
+export type DevUserConfig = Omit<BuilderDevConfig, 'setupMiddlewares'> & {
+    setupMiddlewares?: SetupMiddlewares;
+    /**
+     * Dev server specific options.
+     */
+    server?: DevServerUserConfig;
+};
+export {};

package/dist/types/types/config/experiments.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderConfig } from '@modern-js/builder';
+export type BuilderExperimentsConfig = Required<BuilderConfig>['experiments'];
+export type ExperimentsUserConfig = BuilderExperimentsConfig;

package/dist/types/types/config/html.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { UnwrapBuilderConfig } from '../utils';
+export type HtmlUserConfig = UnwrapBuilderConfig<BuilderConfig, 'html'>;

package/dist/types/types/config/index.d.ts

@@ -0,0 +1,48 @@
+import type { CLIPlugin, CLIPluginExtends } from '@modern-js/plugin';
+import type { BffUserConfig, ServerUserConfig } from '@modern-js/server-core';
+import type { RsbuildConfig } from '@rsbuild/core';
+import type { AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks } from '../plugin';
+import type { DeployUserConfig } from './deploy';
+import type { DevUserConfig } from './dev';
+import type { ExperimentsUserConfig } from './experiments';
+import type { HtmlUserConfig } from './html';
+import type { OutputUserConfig } from './output';
+import type { PerformanceUserConfig } from './performance';
+import type { ResolveUserConfig } from './resolve';
+import type { SecurityUserConfig } from './security';
+import type { SourceUserConfig } from './source';
+import type { TestingUserConfig } from './testing';
+import type { ToolsUserConfig } from './tools';
+export * from './output';
+export type AppToolsBuilderPlugins = NonNullable<RsbuildConfig['plugins']>;
+export interface AppToolsUserConfig {
+    resolve?: ResolveUserConfig;
+    server?: ServerUserConfig;
+    source?: SourceUserConfig;
+    output?: OutputUserConfig;
+    experiments?: ExperimentsUserConfig;
+    /**
+     * The configuration of `bff` is provided by `bff` plugin.
+     * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+     * @requires `bff` plugin
+     */
+    bff?: BffUserConfig;
+    dev?: DevUserConfig;
+    deploy?: DeployUserConfig;
+    html?: HtmlUserConfig;
+    tools?: ToolsUserConfig;
+    security?: SecurityUserConfig;
+    testing?: TestingUserConfig;
+    builderPlugins?: AppToolsBuilderPlugins;
+    performance?: PerformanceUserConfig;
+    environments?: RsbuildConfig['environments'];
+    splitChunks?: RsbuildConfig['splitChunks'];
+    plugins?: CliPlugin<AppTools>[];
+}
+interface SharedNormalizedConfig<RawConfig> {
+    cliOptions?: Record<string, any>;
+    _raw: RawConfig;
+}
+export type AppToolsNormalizedConfig<Config = AppToolsUserConfig> = Required<Config> & SharedNormalizedConfig<Config>;
+export type AppTools = Required<CLIPluginExtends<AppToolsUserConfig, AppToolsNormalizedConfig, AppToolsExtendContext, AppToolsExtendAPI, AppToolsExtendHooks>>;
+export type CliPlugin<Extends extends CLIPluginExtends> = CLIPlugin<Extends>;

package/dist/types/types/config/output.d.ts

@@ -0,0 +1,61 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { SSGConfig, SSGMultiEntryOptions } from '@modern-js/types';
+import type CompressionPlugin from 'compression-webpack-plugin';
+import type { UnwrapBuilderConfig } from '../utils';
+type CompressionPluginOptions = NonNullable<ConstructorParameters<typeof CompressionPlugin>[0]>;
+export type PrecompressCodecOptions = boolean | CompressionPluginOptions;
+export interface PrecompressConfig {
+    /**
+     * Configure gzip precompression options.
+     * `true` means using default options.
+     * `false` means disabling gzip precompression.
+     * @default true
+     */
+    gzip?: PrecompressCodecOptions;
+    /**
+     * Configure brotli precompression options.
+     * `true` means using default options.
+     * `false` means disabling brotli precompression.
+     * @default true
+     */
+    brotli?: PrecompressCodecOptions;
+}
+export interface OutputUserConfig extends UnwrapBuilderConfig<BuilderConfig, 'output'> {
+    /**
+     * Enable SSG for self-controlled routing or conventional routing.
+     * @default false
+     */
+    ssg?: SSGConfig;
+    /**
+     * Specify SSG configuration by entries for multi-entry apps.
+     * Takes precedence over `ssg` when provided.
+     */
+    ssgByEntries?: SSGMultiEntryOptions;
+    /**
+     * When using convention-based routing, the framework will split js and css based on the route to load on demand.
+     * If your project does not want to split js and css based on routes, you can set this option to false.
+     * @default true
+     */
+    splitRouteChunks?: boolean;
+    /**
+     * Used to control whether to inject convention-based routing information into the HTML.
+     * @default true
+     */
+    enableInlineRouteManifests?: boolean;
+    /**
+     * Used to control whether to inject convention-based routing information into the HTML.
+     * @default false
+     */
+    disableInlineRouteManifests?: boolean;
+    /**
+     * Specify the temporary directory for framework generated files.
+     */
+    tempDir?: string;
+    /**
+     * Generate precompressed static assets by using compression-webpack-plugin.
+     * `true` means enabling both gzip and brotli with default options.
+     * @default true
+     */
+    precompress?: boolean | PrecompressConfig;
+}
+export type { SSGConfig, SSGMultiEntryOptions, SSGRouteOptions, SSGSingleEntryOptions, } from '@modern-js/types';

package/dist/types/types/config/performance.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { UnwrapBuilderConfig } from '../utils';
+export type PerformanceUserConfig = UnwrapBuilderConfig<BuilderConfig, 'performance'>;

package/dist/types/types/config/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderConfig } from '@modern-js/builder';
+export type ResolveUserConfig = BuilderConfig['resolve'];

package/dist/types/types/config/security.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderConfig } from '@modern-js/builder';
+export type SecurityUserConfig = Required<BuilderConfig>['security'];

package/dist/types/types/config/source.d.ts

@@ -0,0 +1,61 @@
+import type { BuilderConfig } from '@modern-js/builder';
+export type Entry = string | {
+    /**
+     * The entry file path.
+     */
+    entry: string;
+    /**
+     * Disable framework's behavior of automatically generating entry code.
+     */
+    disableMount?: boolean;
+    /**
+     * use src/{entryName}/entry.tsx to custom entry
+     */
+    customEntry?: boolean;
+};
+export type Entries = Record<string, Entry>;
+export interface SourceUserConfig extends NonNullable<BuilderConfig['source']> {
+    /**
+     * Add code before each page entry. It will be executed before the page code.
+     * @default []
+     */
+    preEntry?: string | string[];
+    /**
+     * Used to configure custom page entries.
+     */
+    entries?: Entries;
+    /**
+     * Used to configure the main entry name.
+     * @default 'main'
+     */
+    mainEntryName?: string;
+    /**
+     * This option is used for Module Federation scenario.
+     * When this option is enabled, framework will wrap the automatically generated entry files with dynamic import.
+     * @default false
+     */
+    enableAsyncEntry?: boolean;
+    /**
+     * When enabled, framework will inject `source.preEntry` into the top of the
+     * auto-generated entry file (`index.jsx`) and will not pass `source.preEntry`
+     * to builder config.
+     * This is useful when `source.enableAsyncEntry` is enabled and you still want
+     * preEntry to run before the real entry code.
+     * @default false
+     */
+    enableAsyncPreEntry?: boolean;
+    /**
+     * Used to disable the functionality of automatically identifying page entry points based on directory structure.
+     * @default false
+     */
+    disableDefaultEntries?: boolean;
+    /**
+     * By default, framework scans the src directory to identify page entries.
+     * You can customize the directory used for identifying page entries with this option.
+     */
+    entriesDir?: string;
+    /**
+     * Customize the directory of the framework configuration files.
+     */
+    configDir?: string;
+}

package/dist/types/types/config/testing.d.ts

@@ -0,0 +1,8 @@
+import type { TestConfig } from '@modern-js/types';
+export interface TestingUserConfig {
+    /**
+     * Decide which transformer will be used to compile file
+     * @default 'babel-jest'
+     */
+    transformer?: TestConfig['transformer'];
+}

package/dist/types/types/config/tools.d.ts

@@ -0,0 +1,21 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { JestConfig } from '@modern-js/types';
+import type { UnwrapBuilderConfig } from '../utils';
+type BuilderToolsConfig = UnwrapBuilderConfig<BuilderConfig, 'tools'>;
+export interface ToolsUserConfig extends Omit<BuilderToolsConfig, 'swc'> {
+    /**
+     * Used to custom Jest configurations.
+     * @requires `test` plugin.
+     * The configuration of `tools.jest` is provided by `test` plugin.
+     * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+     */
+    jest?: JestConfig | ((jestConfig: JestConfig) => JestConfig);
+    /**
+     * Used to custom SWC configurations.
+     * @requires `swc` plugin.
+     * The configuration of `swc` is provided by `swc` plugin.
+     * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+     */
+    swc?: BuilderToolsConfig['swc'];
+}
+export {};

package/dist/types/types/index.d.ts

@@ -0,0 +1,10 @@
+import type { CLIPluginAPI, CLIPluginExtends, RuntimePluginConfig, ServerPluginConfig } from '@modern-js/plugin';
+import type { AppTools, AppToolsNormalizedConfig, AppToolsUserConfig } from './config';
+export type { Rspack } from '@modern-js/builder';
+export type { BffNormalizedConfig, BffUserConfig, LoaderContext, OnError, OnTiming, Params, RequestHandler, RequestHandlerConfig, RequestHandlerOptions, Resource, ServerNormalizedConfig, ServerUserConfig, SSR, SSRByEntries, } from '@modern-js/server-core';
+export * from './config';
+export type { CLIPluginExtends, RuntimePluginConfig, ServerPluginConfig };
+export type AppUserConfig = AppToolsUserConfig;
+export type AppNormalizedConfig = AppToolsNormalizedConfig;
+export type AppToolsAPI = CLIPluginAPI<AppTools>;
+export type { AppToolsContext, AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks, AppToolsHooks as AppToolsFeatureHooks, } from './plugin';

package/dist/types/types/plugin.d.ts

@@ -0,0 +1,114 @@
+import type { AppContext, AsyncHook, InternalContext, PluginHook, PluginHookTap, TransformFunction } from '@modern-js/plugin';
+import type { Hooks } from '@modern-js/plugin/cli';
+import type { Entrypoint, HtmlPartials, HtmlTemplates, NestedRouteForCli, PageRoute, RouteLegacy, ServerPlugin, ServerRoute } from '@modern-js/types';
+import type { getHookRunners } from '../compat/hooks';
+import type { AppTools } from '.';
+import type { AppToolsNormalizedConfig, AppToolsUserConfig } from './config';
+export type AfterPrepareFn = () => Promise<void> | void;
+export type CheckEntryPointFn = TransformFunction<{
+    path: string;
+    entry: false | string;
+}>;
+export type ModifyEntrypointsFn = TransformFunction<{
+    entrypoints: Entrypoint[];
+}>;
+export type ModifyFileSystemRoutesFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
+}>;
+export type DeplpoyFn = () => Promise<void> | void;
+export type GenerateEntryCodeFn = (params: {
+    entrypoints: Entrypoint[];
+}) => Promise<void> | void;
+export type BeforeGenerateRoutesFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    code: string;
+}>;
+export type BeforePrintInstructionsFn = TransformFunction<{
+    instructions: string;
+}>;
+export type AddRuntimeExportsFn = () => Promise<void> | void;
+export interface AppToolsExtendAPI {
+    onAfterPrepare: PluginHookTap<AfterPrepareFn>;
+    deploy: PluginHookTap<DeplpoyFn>;
+    checkEntryPoint: PluginHookTap<CheckEntryPointFn>;
+    modifyEntrypoints: PluginHookTap<ModifyEntrypointsFn>;
+    modifyFileSystemRoutes: PluginHookTap<ModifyFileSystemRoutesFn>;
+    generateEntryCode: PluginHookTap<GenerateEntryCodeFn>;
+    onBeforeGenerateRoutes: PluginHookTap<BeforeGenerateRoutesFn>;
+    /**
+     * @deprecated
+     */
+    onBeforePrintInstructions: PluginHookTap<BeforePrintInstructionsFn>;
+    /**
+     * @deprecated use getAppContext instead
+     */
+    useAppContext: () => AppToolsContext;
+    /**
+     * @deprecated use getConfig instead
+     */
+    useConfigContext: () => AppToolsUserConfig;
+    /**
+     * @deprecated use getNormalizedConfig instead
+     */
+    useResolvedConfigContext: () => AppToolsNormalizedConfig<AppToolsUserConfig>;
+    /**
+     * @deprecated use api.xx instead
+     */
+    useHookRunners: () => ReturnType<typeof getHookRunners>;
+}
+export interface AppToolsExtendHooks extends Record<string, PluginHook<(...args: any[]) => any>> {
+    onAfterPrepare: AsyncHook<AfterPrepareFn>;
+    deploy: AsyncHook<DeplpoyFn>;
+    checkEntryPoint: AsyncHook<CheckEntryPointFn>;
+    modifyEntrypoints: AsyncHook<ModifyEntrypointsFn>;
+    modifyFileSystemRoutes: AsyncHook<ModifyFileSystemRoutesFn>;
+    generateEntryCode: AsyncHook<GenerateEntryCodeFn>;
+    onBeforeGenerateRoutes: AsyncHook<BeforeGenerateRoutesFn>;
+    /**
+     * @deprecated
+     */
+    onBeforePrintInstructions: AsyncHook<BeforePrintInstructionsFn>;
+}
+export interface AppToolsExtendContext {
+    metaName: string;
+    internalDirectory: string;
+    sharedDirectory: string;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    runtimeConfigFile: string;
+    serverPlugins: ServerPlugin[];
+    moduleType: 'module' | 'commonjs';
+    /** Information for entry points */
+    entrypoints: Entrypoint[];
+    /** Selected entry points */
+    checkedEntries: string[];
+    /** Information for server routes */
+    serverRoutes: ServerRoute[];
+    /** Whether to use api only mode */
+    apiOnly: boolean;
+    _internalContext: InternalContext<AppTools>;
+    /**
+     * Information for HTML templates by entry
+     * @private
+     */
+    partialsByEntrypoint?: Record<string, HtmlPartials>;
+    /**
+     * Information for HTML templates
+     * @private
+     */
+    htmlTemplates: HtmlTemplates;
+    /**
+     * @deprecated compat old plugin, default is app tools
+     */
+    toolsType?: string;
+    /**
+     * Identification for bff runtime framework
+     * @private
+     */
+    bffRuntimeFramework?: 'hono' | 'effect';
+}
+export type AppToolsContext = AppContext<AppTools> & AppToolsExtendContext;
+export type AppToolsHooks = Hooks<AppToolsUserConfig, AppToolsNormalizedConfig, {}, {}> & AppToolsExtendHooks;

package/dist/types/types/utils.d.ts

@@ -0,0 +1 @@
+export type UnwrapBuilderConfig<Config, Key extends keyof Config> = Required<Config>[Key];

package/dist/types/ultramodern/designSystem.d.ts

@@ -0,0 +1,54 @@
+export declare const DESIGN_SYSTEM_MODES: readonly ['off', 'tokens', 'components', 'strict'];
+export declare const DESIGN_SYSTEM_OVERRIDE_LAYERS: readonly ['brand', 'vertical', 'application'];
+export type DesignSystemMode = (typeof DESIGN_SYSTEM_MODES)[number];
+export type DesignSystemOverrideLayer = (typeof DESIGN_SYSTEM_OVERRIDE_LAYERS)[number];
+export type DesignSystemTokenValue = string | number;
+export interface DesignSystemTokenPack {
+    id: string;
+    version: string;
+    brand: string;
+    tokens: Record<string, DesignSystemTokenValue>;
+}
+export interface DesignSystemOverride {
+    layer: DesignSystemOverrideLayer;
+    tokens?: Record<string, DesignSystemTokenValue>;
+    reason?: string;
+}
+export interface DesignSystemConsumerContract {
+    id: string;
+    requiredTokens?: string[];
+    unsupportedModes?: DesignSystemMode[];
+    tokenPackVersions?: Record<string, string>;
+}
+export interface DesignSystemRollbackMetadata {
+    tokenPack: string;
+    version: string;
+    reason: string;
+}
+export interface DesignSystemPinMetadata {
+    tokenPack: string;
+    version: string;
+    rollback: DesignSystemRollbackMetadata;
+}
+export interface DesignSystemVerticalContract {
+    mode: DesignSystemMode;
+    tokenPack?: string;
+    overrides?: DesignSystemOverride[];
+    pin?: DesignSystemPinMetadata;
+    consumers?: DesignSystemConsumerContract[];
+}
+export interface DesignSystemContract {
+    tokenPacks: DesignSystemTokenPack[];
+    verticals: Record<string, DesignSystemVerticalContract>;
+}
+export interface DesignSystemValidationIssue {
+    path: string;
+    message: string;
+}
+export interface DesignSystemValidationResult {
+    valid: boolean;
+    issues: DesignSystemValidationIssue[];
+}
+export declare const createDesignSystemTokenPackMap: (tokenPacks: DesignSystemTokenPack[]) => Map<string, DesignSystemTokenPack>;
+export declare const validateDesignSystemConsumerCompatibility: (vertical: DesignSystemVerticalContract, tokenPack: DesignSystemTokenPack | undefined, path?: string) => DesignSystemValidationResult;
+export declare const validateDesignSystemContract: (contract: DesignSystemContract) => DesignSystemValidationResult;

package/dist/types/utils/config.d.ts

@@ -0,0 +1,2 @@
+import type { AppNormalizedConfig } from '../types';
+export declare const emitResolvedConfig: (appDirectory: string, resolvedConfig: AppNormalizedConfig) => Promise<void>;

package/dist/types/utils/createServer.d.ts

@@ -0,0 +1,5 @@
+import type { Server } from 'node:http';
+import type { Http2SecureServer } from 'node:http2';
+export declare const getServer: () => Http2SecureServer<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse, typeof import("node:http2").Http2ServerRequest, typeof import("node:http2").Http2ServerResponse> | Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> | null;
+export declare const setServer: (newServer: Server | Http2SecureServer) => void;
+export declare const closeServer: () => Promise<void>;

package/dist/types/utils/env.d.ts

@@ -0,0 +1,2 @@
+import type { AppToolsContext } from '../types/plugin';
+export declare function getAutoInjectEnv(appContext: AppToolsContext): Record<string, string>;

package/dist/types/utils/generateWatchFiles.d.ts

@@ -0,0 +1,2 @@
+import type { AppToolsContext } from '../types/plugin';
+export declare function generateWatchFiles(appContext: AppToolsContext, configDir?: string): Promise<string[]>;

package/dist/types/utils/getConfigFile.d.ts

@@ -0,0 +1 @@
+export declare const getConfigFile: (configFile?: string, cwd?: string) => any;

package/dist/types/utils/getSelectedEntries.d.ts

@@ -0,0 +1,5 @@
+import type { Entrypoint } from '@modern-js/types';
+/**
+ * Allow user to select entrypoints to build.
+ */
+export declare const getSelectedEntries: (entry: string[] | boolean, entrypoints: Entrypoint[]) => Promise<string[]>;