@rspack-debug/core 1.3.14

package/dist/config/normalization.d.ts

@@ -0,0 +1,148 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/normalization.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compilation } from "../Compilation";
+import type { HttpUriPluginOptions } from "../builtin-plugin";
+import type { Amd, AssetModuleFilename, Bail, CacheOptions, ChunkFilename, ChunkLoading, ChunkLoadingGlobal, Clean, Context, CrossOriginLoading, CssChunkFilename, CssFilename, Dependencies, DevServer, DevTool, DevtoolFallbackModuleFilenameTemplate, DevtoolModuleFilenameTemplate, DevtoolNamespace, EnabledLibraryTypes, EnabledWasmLoadingTypes, EntryDescription, Environment, Externals, ExternalsPresets, ExternalsType, Filename, GeneratorOptionsByModuleType, GlobalObject, HashDigest, HashDigestLength, HashFunction, HashSalt, HotUpdateChunkFilename, HotUpdateGlobal, HotUpdateMainFilename, Iife, ImportFunctionName, ImportMetaName, Incremental, InfrastructureLogging, LazyCompilationOptions, LibraryOptions, Loader, Mode, Name, NoParseOption, Node, Optimization, OutputModule, ParserOptionsByModuleType, Path, Performance, Plugins, Profile, PublicPath, Resolve, RspackFutureOptions, RspackOptions, RuleSetRules, ScriptType, SnapshotOptions, SourceMapFilename, StatsValue, StrictModuleErrorHandling, Target, TrustedTypes, UniqueName, WasmLoading, Watch, WatchOptions, WebassemblyModuleFilename, WorkerPublicPath } from "./types";
+export declare const getNormalizedRspackOptions: (config: RspackOptions) => RspackOptionsNormalized;
+export type EntryDynamicNormalized = () => Promise<EntryStaticNormalized>;
+export type EntryNormalized = EntryDynamicNormalized | EntryStaticNormalized;
+export interface EntryStaticNormalized {
+    [k: string]: EntryDescriptionNormalized;
+}
+export type EntryDescriptionNormalized = Pick<EntryDescription, "runtime" | "chunkLoading" | "asyncChunks" | "publicPath" | "baseUri" | "filename" | "library" | "layer"> & {
+    import?: string[];
+    dependOn?: string[];
+};
+export interface OutputNormalized {
+    path?: Path;
+    pathinfo?: boolean | "verbose";
+    clean?: Clean;
+    publicPath?: PublicPath;
+    filename?: Filename;
+    chunkFilename?: ChunkFilename;
+    crossOriginLoading?: CrossOriginLoading;
+    cssFilename?: CssFilename;
+    cssChunkFilename?: CssChunkFilename;
+    hotUpdateMainFilename?: HotUpdateMainFilename;
+    hotUpdateChunkFilename?: HotUpdateChunkFilename;
+    hotUpdateGlobal?: HotUpdateGlobal;
+    assetModuleFilename?: AssetModuleFilename;
+    uniqueName?: UniqueName;
+    chunkLoadingGlobal?: ChunkLoadingGlobal;
+    enabledLibraryTypes?: EnabledLibraryTypes;
+    library?: LibraryOptions;
+    module?: OutputModule;
+    strictModuleErrorHandling?: StrictModuleErrorHandling;
+    globalObject?: GlobalObject;
+    importFunctionName?: ImportFunctionName;
+    importMetaName?: ImportMetaName;
+    iife?: Iife;
+    wasmLoading?: WasmLoading;
+    enabledWasmLoadingTypes?: EnabledWasmLoadingTypes;
+    webassemblyModuleFilename?: WebassemblyModuleFilename;
+    chunkFormat?: string | false;
+    chunkLoading?: string | false;
+    enabledChunkLoadingTypes?: string[];
+    trustedTypes?: TrustedTypes;
+    sourceMapFilename?: SourceMapFilename;
+    hashDigest?: HashDigest;
+    hashDigestLength?: HashDigestLength;
+    hashFunction?: HashFunction;
+    hashSalt?: HashSalt;
+    asyncChunks?: boolean;
+    workerChunkLoading?: ChunkLoading;
+    workerWasmLoading?: WasmLoading;
+    workerPublicPath?: WorkerPublicPath;
+    scriptType?: ScriptType;
+    devtoolNamespace?: DevtoolNamespace;
+    devtoolModuleFilenameTemplate?: DevtoolModuleFilenameTemplate;
+    devtoolFallbackModuleFilenameTemplate?: DevtoolFallbackModuleFilenameTemplate;
+    environment?: Environment;
+    charset?: boolean;
+    chunkLoadTimeout?: number;
+    compareBeforeEmit?: boolean;
+}
+export interface ModuleOptionsNormalized {
+    defaultRules?: RuleSetRules;
+    rules: RuleSetRules;
+    parser: ParserOptionsByModuleType;
+    generator: GeneratorOptionsByModuleType;
+    noParse?: NoParseOption;
+}
+export type ExperimentCacheNormalized = boolean | {
+    type: "memory";
+} | {
+    type: "persistent";
+    buildDependencies: string[];
+    version: string;
+    snapshot: {
+        immutablePaths: Array<string | RegExp>;
+        unmanagedPaths: Array<string | RegExp>;
+        managedPaths: Array<string | RegExp>;
+    };
+    storage: {
+        type: "filesystem";
+        directory: string;
+    };
+};
+export interface ExperimentsNormalized {
+    cache?: ExperimentCacheNormalized;
+    lazyCompilation?: false | LazyCompilationOptions;
+    asyncWebAssembly?: boolean;
+    outputModule?: boolean;
+    topLevelAwait?: boolean;
+    css?: boolean;
+    layers?: boolean;
+    incremental?: false | Incremental;
+    parallelCodeSplitting?: boolean;
+    futureDefaults?: boolean;
+    rspackFuture?: RspackFutureOptions;
+    buildHttp?: HttpUriPluginOptions;
+    parallelLoader?: boolean;
+}
+export type IgnoreWarningsNormalized = ((warning: Error, compilation: Compilation) => boolean)[];
+export type OptimizationRuntimeChunkNormalized = false | {
+    name: string | ((entrypoint: {
+        name: string;
+    }) => string);
+};
+export interface RspackOptionsNormalized {
+    name?: Name;
+    dependencies?: Dependencies;
+    context?: Context;
+    mode?: Mode;
+    entry: EntryNormalized;
+    output: OutputNormalized;
+    resolve: Resolve;
+    resolveLoader: Resolve;
+    module: ModuleOptionsNormalized;
+    target?: Target;
+    externals?: Externals;
+    externalsType?: ExternalsType;
+    externalsPresets: ExternalsPresets;
+    infrastructureLogging: InfrastructureLogging;
+    devtool?: DevTool;
+    node: Node;
+    loader: Loader;
+    snapshot: SnapshotOptions;
+    cache?: CacheOptions;
+    stats: StatsValue;
+    optimization: Optimization;
+    plugins: Plugins;
+    experiments: ExperimentsNormalized;
+    watch?: Watch;
+    watchOptions: WatchOptions;
+    devServer?: DevServer;
+    ignoreWarnings?: IgnoreWarningsNormalized;
+    performance?: Performance;
+    profile?: Profile;
+    amd?: Amd;
+    bail?: Bail;
+}

package/dist/config/target.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @param context the context directory
+ * @returns default target
+ */
+export declare const getDefaultTarget: (context: string) => "browserslist" | "web";
+export type PlatformTargetProperties = {
+    /** web platform, importing of http(s) and std: is available */
+    web: boolean | null;
+    /** browser platform, running in a normal web browser */
+    browser: boolean | null;
+    /** (Web)Worker platform, running in a web/shared/service worker */
+    webworker: boolean | null;
+    /** node platform, require of node built-in modules is available */
+    node: boolean | null;
+    /** nwjs platform, require of legacy nw.gui is available */
+    nwjs: boolean | null;
+    /** electron platform, require of some electron built-in modules is available */
+    electron: boolean | null;
+};
+export type ElectronContextTargetProperties = {
+    /**  in main context */
+    electronMain: boolean | null;
+    /**  in preload context */
+    electronPreload: boolean | null;
+    /**  in renderer context with node integration */
+    electronRenderer: boolean | null;
+};
+export type ApiTargetProperties = {
+    /**  has require function available */
+    require: boolean | null;
+    /**  has node.js built-in modules available */
+    nodeBuiltins: boolean | null;
+    /**  node.js allows to use `node:` prefix for core modules */
+    nodePrefixForCoreModules: boolean | null;
+    /**  has document available (allows script tags) */
+    document: boolean | null;
+    /**  has importScripts available */
+    importScripts: boolean | null;
+    /**  has importScripts available when creating a worker */
+    importScriptsInWorker: boolean | null;
+    /**  has fetch function available for WebAssembly */
+    fetchWasm: boolean | null;
+    /**  has global variable available */
+    global: boolean | null;
+};
+export type EcmaTargetProperties = {
+    /**  has globalThis variable available */
+    globalThis: boolean | null;
+    /**  big int literal syntax is available */
+    bigIntLiteral: boolean | null;
+    /**  const and let variable declarations are available */
+    const: boolean | null;
+    /**  arrow functions are available */
+    arrowFunction: boolean | null;
+    /**  for of iteration is available */
+    forOf: boolean | null;
+    /**  destructuring is available */
+    destructuring: boolean | null;
+    /**  async import() is available */
+    dynamicImport: boolean | null;
+    /**  async import() is available when creating a worker */
+    dynamicImportInWorker: boolean | null;
+    /**  ESM syntax is available (when in module) */
+    module: boolean | null;
+    /**  optional chaining is available */
+    optionalChaining: boolean | null;
+    /**  template literal is available */
+    templateLiteral: boolean | null;
+    /**  async functions and await are available */
+    asyncFunction: boolean | null;
+};
+type Never<T> = {
+    [P in keyof T]?: never;
+};
+type Mix<A, B> = (A & Never<B>) | (Never<A> & B) | (A & B);
+type TargetProperties = Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>;
+/**
+ * @param target the target
+ * @param context the context directory
+ * @returns target properties
+ */
+export declare const getTargetProperties: (target: string, context: string) => TargetProperties;
+/**
+ * @param targets the targets
+ * @param context the context directory
+ * @returns target properties
+ */
+export declare const getTargetsProperties: (targets: string[], context: string) => TargetProperties;
+export {};