@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/dist/esm-node/native-type-checker.mjs

@@ -0,0 +1,100 @@
+import "node:module";
+import { execFile } from "node:child_process";
+import { realpathSync } from "node:fs";
+import node_path from "node:path";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+const native_type_checker_name = 'UltramodernNativeTypeChecker';
+const watchDependencyPath = (file)=>'win32' === process.platform ? realpathSync.native(file) : file;
+class UltramodernNativeTypeChecker {
+    async check() {
+        const { configFile, build } = this.options;
+        const args = build ? [
+            '--build',
+            configFile,
+            '--stopBuildOnErrors'
+        ] : [
+            '--project',
+            configFile,
+            '--noEmit'
+        ];
+        await this.run([
+            ...args,
+            '--pretty',
+            'false'
+        ]);
+    }
+    async run(args) {
+        try {
+            const result = await execute(this.options.compiler(), args, {
+                cwd: node_path.dirname(this.options.configFile),
+                maxBuffer: 16777216
+            });
+            return result.stdout;
+        } catch (cause) {
+            const output = cause;
+            const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`, {
+                cause
+            });
+        }
+    }
+    async watchInputs() {
+        const inputs = new Set();
+        const projects = [
+            this.options.configFile
+        ];
+        const visited = new Set();
+        for (const configFile of projects){
+            if (visited.has(configFile)) continue;
+            visited.add(configFile);
+            inputs.add(configFile);
+            const config = JSON.parse(await this.run([
+                '--showConfig',
+                '--project',
+                configFile
+            ]));
+            const directory = node_path.dirname(configFile);
+            for (const file of config.files ?? [])inputs.add(node_path.resolve(directory, file));
+            for (const reference of config.references ?? []){
+                const target = node_path.resolve(directory, reference.path);
+                projects.push('.json' === node_path.extname(target) ? target : node_path.join(target, 'tsconfig.json'));
+            }
+        }
+        return inputs;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
+            compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
+                try {
+                    compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
+                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(watchDependencyPath(file));
+                    await this.check();
+                } catch (cause) {
+                    compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {
+                        cause
+                    }));
+                }
+            });
+        });
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+function configureUltramodernTypeChecker(chain, pluginId, resolveCompiler) {
+    if (!chain.plugins.has(pluginId)) return;
+    const options = chain.plugin(pluginId).get('args')?.[0];
+    const typescript = options?.typescript;
+    if (typescript?.tsgo === false) return;
+    if (!typescript?.configFile) throw new Error(`${native_type_checker_name} requires the configured TypeScript project.`);
+    const configFile = node_path.resolve(typescript.configFile);
+    chain.plugin(pluginId).use(UltramodernNativeTypeChecker, [
+        {
+            build: true === typescript.build,
+            compiler: ()=>resolveCompiler(configFile),
+            configFile
+        }
+    ]);
+}
+export { UltramodernNativeTypeChecker, configureUltramodernTypeChecker };

package/dist/esm-node/release-envelope/framework-output.mjs

@@ -2,7 +2,7 @@ import "node:module";
 import { createHash } from "node:crypto";
 import promises from "node:fs/promises";
 import node_path from "node:path";
-import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, isUltramodernBuildArtifact } from "@modern-js/utils/universal";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, isUltramodernBuildArtifact } from "@modern-js/backend-federation-contracts";
 import { canonicalSerializeMicroVerticalReleaseEnvelope, createMicroVerticalReleaseEnvelope, verifyMicroVerticalReleaseEnvelope } from "./index.mjs";
 const MICROVERTICAL_RELEASE_ENVELOPE_PATH = 'release/microvertical-release-envelope.json';
 const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH = 'release/microvertical-release-identity-carriers.json';

package/dist/esm-node/release-envelope/plugin.mjs

@@ -11,7 +11,8 @@ const createUltramodernReleaseEnvelopePlugin = ({ resolveDeployTarget })=>({
         name: '@modern-js/ultramodern-release-envelope',
         pre: [
             '@modern-js/backend-federation-build',
-            '@modern-js/plugin-bff'
+            '@modern-js/plugin-bff',
+            '@modern-js/deploy-output-aliases'
         ],
         post: [
             '@modern-js/plugin-deploy'

package/dist/esm-node/release-identity.mjs

@@ -5,11 +5,8 @@ const BUILD_MARKER_NAMESPACE = 'ultramodern-delivery-unit-release-build-marker:v
 const PROMOTABLE_SOURCE_REVISION_PATTERN = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u;
 const gitOutput = (workspaceRoot, args)=>{
     try {
-        return execFileSync('git', [
-            '-C',
-            workspaceRoot,
-            ...args
-        ], {
+        return execFileSync('git', args, {
+            cwd: workspaceRoot,
             encoding: 'utf8',
             stdio: [
                 'ignore',
@@ -44,7 +41,7 @@ const resolveUltramodernSourceRevision = (workspaceRoot = process.cwd(), configu
     ]);
     const status = gitOutput(gitRoot, [
         'status',
-        '--porcelain=v1',
+        '--porcelain',
         '--untracked-files=all'
     ]);
     if (!revision || void 0 === status || status.length > 0) return 'workspace';

package/dist/types/backend-federation-build/codegen.d.ts

@@ -0,0 +1,86 @@
+import type { BackendFederationEntryIntegrity } from '@modern-js/server-runtime-extensions/backend-federation-security';
+import { type BackendFederationApp } from './config.js';
+export declare const createBackendRemoteEntrySource: (workspaceRoot: string, app: BackendFederationApp, effectApiPath: string, entryPath: string) => Promise<string>;
+export declare const createBackendManifest: (workspaceRoot: string, distDirectory: string, app: BackendFederationApp, entryIntegrity: BackendFederationEntryIntegrity) => {
+    schemaVersion: number;
+    id: string;
+    name: string;
+    version: string | undefined;
+    buildVersion: string | undefined;
+    metaData: {
+        name: string;
+        type: string;
+        buildInfo: {
+            buildVersion: string | undefined;
+            buildName: string | undefined;
+        };
+        remoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        globalName: string;
+        publicPath: string;
+        ssrRemoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        ssrPublicPath: string;
+    };
+    entry: {
+        byteLength: number;
+        sha256: string;
+        file: string;
+        path: string;
+        type: string;
+        url: string;
+    };
+    exposes: {
+        id: string;
+        name: string;
+        path: string;
+        assets: {
+            js: {
+                async: never[];
+                sync: string[];
+            };
+            css: {
+                async: never[];
+                sync: never[];
+            };
+        };
+    }[];
+    shared: never[];
+    backendFederation: {
+        role: string;
+        appId: string;
+        name: string;
+        runtimeFramework: string;
+        strictEffectApproach: boolean;
+        contractVersion: string;
+        nodeAdapterVersion: string;
+        remoteType: string;
+        expose: string;
+        manifestUrl: string;
+        containerEntry: string;
+        source: {
+            module: string;
+        };
+        readinessPath: string;
+        openapiPath: string;
+        deliveryUnit?: import("@modern-js/backend-federation-contracts").DeliveryUnitContractBlock | undefined;
+        versionBoundary: {
+            invariant: string;
+            packageName: string | undefined;
+            version: string | undefined;
+            buildVersion: string | undefined;
+            uiManifestUrl?: string | undefined;
+            deliveryUnit?: {
+                unitId: string;
+                buildMarker: string;
+                sourceRevision: string;
+            } | undefined;
+        };
+    };
+};

package/dist/types/backend-federation-build/config.d.ts

@@ -0,0 +1,103 @@
+import { type DeliveryUnitContractBlock, type UltramodernBuildArtifact } from '@modern-js/backend-federation-contracts';
+export declare const COMPACT_CONFIG_PATH = ".modernjs/ultramodern.json";
+export type CompactApp = {
+    id?: unknown;
+    kind?: unknown;
+    path?: unknown;
+    package?: unknown;
+    port?: unknown;
+    api?: {
+        prefix?: unknown;
+        stem?: unknown;
+    };
+    moduleFederation?: {
+        name?: unknown;
+        manifestUrl?: unknown;
+    };
+    backendFederation?: {
+        name?: unknown;
+        versionBoundary?: {
+            ui?: {
+                manifestUrl?: unknown;
+            };
+        };
+        executionSurfaces?: {
+            node?: {
+                remoteName?: unknown;
+                manifestUrl?: unknown;
+                containerEntry?: unknown;
+                remoteType?: unknown;
+            };
+        };
+    };
+    deliveryUnit?: {
+        unitId?: unknown;
+        buildMarker?: unknown;
+        sourceRevision?: unknown;
+        packageName?: unknown;
+        version?: unknown;
+    };
+    serverExecution?: {
+        node?: {
+            remoteName?: unknown;
+            manifestUrl?: unknown;
+            containerEntry?: unknown;
+            remoteType?: unknown;
+        };
+    };
+};
+export type CompactConfig = {
+    topology?: {
+        apps?: CompactApp[];
+    };
+};
+export type BackendFederationApp = {
+    id: string;
+    directory: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    deliveryUnit?: DeliveryUnitContractBlock;
+    port: number;
+    apiPrefix: string;
+    apiStem: string;
+    backendName: string;
+    manifestUrl: string;
+    containerEntry: string;
+    remoteType: string;
+    uiManifestUrl?: string;
+    compactDeliveryUnit?: {
+        unitId?: string;
+        buildMarker?: string;
+        sourceRevision?: string;
+        packageName?: string;
+        version?: string;
+    };
+};
+export type BackendFederationBuildIdentity = {
+    appId?: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    artifact?: UltramodernBuildArtifact;
+};
+export declare const normalizeRelativePath: (value: string) => string;
+export declare const buildArtifactPathFor: (appDirectory: string) => string;
+export declare const buildModulePathFor: (appDirectory: string) => string;
+export declare const readBuildIdentity: (appDirectory: string) => Promise<BackendFederationBuildIdentity>;
+export declare const findWorkspaceRoot: (appDirectory: string) => string | undefined;
+export declare const resolveWorkspaceSourceRevision: (workspaceRoot: string) => Promise<string>;
+export declare const createStampedDeliveryUnit: (input: {
+    appId: string;
+    unitId?: string;
+    buildMarker?: string;
+    packageName?: string;
+    version?: string;
+    sourceRevision: string;
+}) => DeliveryUnitContractBlock | undefined;
+export declare const createAppFromCompactMetadata: (workspaceRoot: string, appDirectory: string, compactApp: CompactApp) => BackendFederationApp | undefined;
+export declare const findBackendFederationApp: (workspaceRoot: string, appDirectory: string) => Promise<BackendFederationApp | undefined>;

package/dist/types/backend-federation-build/emit.d.ts

@@ -0,0 +1,21 @@
+export type { BackendFederationBuildIdentity } from './config.js';
+export type BackendFederationArtifactResult = {
+    appId: string;
+    manifestPath: string;
+    containerPath: string;
+    deliveryUnitArtifactPath?: string;
+    remoteName: string;
+    remoteType: string;
+};
+export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string) => Promise<BackendFederationArtifactResult | undefined>;
+export default _default;
+declare function _default(): {
+    name: string;
+    setup(api: {
+        getAppContext(): {
+            appDirectory: string;
+            distDirectory: string;
+        };
+        onAfterBuild(handler: () => Promise<void>): void;
+    }): void;
+};

package/dist/types/backend-federation-build/index.d.ts

@@ -0,0 +1,2 @@
+export type { BackendFederationArtifactResult } from './emit.js';
+export { default, emitBackendFederationArtifacts } from './emit.js';

package/dist/types/build-config/build-environment.d.ts

@@ -0,0 +1,22 @@
+import type { URL } from 'node:url';
+import type { Rspack } from '@rsbuild/core';
+/**
+ * Reads an environment variable while keeping generated build configs free of
+ * direct process access.
+ */
+export declare function getBuildConfigEnvironment(name: string): string | undefined;
+/**
+ * Runs a Rspack config setup under a leased environment value. The lease is
+ * restored when that compiler reaches any supported terminal hook.
+ */
+export declare function withBuildConfigEnvironment<Config extends {
+    plugins?: Rspack.Plugin[];
+}, SetupArguments extends unknown[]>(name: string, value: string, setup: (config: Config, ...args: SetupArguments) => Config | void | Promise<Config | void>): (config: Config, ...args: SetupArguments) => Promise<Config>;
+export type ResolveEffectTsgoCompilerOptions = {
+    /** Module URL or absolute filename used to resolve the consumer's compiler. */
+    from: string | URL;
+};
+/**
+ * Resolves the Effect TS-Go executable used by Module Federation DTS builds.
+ */
+export declare function resolveEffectTsgoCompiler(options: ResolveEffectTsgoCompilerOptions): string;

package/dist/types/build-config/precompress/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { PrecompressConfig } from './types.js';
+export type { PrecompressCodecOptions, PrecompressConfig } from './types.js';
+export declare const builderPluginAdapterPrecompress: (precompress: boolean | PrecompressConfig | undefined) => RsbuildPlugin;

package/dist/types/build-config/precompress/types.d.ts

@@ -0,0 +1,19 @@
+import type { CompressionPluginOptions } from '../../precompress/index.js';
+export type PrecompressCodecOptions = boolean | Partial<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 {};

package/dist/types/build-config/public.d.ts

@@ -0,0 +1,2 @@
+export type { ResolveEffectTsgoCompilerOptions } from './build-environment.js';
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment, } from './build-environment.js';

package/dist/types/cloudflare/constants.d.ts

@@ -16,7 +16,7 @@ export declare const SERVER_OUTPUT_DIRECTORY = "server";
 export declare const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES: readonly ['api', 'shared'];
 export declare const BFF_EFFECT_WORKER_ENTRY = "worker/__modern_bff_effect.js";
 export declare const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = "__modern_create_effect_bff_dispatcher";
-export declare const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = "Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.";
+export declare const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = "Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/bff-effect/effect-edge instead of lambda/Hono server helpers.";
 export declare const DEFAULT_COMPATIBILITY_DATE = "2026-06-02";
 export declare const COMPATIBILITY_DATE_PATTERN: RegExp;
 export declare const REQUIRED_COMPATIBILITY_FLAGS: readonly ["nodejs_compat", "global_fetch_strictly_public"];

package/dist/types/cloudflare/delivery-unit.d.ts

@@ -1,4 +1,4 @@
-import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import { type DeliveryUnitIdentity } from '@modern-js/backend-federation-contracts';
 export type DeliveryUnitStamp = DeliveryUnitIdentity & {
     surfaces: {
         ui?: DeliveryUnitIdentity & {

package/dist/types/cloudflare/worker-manifest.d.ts

@@ -108,8 +108,8 @@ export declare const createWorkerManifest: (outputDirectory: string, modernConfi
         prefix: string;
         worker: string;
         effect: {
-            openapi?: import("@modern-js/server-core").BffEffectOpenApiUserConfig | undefined;
-            dataPlatform?: import("@modern-js/server-core").BffEffectDataPlatformUserConfig | undefined;
+            openapi?: import("@modern-js/runtime-extensions/server-config").BffEffectOpenApiUserConfig | undefined;
+            dataPlatform?: import("@modern-js/runtime-extensions/server-config").BffEffectDataPlatformUserConfig | undefined;
             crossProjectPolicy: {
                 allowedNamespaces?: string[];
                 verifyProducerIdentity?: (headers: Record<string, unknown>) => string | undefined;

package/dist/types/cloudflare-output-contract.d.ts

@@ -10,5 +10,6 @@ export declare const CLOUDFLARE_RUNTIME_TYPE = "cloudflare-module-worker";
 export declare const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = "module";
 export declare const CLOUDFLARE_WORKER_PACKAGE_TYPE = "commonjs";
 export declare const CLOUDFLARE_WORKER_BUNDLE_FORMAT = "commonjs";
-export declare const CLOUDFLARE_WORKER_NODE_BUILTINS: readonly ['async_hooks', 'buffer', 'crypto', 'events', 'fs/promises', 'module', 'path', 'process', 'stream', 'string_decoder', 'url', 'util'];
+export declare const CLOUDFLARE_WORKER_NODE_BUILTINS: readonly ['assert', 'assert/strict', 'async_hooks', 'buffer', 'child_process', 'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'fs/promises', 'http', 'http2', 'inspector', 'module', 'net', 'os', 'path', 'process', 'readline', 'readline/promises', 'repl', 'sqlite', 'stream', 'stream/consumers', 'stream/promises', 'stream/web', 'string_decoder', 'timers', 'timers/promises', 'tls', 'trace_events', 'tty', 'url', 'util', 'util/types', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib'];
+export declare const CLOUDFLARE_WORKER_PLATFORM_MODULES: readonly ['cloudflare:sockets'];
 export declare const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS: readonly ['nodejs_compat', 'global_fetch_strictly_public'];

package/dist/types/cloudflare-output-verifier/identity.d.ts

@@ -1,4 +1,4 @@
-import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import { type DeliveryUnitIdentity } from '@modern-js/backend-federation-contracts';
 import type { CloudflareOutputVerifierIssue, JsonObject } from './issues.js';
 export type CloudflareDeliveryUnitIdentity = DeliveryUnitIdentity & {
     surfaces?: Partial<Record<'api' | 'ui', DeliveryUnitIdentity & {

package/dist/types/config.d.ts

@@ -1,3 +1,5 @@
+export type { ResolveEffectTsgoCompilerOptions } from './build-config/public.js';
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment, } from './build-config/public.js';
 export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
 export type CloudflareWorkerSecurityCspMode = 'enforce' | 'report-only' | 'off';
 export type JsonValue = string | number | boolean | null | JsonValue[] | {

package/dist/types/deploy-output/npmAliases.d.ts

@@ -0,0 +1,14 @@
+export type NpmAlias = {
+    aliasName: string;
+    targetName: string;
+    targetVersion: string;
+};
+export declare function readPackageIdentity(entryPath: string): Promise<{
+    name: string;
+    version: string;
+}>;
+export declare function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases, }: {
+    appDirectory: string;
+    outputDirectory: string;
+    implicitAliases?: NpmAlias[];
+}): Promise<void>;

package/dist/types/deploy-output/plugin.d.ts

@@ -0,0 +1,15 @@
+import { type DeployOutputConfig } from './target.js';
+export interface DeployOutputPluginApi {
+    getAppContext(): {
+        appDirectory: string;
+        metaName: string;
+    };
+    getNormalizedConfig(): DeployOutputConfig;
+    onAfterDeploy(handler: () => Promise<void>): void;
+}
+export declare const createDeployOutputAliasesPlugin: ({ resolveDeployTarget, }?: {
+    resolveDeployTarget?: (config: DeployOutputConfig) => string;
+}) => {
+    name: string;
+    setup(api: DeployOutputPluginApi): void;
+};

package/dist/types/deploy-output/target.d.ts

@@ -0,0 +1,6 @@
+export interface DeployOutputConfig {
+    deploy?: {
+        target?: string;
+    };
+}
+export declare const resolveDeployTarget: (config: DeployOutputConfig, envDeployTarget?: string | undefined, detectedProvider?: import("std-env").ProviderName) => string;

package/dist/types/native-type-checker.d.ts

@@ -0,0 +1,15 @@
+import type { Rspack, RspackChain } from '@rsbuild/core';
+export declare class UltramodernNativeTypeChecker {
+    private readonly options;
+    constructor(options: {
+        compiler: () => string;
+        configFile: string;
+        build: boolean;
+    });
+    check(): Promise<void>;
+    private run;
+    private watchInputs;
+    apply(compiler: Rspack.Compiler): void;
+}
+/** Preserve project-reference emit contracts in the native Effect compiler. */
+export declare function configureUltramodernTypeChecker(chain: RspackChain, pluginId: string, resolveCompiler: (configFile: string) => string): void;

package/dist/types/precompress/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

@@ -0,0 +1,76 @@
+type BasePluginOptions<T> = {
+  /**
+   * include all assets that pass test assertion
+   */
+  test?: Rules | undefined;
+  /**
+   * include all assets matching any of these conditions
+   */
+  include?: Rules | undefined;
+  /**
+   * exclude all assets matching any of these conditions
+   */
+  exclude?: Rules | undefined;
+  /**
+   * only assets bigger than this size are processed, in bytes
+   */
+  threshold?: number | undefined;
+  /**
+   * only assets that compress better than this ratio are processed (`minRatio = Compressed Size / Original Size`)
+   */
+  minRatio?: number | undefined;
+  /**
+   * whether to delete the original assets or not
+   */
+  deleteOriginalAssets?: DeleteOriginalAssets | undefined;
+  /**
+   * the target asset filename
+   */
+  filename?: Filename | undefined;
+};
+type Rules = Rule[] | Rule;
+type Rule = RegExp | string;
+type DeleteOriginalAssets =
+  | boolean
+  | "keep-source-map"
+  | ((name: string) => boolean);
+type Filename = string | ((fileData: PathData) => string);
+type PathData = import('@rsbuild/core').Rspack.PathData;
+type DefinedDefaultAlgorithmAndOptions<T> = T extends ZlibOptions
+  ? {
+      algorithm?: string | AlgorithmFunction<T> | undefined;
+      compressionOptions?: CompressionOptions<T> | undefined;
+    }
+  : {
+      algorithm: string | AlgorithmFunction<T>;
+      compressionOptions?: CompressionOptions<T> | undefined;
+    };
+type ZlibOptions = import("zlib").ZlibOptions;
+type AlgorithmFunction<T> = (
+  input: Buffer,
+  options: CompressionOptions<T>,
+  callback: (
+    error: Error | null | undefined,
+    result:
+      | WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>
+      | Uint8Array
+      | ReadonlyArray<number>
+      | WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>
+      | WithImplicitCoercion<string>
+      | {
+          [Symbol.toPrimitive](hint: "string"): string;
+        },
+  ) => void,
+) => any;
+type CompressionOptions<T> = InferDefaultType<T>;
+type InferDefaultType<T> = T extends infer U ? U : CustomOptions;
+type CustomOptions = {
+  [key: string]: EXPECTED_ANY;
+};
+type EXPECTED_ANY = any;
+type WithImplicitCoercion<T> =
+  | T
+  | {
+      valueOf(): T;
+    };
+export type CompressionPluginOptions = BasePluginOptions<ZlibOptions> & DefinedDefaultAlgorithmAndOptions<ZlibOptions>;