@vencord-companion/webpack-ast-parser 0.0.1

package/dist/WebpackAstParser.d.ts

@@ -0,0 +1,225 @@
+import { VariableInfo } from "ts-api-utils";
+import { CallExpression, ClassDeclaration, Expression, Identifier, MemberName, NewExpression, Node, ObjectLiteralExpression, SourceFile } from "typescript";
+import { AstParser } from "@vencord-companion/ast-parser";
+import { Logger } from "@vencord-companion/shared/Logger";
+import { Position } from "@vencord-companion/shared/Position";
+import { Range } from "@vencord-companion/shared/Range";
+import { AnyExportKey, Definition, ExportMap, ExportRange, IModuleCache, IModuleDepManager, ModuleDeps, RangeExportMap, RawExportMap, RawExportRange, Reference, Store } from "./types";
+export declare function setLogger(l: Logger): void;
+export declare class WebpackAstParser extends AstParser {
+    private static defaultModuleCache;
+    static setDefaultModuleCache(cache: IModuleCache | ((self: WebpackAstParser) => IModuleCache)): void;
+    private static defaultModuleDepManager;
+    static setDefaultModuleDepManager(manager: IModuleDepManager | ((self: WebpackAstParser) => IModuleDepManager)): void;
+    /**
+     * This is set on {@link RangeExportMap} when the default export is commonjs and has no properties, eg, string literal, function
+     */
+    static readonly SYM_CJS_DEFAULT: unique symbol;
+    /**
+     * set on raw export maps to give a hover hint for LSP
+     */
+    static readonly SYM_HOVER: unique symbol;
+    /**
+     *
+     * @param text the module text
+     * @returns a {@link WebpackAstParser}
+     *
+     * NOTE: you probably want {@link WebpackAstParser.withFormattedModule|withFormattedModule}
+     */
+    static withFormattedText(text: string): WebpackAstParser;
+    static withFormattedModule(text: string, moduleId: string | number): WebpackAstParser;
+    /**
+     * The webpack instance passed to this module
+     *
+     * The `n` of
+     * ```
+     * function (e, t, n) {
+     // webpack module contents
+     * }
+     * ```
+     * @CacheGetter
+     */
+    get wreq(): Identifier | undefined;
+    /**
+     * where {@link WebpackAstParser.wreq this.wreq} is used
+     * @CacheGetter
+     */
+    get uses(): VariableInfo | undefined;
+    /**
+     * The module id of the current module
+     * @CacheGetter
+     */
+    get moduleId(): string | null;
+    /**
+     * @CacheGetter
+     */
+    get moduleCache(): IModuleCache;
+    /**
+     * @CacheGetter
+     */
+    get moduleDepManager(): IModuleDepManager;
+    constructor(text: string);
+    protected createSourceFile(): SourceFile;
+    /**
+     * @param paramIndex the index of the param 0, 1, 2 etc...
+     * @param start finds a webpack arg from the source tree
+     * @returns the identifier of the param if found or undef
+     *
+     * NOTE: you should probably not use this
+     *
+     * @see {@link findWreq_t}
+     * @see {@link findWreq_e}
+     * @see {@link wreq}
+     */
+    private findWebpackArg;
+    getModulesThatRequireThisModule(): ModuleDeps | null;
+    /**
+     * @Cache
+     */
+    getModulesThatThisModuleRequires(): ModuleDeps | null;
+    tryGetFreshModuleFallbackToCache(moduleId: string | number): Promise<string | undefined>;
+    /**
+     * @param idNode the numeric literal node that is the module id
+     * This is called internally by {@link generateDefinitions}
+     *
+     * given
+     * ```js
+     * var mod = n(123456);
+     * //          ^^^^^^
+     * ```
+     * returns the definitions for that module
+     */
+    private generateDirectModuleDefinition;
+    generateDefinitions(position: Position): Promise<Definition[] | undefined>;
+    generateHover(position: Position): Promise<[Range, string] | undefined>;
+    doesReExportFromExport(exportName: AnyExportKey[]): [
+        importSourceId: string,
+        exportName: MemberName[]
+    ] | undefined;
+    /**
+     * gets the module id from a require
+     * given
+     * ```js
+     * var mod = n(123456);
+     * ```
+     * @argument dec the variable info for that mod
+     * @see {@link getVariableInitializer} which can than be passed into {@link vars|vars.get}
+     * @returns `123456`
+     */
+    getModuleIdForImport(dec: VariableInfo | undefined): number | undefined;
+    generateReferences(position: Position): Promise<Reference[] | undefined>;
+    /**
+     * checks if this module re-exports another whole module and not just parts of it
+     * ```js
+     * e.exports = n(moduleId);
+     * ```
+     * @returns the module ID if it does, undefined otherwise
+     * @Cache
+     */
+    doesReExportWholeModule(): string | undefined;
+    /**
+     * Figure out if this module re-exports another given the module id of the other and the name of the export from the other module
+   * @param moduleId the module id that {@link exportName} is from
+   * @param exportName the name of the re-exported export
+   */
+    doesReExportFromImport(moduleId: string, exportName: AnyExportKey): AnyExportKey | undefined;
+    /**
+     * @returns a map of exported names to the nodes that they are exported from
+     * @Cache
+     */
+    getExportMapRaw(): RawExportMap;
+    /**
+     * FIXME: this is not in line with {@link getExportMapWreq_d}
+     * @Cache
+     */
+    getExportMapRawWreq_d(): RawExportMap | undefined;
+    /**
+     * @Cache
+     */
+    getExportMapRawWreq_e(): ExportMap<Expression> | undefined;
+    /**
+     * @Cache
+     */
+    getExportMapRawWreq_t(): ExportMap<Expression> | undefined;
+    /**
+     * @Cache
+     */
+    getExportMap(): RangeExportMap;
+    getImportedVar(moduleId: string): Identifier | undefined;
+    getIdOfImportedVar(variable: Identifier): string | undefined;
+    /**
+     * @param moduleId the imported module id where {@link exportName} is used
+     * @param exportName the string of the exported name or {@link SYM_CJS_DEFAULT} for the default export
+     * TODO: support nested exports eg: `wreq(123).ZP.storeMethod()`
+     * @returns the ranges where the export is used in this file
+     */
+    getUsesOfImport(moduleId: string, exportName: string | symbol): Range[];
+    /**
+     * @Cache
+     */
+    getExportMapWreq_t(): RangeExportMap | undefined;
+    rawMakeExportMapRecursive(node: Node): RawExportMap | RawExportRange;
+    rawMapToExportMap(map: RawExportRange): ExportRange;
+    rawMapToExportMap(map: RawExportMap): RangeExportMap;
+    rawMapToExportMap(map: RawExportMap | RawExportRange): RangeExportMap | ExportRange;
+    /**
+   * takes an expression, and maps it to ranges which it is in
+   */
+    makeExportMapRecursive(node: Node): RangeExportMap | ExportRange;
+    /**
+     * @Cache
+     */
+    getExportMapWreq_e(): RangeExportMap | undefined;
+    /**
+     * @Cache
+     */
+    getExportMapWreq_d(): RangeExportMap | undefined;
+    tryParseStoreForExport(node: Node | undefined, extraStoreLocs?: Range[]): RangeExportMap | undefined;
+    tryParseStore(storeInit: NewExpression): Store | undefined;
+    tryFindStoreDisplayName(storeVar: VariableInfo): string | undefined;
+    /**
+     *
+     * @returns ```js
+     * {
+     *     "<PASSED_IN_CLASS_NAME>": {
+     *          [WebpackAstParser.SYM_CJS_DEFAULT]: ["<CONSTRUCTOR>"],
+     *          ["methodName"]: ["METHOD"]
+     *     }
+     * }
+     * ```
+     */
+    parseClassDeclaration(clazz: ClassDeclaration, extraExportRanges?: Node[]): RawExportMap;
+    tryParseClassDeclaration(node: Node, extraExportRanges: Node[]): RawExportMap | undefined;
+    getNestedExportFromMap<T>(keys: readonly AnyExportKey[], map: ExportMap<T>): T[] | undefined;
+    findExportLocation(exportNames: readonly AnyExportKey[]): Range;
+    findHoverText(exportNames: readonly AnyExportKey[]): string | undefined;
+    /**
+     * @Cache
+     */
+    findWreq_d(): (Omit<CallExpression, "arguments"> & {
+        arguments: readonly [Identifier, ObjectLiteralExpression];
+    }) | undefined;
+    tryFindExportwreq_d(exportName: string): Range | undefined;
+    /**
+     * @Cache
+     */
+    findWreq_t(): Identifier | undefined;
+    tryFindExportWreq_t(exportName: string): Range | undefined;
+    /**
+     * @Cache
+     */
+    findWreq_e(): Identifier | undefined;
+    tryFindExportsWreq_e(exportName: string): Range | undefined;
+    getAllReExportsForExport(exportName: AnyExportKey): Promise<[moduleId: string, exportChain: AnyExportKey[]][]>;
+    /**
+     * @returns the string of the export if this is the flux dispatcher module, null otherwise
+     * @Cache
+     */
+    isFluxDispatcherModule(): string | undefined;
+    /**
+     * checks if this module exports a flux dispatcher
+     *
+     * @returns the string of the export name if this module exports a flux dispatcher
+     */
+    exportsFluxDispatcherInstance(): string | null;
+}