forked from FINAKON/HelpProject
Bhargava
6063bd1724
1. Initial Commit - a boiler plate code and POC to realize the concept of context
sensitive help
2. Frontend code written in ReactJS
3. Backend code written in Java, Spring Boot Framework
4. Frontend Start:
pre-requisites : node, npm
npm run dev ==> to start the frontend vite server
5. Backend Start:
pre-requisites : java, mvn
mvn spring-boot:run ==> to start the backend server
6. Visit http://localhost:5173/ for basic demo of help, press F1 in textboxes
7. Visit http://localhost:5173/editor and enter "admin123" to add/modify texts.
Happy Coding !!!
Thank you,
Bhargava.
1182 lines
32 KiB
TypeScript
1182 lines
32 KiB
TypeScript
import type * as estree from 'estree';
|
|
|
|
declare module 'estree' {
|
|
export interface Decorator extends estree.BaseNode {
|
|
type: 'Decorator';
|
|
expression: estree.Expression;
|
|
}
|
|
interface PropertyDefinition {
|
|
decorators: estree.Decorator[];
|
|
}
|
|
interface MethodDefinition {
|
|
decorators: estree.Decorator[];
|
|
}
|
|
interface BaseClass {
|
|
decorators: estree.Decorator[];
|
|
}
|
|
}
|
|
|
|
export const VERSION: string;
|
|
|
|
// utils
|
|
type NullValue = null | undefined | void;
|
|
type MaybeArray<T> = T | T[];
|
|
type MaybePromise<T> = T | Promise<T>;
|
|
|
|
type PartialNull<T> = {
|
|
[P in keyof T]: T[P] | null;
|
|
};
|
|
|
|
export interface RollupError extends RollupLog {
|
|
name?: string;
|
|
stack?: string;
|
|
watchFiles?: string[];
|
|
}
|
|
|
|
export interface RollupLog {
|
|
binding?: string;
|
|
cause?: unknown;
|
|
code?: string;
|
|
exporter?: string;
|
|
frame?: string;
|
|
hook?: string;
|
|
id?: string;
|
|
ids?: string[];
|
|
loc?: {
|
|
column: number;
|
|
file?: string;
|
|
line: number;
|
|
};
|
|
message: string;
|
|
meta?: any;
|
|
names?: string[];
|
|
plugin?: string;
|
|
pluginCode?: unknown;
|
|
pos?: number;
|
|
reexporter?: string;
|
|
stack?: string;
|
|
url?: string;
|
|
}
|
|
|
|
export type LogLevel = 'warn' | 'info' | 'debug';
|
|
export type LogLevelOption = LogLevel | 'silent';
|
|
|
|
export type SourceMapSegment =
|
|
| [number]
|
|
| [number, number, number, number]
|
|
| [number, number, number, number, number];
|
|
|
|
export interface ExistingDecodedSourceMap {
|
|
file?: string;
|
|
readonly mappings: SourceMapSegment[][];
|
|
names: string[];
|
|
sourceRoot?: string;
|
|
sources: string[];
|
|
sourcesContent?: string[];
|
|
version: number;
|
|
x_google_ignoreList?: number[];
|
|
}
|
|
|
|
export interface ExistingRawSourceMap {
|
|
file?: string;
|
|
mappings: string;
|
|
names: string[];
|
|
sourceRoot?: string;
|
|
sources: string[];
|
|
sourcesContent?: string[];
|
|
version: number;
|
|
x_google_ignoreList?: number[];
|
|
}
|
|
|
|
export type DecodedSourceMapOrMissing =
|
|
| {
|
|
missing: true;
|
|
plugin: string;
|
|
}
|
|
| (ExistingDecodedSourceMap & { missing?: false });
|
|
|
|
export interface SourceMap {
|
|
file: string;
|
|
mappings: string;
|
|
names: string[];
|
|
sources: string[];
|
|
sourcesContent?: string[];
|
|
version: number;
|
|
debugId?: string;
|
|
toString(): string;
|
|
toUrl(): string;
|
|
}
|
|
|
|
export type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' };
|
|
|
|
interface ModuleOptions {
|
|
attributes: Record<string, string>;
|
|
meta: CustomPluginOptions;
|
|
moduleSideEffects: boolean | 'no-treeshake';
|
|
syntheticNamedExports: boolean | string;
|
|
}
|
|
|
|
export interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
|
|
ast?: ProgramNode;
|
|
code: string;
|
|
map?: SourceMapInput;
|
|
}
|
|
|
|
export interface TransformModuleJSON {
|
|
ast?: ProgramNode;
|
|
code: string;
|
|
// note if plugins use new this.cache to opt-out auto transform cache
|
|
customTransformCache: boolean;
|
|
originalCode: string;
|
|
originalSourcemap: ExistingDecodedSourceMap | null;
|
|
sourcemapChain: DecodedSourceMapOrMissing[];
|
|
transformDependencies: string[];
|
|
}
|
|
|
|
export interface ModuleJSON extends TransformModuleJSON, ModuleOptions {
|
|
ast: ProgramNode;
|
|
dependencies: string[];
|
|
id: string;
|
|
resolvedIds: ResolvedIdMap;
|
|
transformFiles: EmittedFile[] | undefined;
|
|
}
|
|
|
|
export interface PluginCache {
|
|
delete(id: string): boolean;
|
|
get<T = any>(id: string): T;
|
|
has(id: string): boolean;
|
|
set<T = any>(id: string, value: T): void;
|
|
}
|
|
|
|
export type LoggingFunction = (log: RollupLog | string | (() => RollupLog | string)) => void;
|
|
|
|
export interface MinimalPluginContext {
|
|
debug: LoggingFunction;
|
|
error: (error: RollupError | string) => never;
|
|
info: LoggingFunction;
|
|
meta: PluginContextMeta;
|
|
warn: LoggingFunction;
|
|
}
|
|
|
|
export interface EmittedAsset {
|
|
fileName?: string;
|
|
name?: string;
|
|
needsCodeReference?: boolean;
|
|
originalFileName?: string | null;
|
|
source?: string | Uint8Array;
|
|
type: 'asset';
|
|
}
|
|
|
|
export interface EmittedChunk {
|
|
fileName?: string;
|
|
id: string;
|
|
implicitlyLoadedAfterOneOf?: string[];
|
|
importer?: string;
|
|
name?: string;
|
|
preserveSignature?: PreserveEntrySignaturesOption;
|
|
type: 'chunk';
|
|
}
|
|
|
|
export interface EmittedPrebuiltChunk {
|
|
code: string;
|
|
exports?: string[];
|
|
fileName: string;
|
|
map?: SourceMap;
|
|
sourcemapFileName?: string;
|
|
type: 'prebuilt-chunk';
|
|
}
|
|
|
|
export type EmittedFile = EmittedAsset | EmittedChunk | EmittedPrebuiltChunk;
|
|
|
|
export type EmitFile = (emittedFile: EmittedFile) => string;
|
|
|
|
export interface ModuleInfo extends ModuleOptions {
|
|
ast: ProgramNode | null;
|
|
code: string | null;
|
|
dynamicImporters: readonly string[];
|
|
dynamicallyImportedIdResolutions: readonly ResolvedId[];
|
|
dynamicallyImportedIds: readonly string[];
|
|
exportedBindings: Record<string, string[]> | null;
|
|
exports: string[] | null;
|
|
hasDefaultExport: boolean | null;
|
|
id: string;
|
|
implicitlyLoadedAfterOneOf: readonly string[];
|
|
implicitlyLoadedBefore: readonly string[];
|
|
importedIdResolutions: readonly ResolvedId[];
|
|
importedIds: readonly string[];
|
|
importers: readonly string[];
|
|
isEntry: boolean;
|
|
isExternal: boolean;
|
|
isIncluded: boolean | null;
|
|
}
|
|
|
|
export type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
|
|
|
|
// eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style -- this is an interface so that it can be extended by plugins
|
|
export interface CustomPluginOptions {
|
|
[plugin: string]: any;
|
|
}
|
|
|
|
type LoggingFunctionWithPosition = (
|
|
log: RollupLog | string | (() => RollupLog | string),
|
|
pos?: number | { column: number; line: number }
|
|
) => void;
|
|
|
|
export type ParseAst = (
|
|
input: string,
|
|
options?: { allowReturnOutsideFunction?: boolean; jsx?: boolean }
|
|
) => ProgramNode;
|
|
|
|
// declare AbortSignal here for environments without DOM lib or @types/node
|
|
declare global {
|
|
// eslint-disable-next-line @typescript-eslint/no-empty-object-type
|
|
interface AbortSignal {}
|
|
}
|
|
|
|
export type ParseAstAsync = (
|
|
input: string,
|
|
options?: { allowReturnOutsideFunction?: boolean; jsx?: boolean; signal?: AbortSignal }
|
|
) => Promise<ProgramNode>;
|
|
|
|
export interface PluginContext extends MinimalPluginContext {
|
|
addWatchFile: (id: string) => void;
|
|
cache: PluginCache;
|
|
debug: LoggingFunction;
|
|
emitFile: EmitFile;
|
|
error: (error: RollupError | string) => never;
|
|
fs: RollupFsModule;
|
|
getFileName: (fileReferenceId: string) => string;
|
|
getModuleIds: () => IterableIterator<string>;
|
|
getModuleInfo: GetModuleInfo;
|
|
getWatchFiles: () => string[];
|
|
info: LoggingFunction;
|
|
load: (
|
|
options: { id: string; resolveDependencies?: boolean } & Partial<PartialNull<ModuleOptions>>
|
|
) => Promise<ModuleInfo>;
|
|
parse: ParseAst;
|
|
resolve: (
|
|
source: string,
|
|
importer?: string,
|
|
options?: {
|
|
attributes?: Record<string, string>;
|
|
custom?: CustomPluginOptions;
|
|
isEntry?: boolean;
|
|
skipSelf?: boolean;
|
|
}
|
|
) => Promise<ResolvedId | null>;
|
|
setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void;
|
|
warn: LoggingFunction;
|
|
}
|
|
|
|
export interface PluginContextMeta {
|
|
rollupVersion: string;
|
|
watchMode: boolean;
|
|
}
|
|
|
|
export type StringOrRegExp = string | RegExp;
|
|
|
|
export type StringFilter<Value = StringOrRegExp> =
|
|
| MaybeArray<Value>
|
|
| {
|
|
include?: MaybeArray<Value>;
|
|
exclude?: MaybeArray<Value>;
|
|
};
|
|
|
|
export interface HookFilter {
|
|
id?: StringFilter;
|
|
code?: StringFilter;
|
|
}
|
|
|
|
export interface ResolvedId extends ModuleOptions {
|
|
external: boolean | 'absolute';
|
|
id: string;
|
|
resolvedBy: string;
|
|
}
|
|
|
|
export type ResolvedIdMap = Record<string, ResolvedId>;
|
|
|
|
export interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
|
|
external?: boolean | 'absolute' | 'relative';
|
|
id: string;
|
|
resolvedBy?: string;
|
|
}
|
|
|
|
export type ResolveIdResult = string | NullValue | false | PartialResolvedId;
|
|
|
|
export type ResolveIdResultWithoutNullValue = string | false | PartialResolvedId;
|
|
|
|
export type ResolveIdHook = (
|
|
this: PluginContext,
|
|
source: string,
|
|
importer: string | undefined,
|
|
options: { attributes: Record<string, string>; custom?: CustomPluginOptions; isEntry: boolean }
|
|
) => ResolveIdResult;
|
|
|
|
export type ShouldTransformCachedModuleHook = (
|
|
this: PluginContext,
|
|
options: {
|
|
ast: ProgramNode;
|
|
code: string;
|
|
id: string;
|
|
meta: CustomPluginOptions;
|
|
moduleSideEffects: boolean | 'no-treeshake';
|
|
resolvedSources: ResolvedIdMap;
|
|
syntheticNamedExports: boolean | string;
|
|
}
|
|
) => boolean | NullValue;
|
|
|
|
export type IsExternal = (
|
|
source: string,
|
|
importer: string | undefined,
|
|
isResolved: boolean
|
|
) => boolean;
|
|
|
|
export type HasModuleSideEffects = (id: string, external: boolean) => boolean;
|
|
|
|
export type LoadResult = SourceDescription | string | NullValue;
|
|
|
|
export type LoadHook = (this: PluginContext, id: string) => LoadResult;
|
|
|
|
export interface TransformPluginContext extends PluginContext {
|
|
debug: LoggingFunctionWithPosition;
|
|
error: (error: RollupError | string, pos?: number | { column: number; line: number }) => never;
|
|
getCombinedSourcemap: () => SourceMap;
|
|
info: LoggingFunctionWithPosition;
|
|
warn: LoggingFunctionWithPosition;
|
|
}
|
|
|
|
export type TransformResult = string | NullValue | Partial<SourceDescription>;
|
|
|
|
export type TransformHook = (
|
|
this: TransformPluginContext,
|
|
code: string,
|
|
id: string
|
|
) => TransformResult;
|
|
|
|
export type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => void;
|
|
|
|
export type RenderChunkHook = (
|
|
this: PluginContext,
|
|
code: string,
|
|
chunk: RenderedChunk,
|
|
options: NormalizedOutputOptions,
|
|
meta: { chunks: Record<string, RenderedChunk> }
|
|
) => { code: string; map?: SourceMapInput } | string | NullValue;
|
|
|
|
export type ResolveDynamicImportHook = (
|
|
this: PluginContext,
|
|
specifier: string | AstNode,
|
|
importer: string,
|
|
options: { attributes: Record<string, string> }
|
|
) => ResolveIdResult;
|
|
|
|
export type ResolveImportMetaHook = (
|
|
this: PluginContext,
|
|
property: string | null,
|
|
options: { chunkId: string; format: InternalModuleFormat; moduleId: string }
|
|
) => string | NullValue;
|
|
|
|
export type ResolveFileUrlHook = (
|
|
this: PluginContext,
|
|
options: {
|
|
chunkId: string;
|
|
fileName: string;
|
|
format: InternalModuleFormat;
|
|
moduleId: string;
|
|
referenceId: string;
|
|
relativePath: string;
|
|
}
|
|
) => string | NullValue;
|
|
|
|
export type AddonHookFunction = (
|
|
this: PluginContext,
|
|
chunk: RenderedChunk
|
|
) => string | Promise<string>;
|
|
export type AddonHook = string | AddonHookFunction;
|
|
|
|
export type ChangeEvent = 'create' | 'update' | 'delete';
|
|
export type WatchChangeHook = (
|
|
this: PluginContext,
|
|
id: string,
|
|
change: { event: ChangeEvent }
|
|
) => void;
|
|
|
|
/**
|
|
* use this type for plugin annotation
|
|
* @example
|
|
* ```ts
|
|
* interface Options {
|
|
* ...
|
|
* }
|
|
* const myPlugin: PluginImpl<Options> = (options = {}) => { ... }
|
|
* ```
|
|
*/
|
|
export type PluginImpl<O extends object = object, A = any> = (options?: O) => Plugin<A>;
|
|
|
|
export type OutputBundle = Record<string, OutputAsset | OutputChunk>;
|
|
|
|
export type PreRenderedChunkWithFileName = PreRenderedChunk & { fileName: string };
|
|
|
|
export interface ImportedInternalChunk {
|
|
type: 'internal';
|
|
fileName: string;
|
|
resolvedImportPath: string;
|
|
chunk: PreRenderedChunk;
|
|
}
|
|
|
|
export interface ImportedExternalChunk {
|
|
type: 'external';
|
|
fileName: string;
|
|
resolvedImportPath: string;
|
|
}
|
|
|
|
export type DynamicImportTargetChunk = ImportedInternalChunk | ImportedExternalChunk;
|
|
|
|
export interface FunctionPluginHooks {
|
|
augmentChunkHash: (this: PluginContext, chunk: RenderedChunk) => string | void;
|
|
buildEnd: (this: PluginContext, error?: Error) => void;
|
|
buildStart: (this: PluginContext, options: NormalizedInputOptions) => void;
|
|
closeBundle: (this: PluginContext, error?: Error) => void;
|
|
closeWatcher: (this: PluginContext) => void;
|
|
generateBundle: (
|
|
this: PluginContext,
|
|
options: NormalizedOutputOptions,
|
|
bundle: OutputBundle,
|
|
isWrite: boolean
|
|
) => void;
|
|
load: LoadHook;
|
|
moduleParsed: ModuleParsedHook;
|
|
onLog: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => boolean | NullValue;
|
|
options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | NullValue;
|
|
outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | NullValue;
|
|
renderChunk: RenderChunkHook;
|
|
renderDynamicImport: (
|
|
this: PluginContext,
|
|
options: {
|
|
customResolution: string | null;
|
|
format: InternalModuleFormat;
|
|
moduleId: string;
|
|
targetModuleId: string | null;
|
|
chunk: PreRenderedChunkWithFileName;
|
|
targetChunk: PreRenderedChunkWithFileName | null;
|
|
getTargetChunkImports: () => DynamicImportTargetChunk[] | null;
|
|
}
|
|
) => { left: string; right: string } | NullValue;
|
|
renderError: (this: PluginContext, error?: Error) => void;
|
|
renderStart: (
|
|
this: PluginContext,
|
|
outputOptions: NormalizedOutputOptions,
|
|
inputOptions: NormalizedInputOptions
|
|
) => void;
|
|
resolveDynamicImport: ResolveDynamicImportHook;
|
|
resolveFileUrl: ResolveFileUrlHook;
|
|
resolveId: ResolveIdHook;
|
|
resolveImportMeta: ResolveImportMetaHook;
|
|
shouldTransformCachedModule: ShouldTransformCachedModuleHook;
|
|
transform: TransformHook;
|
|
watchChange: WatchChangeHook;
|
|
writeBundle: (
|
|
this: PluginContext,
|
|
options: NormalizedOutputOptions,
|
|
bundle: OutputBundle
|
|
) => void;
|
|
}
|
|
|
|
export type OutputPluginHooks =
|
|
| 'augmentChunkHash'
|
|
| 'generateBundle'
|
|
| 'outputOptions'
|
|
| 'renderChunk'
|
|
| 'renderDynamicImport'
|
|
| 'renderError'
|
|
| 'renderStart'
|
|
| 'resolveFileUrl'
|
|
| 'resolveImportMeta'
|
|
| 'writeBundle';
|
|
|
|
export type InputPluginHooks = Exclude<keyof FunctionPluginHooks, OutputPluginHooks>;
|
|
|
|
export type SyncPluginHooks =
|
|
| 'augmentChunkHash'
|
|
| 'onLog'
|
|
| 'outputOptions'
|
|
| 'renderDynamicImport'
|
|
| 'resolveFileUrl'
|
|
| 'resolveImportMeta';
|
|
|
|
export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
|
|
|
|
export type FirstPluginHooks =
|
|
| 'load'
|
|
| 'renderDynamicImport'
|
|
| 'resolveDynamicImport'
|
|
| 'resolveFileUrl'
|
|
| 'resolveId'
|
|
| 'resolveImportMeta'
|
|
| 'shouldTransformCachedModule';
|
|
|
|
export type SequentialPluginHooks =
|
|
| 'augmentChunkHash'
|
|
| 'generateBundle'
|
|
| 'onLog'
|
|
| 'options'
|
|
| 'outputOptions'
|
|
| 'renderChunk'
|
|
| 'transform';
|
|
|
|
export type ParallelPluginHooks = Exclude<
|
|
keyof FunctionPluginHooks | AddonHooks,
|
|
FirstPluginHooks | SequentialPluginHooks
|
|
>;
|
|
|
|
export type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro';
|
|
|
|
type MakeAsync<Function_> = Function_ extends (
|
|
this: infer This,
|
|
...parameters: infer Arguments
|
|
) => infer Return
|
|
? (this: This, ...parameters: Arguments) => Return | Promise<Return>
|
|
: never;
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-empty-object-type
|
|
export type ObjectHook<T, O = {}> = T | ({ handler: T; order?: 'pre' | 'post' | null } & O);
|
|
|
|
export type HookFilterExtension<K extends keyof FunctionPluginHooks> = K extends 'transform'
|
|
? { filter?: HookFilter }
|
|
: K extends 'load'
|
|
? { filter?: Pick<HookFilter, 'id'> }
|
|
: K extends 'resolveId'
|
|
? { filter?: { id?: StringFilter<RegExp> } }
|
|
: // eslint-disable-next-line @typescript-eslint/no-empty-object-type
|
|
{};
|
|
|
|
export type PluginHooks = {
|
|
[K in keyof FunctionPluginHooks]: ObjectHook<
|
|
K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K],
|
|
// eslint-disable-next-line @typescript-eslint/no-empty-object-type
|
|
HookFilterExtension<K> & (K extends ParallelPluginHooks ? { sequential?: boolean } : {})
|
|
>;
|
|
};
|
|
|
|
export interface OutputPlugin
|
|
extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>,
|
|
Partial<Record<AddonHooks, ObjectHook<AddonHook>>> {
|
|
cacheKey?: string;
|
|
name: string;
|
|
version?: string;
|
|
}
|
|
|
|
export interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
|
|
// for inter-plugin communication
|
|
api?: A;
|
|
}
|
|
|
|
export type JsxPreset = 'react' | 'react-jsx' | 'preserve' | 'preserve-react';
|
|
|
|
export type NormalizedJsxOptions =
|
|
| NormalizedJsxPreserveOptions
|
|
| NormalizedJsxClassicOptions
|
|
| NormalizedJsxAutomaticOptions;
|
|
|
|
interface NormalizedJsxPreserveOptions {
|
|
factory: string | null;
|
|
fragment: string | null;
|
|
importSource: string | null;
|
|
mode: 'preserve';
|
|
}
|
|
|
|
interface NormalizedJsxClassicOptions {
|
|
factory: string;
|
|
fragment: string;
|
|
importSource: string | null;
|
|
mode: 'classic';
|
|
}
|
|
|
|
interface NormalizedJsxAutomaticOptions {
|
|
factory: string;
|
|
importSource: string | null;
|
|
jsxImportSource: string;
|
|
mode: 'automatic';
|
|
}
|
|
|
|
export type JsxOptions = Partial<NormalizedJsxOptions> & {
|
|
preset?: JsxPreset;
|
|
};
|
|
|
|
export type TreeshakingPreset = 'smallest' | 'safest' | 'recommended';
|
|
|
|
export interface NormalizedTreeshakingOptions {
|
|
annotations: boolean;
|
|
correctVarValueBeforeDeclaration: boolean;
|
|
manualPureFunctions: readonly string[];
|
|
moduleSideEffects: HasModuleSideEffects;
|
|
propertyReadSideEffects: boolean | 'always';
|
|
tryCatchDeoptimization: boolean;
|
|
unknownGlobalSideEffects: boolean;
|
|
}
|
|
|
|
export interface TreeshakingOptions
|
|
extends Partial<Omit<NormalizedTreeshakingOptions, 'moduleSideEffects'>> {
|
|
moduleSideEffects?: ModuleSideEffectsOption;
|
|
preset?: TreeshakingPreset;
|
|
}
|
|
|
|
interface ManualChunkMeta {
|
|
getModuleIds: () => IterableIterator<string>;
|
|
getModuleInfo: GetModuleInfo;
|
|
}
|
|
|
|
export type GetManualChunk = (id: string, meta: ManualChunkMeta) => string | NullValue;
|
|
|
|
export type ExternalOption =
|
|
| (string | RegExp)[]
|
|
| string
|
|
| RegExp
|
|
| ((source: string, importer: string | undefined, isResolved: boolean) => boolean | NullValue);
|
|
|
|
export type GlobalsOption = Record<string, string> | ((name: string) => string);
|
|
|
|
export type InputOption = string | string[] | Record<string, string>;
|
|
|
|
export type ManualChunksOption = Record<string, string[]> | GetManualChunk;
|
|
|
|
export type LogHandlerWithDefault = (
|
|
level: LogLevel,
|
|
log: RollupLog,
|
|
defaultHandler: LogOrStringHandler
|
|
) => void;
|
|
|
|
export type LogOrStringHandler = (level: LogLevel | 'error', log: RollupLog | string) => void;
|
|
|
|
export type LogHandler = (level: LogLevel, log: RollupLog) => void;
|
|
|
|
export type ModuleSideEffectsOption = boolean | 'no-external' | string[] | HasModuleSideEffects;
|
|
|
|
export type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
|
|
|
|
export type SourcemapPathTransformOption = (
|
|
relativeSourcePath: string,
|
|
sourcemapPath: string
|
|
) => string;
|
|
|
|
export type SourcemapIgnoreListOption = (
|
|
relativeSourcePath: string,
|
|
sourcemapPath: string
|
|
) => boolean;
|
|
|
|
export type InputPluginOption = MaybePromise<Plugin | NullValue | false | InputPluginOption[]>;
|
|
|
|
export interface InputOptions {
|
|
cache?: boolean | RollupCache;
|
|
context?: string;
|
|
experimentalCacheExpiry?: number;
|
|
experimentalLogSideEffects?: boolean;
|
|
external?: ExternalOption;
|
|
fs?: RollupFsModule;
|
|
input?: InputOption;
|
|
jsx?: false | JsxPreset | JsxOptions;
|
|
logLevel?: LogLevelOption;
|
|
makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource';
|
|
maxParallelFileOps?: number;
|
|
moduleContext?: ((id: string) => string | NullValue) | Record<string, string>;
|
|
onLog?: LogHandlerWithDefault;
|
|
onwarn?: WarningHandlerWithDefault;
|
|
perf?: boolean;
|
|
plugins?: InputPluginOption;
|
|
preserveEntrySignatures?: PreserveEntrySignaturesOption;
|
|
preserveSymlinks?: boolean;
|
|
shimMissingExports?: boolean;
|
|
strictDeprecations?: boolean;
|
|
treeshake?: boolean | TreeshakingPreset | TreeshakingOptions;
|
|
watch?: WatcherOptions | false;
|
|
}
|
|
|
|
export interface InputOptionsWithPlugins extends InputOptions {
|
|
plugins: Plugin[];
|
|
}
|
|
|
|
export interface NormalizedInputOptions {
|
|
cache: false | undefined | RollupCache;
|
|
context: string;
|
|
experimentalCacheExpiry: number;
|
|
experimentalLogSideEffects: boolean;
|
|
external: IsExternal;
|
|
fs: RollupFsModule;
|
|
input: string[] | Record<string, string>;
|
|
jsx: false | NormalizedJsxOptions;
|
|
logLevel: LogLevelOption;
|
|
makeAbsoluteExternalsRelative: boolean | 'ifRelativeSource';
|
|
maxParallelFileOps: number;
|
|
moduleContext: (id: string) => string;
|
|
onLog: LogHandler;
|
|
perf: boolean;
|
|
plugins: Plugin[];
|
|
preserveEntrySignatures: PreserveEntrySignaturesOption;
|
|
preserveSymlinks: boolean;
|
|
shimMissingExports: boolean;
|
|
strictDeprecations: boolean;
|
|
treeshake: false | NormalizedTreeshakingOptions;
|
|
}
|
|
|
|
export type InternalModuleFormat = 'amd' | 'cjs' | 'es' | 'iife' | 'system' | 'umd';
|
|
export type ImportAttributesKey = 'with' | 'assert';
|
|
|
|
export type ModuleFormat = InternalModuleFormat | 'commonjs' | 'esm' | 'module' | 'systemjs';
|
|
|
|
type GeneratedCodePreset = 'es5' | 'es2015';
|
|
|
|
interface NormalizedGeneratedCodeOptions {
|
|
arrowFunctions: boolean;
|
|
constBindings: boolean;
|
|
objectShorthand: boolean;
|
|
reservedNamesAsProps: boolean;
|
|
symbols: boolean;
|
|
}
|
|
|
|
interface GeneratedCodeOptions extends Partial<NormalizedGeneratedCodeOptions> {
|
|
preset?: GeneratedCodePreset;
|
|
}
|
|
|
|
export type OptionsPaths = Record<string, string> | ((id: string) => string);
|
|
|
|
export type InteropType = 'compat' | 'auto' | 'esModule' | 'default' | 'defaultOnly';
|
|
|
|
export type GetInterop = (id: string | null) => InteropType;
|
|
|
|
export type AmdOptions = (
|
|
| {
|
|
autoId?: false;
|
|
id: string;
|
|
}
|
|
| {
|
|
autoId: true;
|
|
basePath?: string;
|
|
id?: undefined;
|
|
}
|
|
| {
|
|
autoId?: false;
|
|
id?: undefined;
|
|
}
|
|
) & {
|
|
define?: string;
|
|
forceJsExtensionForImports?: boolean;
|
|
};
|
|
|
|
export type NormalizedAmdOptions = (
|
|
| {
|
|
autoId: false;
|
|
id?: string;
|
|
}
|
|
| {
|
|
autoId: true;
|
|
basePath: string;
|
|
}
|
|
) & {
|
|
define: string;
|
|
forceJsExtensionForImports: boolean;
|
|
};
|
|
|
|
type AddonFunction = (chunk: RenderedChunk) => string | Promise<string>;
|
|
|
|
type OutputPluginOption = MaybePromise<OutputPlugin | NullValue | false | OutputPluginOption[]>;
|
|
|
|
type HashCharacters = 'base64' | 'base36' | 'hex';
|
|
|
|
export interface OutputOptions {
|
|
amd?: AmdOptions;
|
|
assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string);
|
|
banner?: string | AddonFunction;
|
|
chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
|
|
compact?: boolean;
|
|
// only required for bundle.write
|
|
dir?: string;
|
|
dynamicImportInCjs?: boolean;
|
|
entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
|
|
esModule?: boolean | 'if-default-prop';
|
|
experimentalMinChunkSize?: number;
|
|
exports?: 'default' | 'named' | 'none' | 'auto';
|
|
extend?: boolean;
|
|
/** @deprecated Use "externalImportAttributes" instead. */
|
|
externalImportAssertions?: boolean;
|
|
externalImportAttributes?: boolean;
|
|
externalLiveBindings?: boolean;
|
|
// only required for bundle.write
|
|
file?: string;
|
|
footer?: string | AddonFunction;
|
|
format?: ModuleFormat;
|
|
freeze?: boolean;
|
|
generatedCode?: GeneratedCodePreset | GeneratedCodeOptions;
|
|
globals?: GlobalsOption;
|
|
hashCharacters?: HashCharacters;
|
|
hoistTransitiveImports?: boolean;
|
|
importAttributesKey?: ImportAttributesKey;
|
|
indent?: string | boolean;
|
|
inlineDynamicImports?: boolean;
|
|
interop?: InteropType | GetInterop;
|
|
intro?: string | AddonFunction;
|
|
manualChunks?: ManualChunksOption;
|
|
minifyInternalExports?: boolean;
|
|
name?: string;
|
|
noConflict?: boolean;
|
|
outro?: string | AddonFunction;
|
|
paths?: OptionsPaths;
|
|
plugins?: OutputPluginOption;
|
|
preserveModules?: boolean;
|
|
preserveModulesRoot?: string;
|
|
reexportProtoFromExternal?: boolean;
|
|
sanitizeFileName?: boolean | ((fileName: string) => string);
|
|
sourcemap?: boolean | 'inline' | 'hidden';
|
|
sourcemapBaseUrl?: string;
|
|
sourcemapExcludeSources?: boolean;
|
|
sourcemapFile?: string;
|
|
sourcemapFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
|
|
sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption;
|
|
sourcemapPathTransform?: SourcemapPathTransformOption;
|
|
sourcemapDebugIds?: boolean;
|
|
strict?: boolean;
|
|
systemNullSetters?: boolean;
|
|
validate?: boolean;
|
|
virtualDirname?: string;
|
|
}
|
|
|
|
export interface NormalizedOutputOptions {
|
|
amd: NormalizedAmdOptions;
|
|
assetFileNames: string | ((chunkInfo: PreRenderedAsset) => string);
|
|
banner: AddonFunction;
|
|
chunkFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
|
|
compact: boolean;
|
|
dir: string | undefined;
|
|
dynamicImportInCjs: boolean;
|
|
entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
|
|
esModule: boolean | 'if-default-prop';
|
|
experimentalMinChunkSize: number;
|
|
exports: 'default' | 'named' | 'none' | 'auto';
|
|
extend: boolean;
|
|
/** @deprecated Use "externalImportAttributes" instead. */
|
|
externalImportAssertions: boolean;
|
|
externalImportAttributes: boolean;
|
|
externalLiveBindings: boolean;
|
|
file: string | undefined;
|
|
footer: AddonFunction;
|
|
format: InternalModuleFormat;
|
|
freeze: boolean;
|
|
generatedCode: NormalizedGeneratedCodeOptions;
|
|
globals: GlobalsOption;
|
|
hashCharacters: HashCharacters;
|
|
hoistTransitiveImports: boolean;
|
|
importAttributesKey: ImportAttributesKey;
|
|
indent: true | string;
|
|
inlineDynamicImports: boolean;
|
|
interop: GetInterop;
|
|
intro: AddonFunction;
|
|
manualChunks: ManualChunksOption;
|
|
minifyInternalExports: boolean;
|
|
name: string | undefined;
|
|
noConflict: boolean;
|
|
outro: AddonFunction;
|
|
paths: OptionsPaths;
|
|
plugins: OutputPlugin[];
|
|
preserveModules: boolean;
|
|
preserveModulesRoot: string | undefined;
|
|
reexportProtoFromExternal: boolean;
|
|
sanitizeFileName: (fileName: string) => string;
|
|
sourcemap: boolean | 'inline' | 'hidden';
|
|
sourcemapBaseUrl: string | undefined;
|
|
sourcemapExcludeSources: boolean;
|
|
sourcemapFile: string | undefined;
|
|
sourcemapFileNames: string | ((chunkInfo: PreRenderedChunk) => string) | undefined;
|
|
sourcemapIgnoreList: SourcemapIgnoreListOption;
|
|
sourcemapPathTransform: SourcemapPathTransformOption | undefined;
|
|
sourcemapDebugIds: boolean;
|
|
strict: boolean;
|
|
systemNullSetters: boolean;
|
|
validate: boolean;
|
|
virtualDirname: string;
|
|
}
|
|
|
|
export type WarningHandlerWithDefault = (
|
|
warning: RollupLog,
|
|
defaultHandler: LoggingFunction
|
|
) => void;
|
|
|
|
export type SerializedTimings = Record<string, [number, number, number]>;
|
|
|
|
export interface PreRenderedAsset {
|
|
/** @deprecated Use "names" instead. */
|
|
name: string | undefined;
|
|
names: string[];
|
|
/** @deprecated Use "originalFileNames" instead. */
|
|
originalFileName: string | null;
|
|
originalFileNames: string[];
|
|
source: string | Uint8Array;
|
|
type: 'asset';
|
|
}
|
|
|
|
export interface OutputAsset extends PreRenderedAsset {
|
|
fileName: string;
|
|
needsCodeReference: boolean;
|
|
}
|
|
|
|
export interface RenderedModule {
|
|
readonly code: string | null;
|
|
originalLength: number;
|
|
removedExports: string[];
|
|
renderedExports: string[];
|
|
renderedLength: number;
|
|
}
|
|
|
|
export interface PreRenderedChunk {
|
|
exports: string[];
|
|
facadeModuleId: string | null;
|
|
isDynamicEntry: boolean;
|
|
isEntry: boolean;
|
|
isImplicitEntry: boolean;
|
|
moduleIds: string[];
|
|
name: string;
|
|
type: 'chunk';
|
|
}
|
|
|
|
export interface RenderedChunk extends PreRenderedChunk {
|
|
dynamicImports: string[];
|
|
fileName: string;
|
|
implicitlyLoadedBefore: string[];
|
|
importedBindings: Record<string, string[]>;
|
|
imports: string[];
|
|
modules: Record<string, RenderedModule>;
|
|
referencedFiles: string[];
|
|
}
|
|
|
|
export interface OutputChunk extends RenderedChunk {
|
|
code: string;
|
|
map: SourceMap | null;
|
|
sourcemapFileName: string | null;
|
|
preliminaryFileName: string;
|
|
}
|
|
|
|
export type SerializablePluginCache = Record<string, [number, any]>;
|
|
|
|
export interface RollupCache {
|
|
modules: ModuleJSON[];
|
|
plugins?: Record<string, SerializablePluginCache>;
|
|
}
|
|
|
|
export interface RollupOutput {
|
|
output: [OutputChunk, ...(OutputChunk | OutputAsset)[]];
|
|
}
|
|
|
|
export interface RollupBuild {
|
|
cache: RollupCache | undefined;
|
|
close: () => Promise<void>;
|
|
closed: boolean;
|
|
[Symbol.asyncDispose](): Promise<void>;
|
|
generate: (outputOptions: OutputOptions) => Promise<RollupOutput>;
|
|
getTimings?: () => SerializedTimings;
|
|
watchFiles: string[];
|
|
write: (options: OutputOptions) => Promise<RollupOutput>;
|
|
}
|
|
|
|
export interface RollupOptions extends InputOptions {
|
|
// This is included for compatibility with config files but ignored by rollup.rollup
|
|
output?: OutputOptions | OutputOptions[];
|
|
}
|
|
|
|
export interface MergedRollupOptions extends InputOptionsWithPlugins {
|
|
output: OutputOptions[];
|
|
}
|
|
|
|
export function rollup(options: RollupOptions): Promise<RollupBuild>;
|
|
|
|
export interface ChokidarOptions {
|
|
alwaysStat?: boolean;
|
|
atomic?: boolean | number;
|
|
awaitWriteFinish?:
|
|
| {
|
|
pollInterval?: number;
|
|
stabilityThreshold?: number;
|
|
}
|
|
| boolean;
|
|
binaryInterval?: number;
|
|
cwd?: string;
|
|
depth?: number;
|
|
disableGlobbing?: boolean;
|
|
followSymlinks?: boolean;
|
|
ignoreInitial?: boolean;
|
|
ignorePermissionErrors?: boolean;
|
|
ignored?: any;
|
|
interval?: number;
|
|
persistent?: boolean;
|
|
useFsEvents?: boolean;
|
|
usePolling?: boolean;
|
|
}
|
|
|
|
export type RollupWatchHooks = 'onError' | 'onStart' | 'onBundleStart' | 'onBundleEnd' | 'onEnd';
|
|
|
|
export interface WatcherOptions {
|
|
allowInputInsideOutputPath?: boolean;
|
|
buildDelay?: number;
|
|
chokidar?: ChokidarOptions;
|
|
clearScreen?: boolean;
|
|
exclude?: string | RegExp | (string | RegExp)[];
|
|
include?: string | RegExp | (string | RegExp)[];
|
|
skipWrite?: boolean;
|
|
onInvalidate?: (id: string) => void;
|
|
}
|
|
|
|
export interface RollupWatchOptions extends InputOptions {
|
|
output?: OutputOptions | OutputOptions[];
|
|
watch?: WatcherOptions | false;
|
|
}
|
|
|
|
export type AwaitedEventListener<
|
|
T extends Record<string, (...parameters: any) => any>,
|
|
K extends keyof T
|
|
> = (...parameters: Parameters<T[K]>) => void | Promise<void>;
|
|
|
|
export interface AwaitingEventEmitter<T extends Record<string, (...parameters: any) => any>> {
|
|
close(): Promise<void>;
|
|
emit<K extends keyof T>(event: K, ...parameters: Parameters<T[K]>): Promise<unknown>;
|
|
/**
|
|
* Removes an event listener.
|
|
*/
|
|
off<K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>): this;
|
|
/**
|
|
* Registers an event listener that will be awaited before Rollup continues.
|
|
* All listeners will be awaited in parallel while rejections are tracked via
|
|
* Promise.all.
|
|
*/
|
|
on<K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>): this;
|
|
/**
|
|
* Registers an event listener that will be awaited before Rollup continues.
|
|
* All listeners will be awaited in parallel while rejections are tracked via
|
|
* Promise.all.
|
|
* Listeners are removed automatically when removeListenersForCurrentRun is
|
|
* called, which happens automatically after each run.
|
|
*/
|
|
onCurrentRun<K extends keyof T>(
|
|
event: K,
|
|
listener: (...parameters: Parameters<T[K]>) => Promise<ReturnType<T[K]>>
|
|
): this;
|
|
removeAllListeners(): this;
|
|
removeListenersForCurrentRun(): this;
|
|
}
|
|
|
|
export type RollupWatcherEvent =
|
|
| { code: 'START' }
|
|
| { code: 'BUNDLE_START'; input?: InputOption; output: readonly string[] }
|
|
| {
|
|
code: 'BUNDLE_END';
|
|
duration: number;
|
|
input?: InputOption;
|
|
output: readonly string[];
|
|
result: RollupBuild;
|
|
}
|
|
| { code: 'END' }
|
|
| { code: 'ERROR'; error: RollupError; result: RollupBuild | null };
|
|
|
|
export type RollupWatcher = AwaitingEventEmitter<{
|
|
change: (id: string, change: { event: ChangeEvent }) => void;
|
|
close: () => void;
|
|
event: (event: RollupWatcherEvent) => void;
|
|
restart: () => void;
|
|
}>;
|
|
|
|
export function watch(config: RollupWatchOptions | RollupWatchOptions[]): RollupWatcher;
|
|
|
|
interface AstNodeLocation {
|
|
end: number;
|
|
start: number;
|
|
}
|
|
|
|
type OmittedEstreeKeys =
|
|
| 'loc'
|
|
| 'range'
|
|
| 'leadingComments'
|
|
| 'trailingComments'
|
|
| 'innerComments'
|
|
| 'comments';
|
|
type RollupAstNode<T> = Omit<T, OmittedEstreeKeys> & AstNodeLocation;
|
|
|
|
type ProgramNode = RollupAstNode<estree.Program>;
|
|
export type AstNode = RollupAstNode<estree.Node>;
|
|
|
|
export function defineConfig(options: RollupOptions): RollupOptions;
|
|
export function defineConfig(options: RollupOptions[]): RollupOptions[];
|
|
export function defineConfig(optionsFunction: RollupOptionsFunction): RollupOptionsFunction;
|
|
|
|
export type RollupOptionsFunction = (
|
|
commandLineArguments: Record<string, any>
|
|
) => MaybePromise<RollupOptions | RollupOptions[]>;
|
|
|
|
export interface RollupFsModule {
|
|
appendFile(
|
|
path: string,
|
|
data: string | Uint8Array,
|
|
options?: { encoding?: BufferEncoding | null; mode?: string | number; flag?: string | number }
|
|
): Promise<void>;
|
|
|
|
copyFile(source: string, destination: string, mode?: string | number): Promise<void>;
|
|
|
|
mkdir(path: string, options?: { recursive?: boolean; mode?: string | number }): Promise<void>;
|
|
|
|
mkdtemp(prefix: string): Promise<string>;
|
|
|
|
readdir(path: string, options?: { withFileTypes?: false }): Promise<string[]>;
|
|
readdir(path: string, options?: { withFileTypes: true }): Promise<RollupDirectoryEntry[]>;
|
|
|
|
readFile(
|
|
path: string,
|
|
options?: { encoding?: null; flag?: string | number; signal?: AbortSignal }
|
|
): Promise<Uint8Array>;
|
|
readFile(
|
|
path: string,
|
|
options?: { encoding: BufferEncoding; flag?: string | number; signal?: AbortSignal }
|
|
): Promise<string>;
|
|
|
|
realpath(path: string): Promise<string>;
|
|
|
|
rename(oldPath: string, newPath: string): Promise<void>;
|
|
|
|
rmdir(path: string, options?: { recursive?: boolean }): Promise<void>;
|
|
|
|
stat(path: string): Promise<RollupFileStats>;
|
|
|
|
lstat(path: string): Promise<RollupFileStats>;
|
|
|
|
unlink(path: string): Promise<void>;
|
|
|
|
writeFile(
|
|
path: string,
|
|
data: string | Uint8Array,
|
|
options?: { encoding?: BufferEncoding | null; mode?: string | number; flag?: string | number }
|
|
): Promise<void>;
|
|
}
|
|
|
|
export type BufferEncoding =
|
|
| 'ascii'
|
|
| 'utf8'
|
|
| 'utf16le'
|
|
| 'ucs2'
|
|
| 'base64'
|
|
| 'base64url'
|
|
| 'latin1'
|
|
| 'binary'
|
|
| 'hex';
|
|
|
|
export interface RollupDirectoryEntry {
|
|
isFile(): boolean;
|
|
isDirectory(): boolean;
|
|
isSymbolicLink(): boolean;
|
|
name: string;
|
|
}
|
|
|
|
export interface RollupFileStats {
|
|
isFile(): boolean;
|
|
isDirectory(): boolean;
|
|
isSymbolicLink(): boolean;
|
|
size: number;
|
|
mtime: Date;
|
|
ctime: Date;
|
|
atime: Date;
|
|
birthtime: Date;
|
|
}
|