@ibm/sourceorbit/dist/src/targets.d.ts

IBM i dependency management tool

import { ObjectRef } from 'vscode-db2i/src/language/sql/types';
import { Logger } from './logger';
import { ReadFileSystem } from './readFileSystem';
export type ObjectType = "PGM" | "SRVPGM" | "MODULE" | "FILE" | "BNDDIR" | "DTAARA" | "CMD" | "MENU" | "DTAQ";
export interface ILEObject {
    systemName: string;
    longName?: string;
    type: ObjectType;
    text?: string;
    relativePath?: string;
    extension?: string;
    reference?: boolean;
    /** exported functions */
    exports?: string[];
    /** each function import in the object */
    imports?: string[];
    /** headers. only supports RPGLE and is not recursive */
    headers?: string[];
}
export interface ILEObjectTarget extends ILEObject {
    deps: ILEObject[];
}
export interface TargetSuggestions {
    renames?: boolean;
    includes?: boolean;
}
export interface ImpactedObject {
    ileObject: ILEObject;
    children: ImpactedObject[];
}
/**
 * This class is responsible for storing all the targets
 * and their dependencies. It also handles the parsing
 * of files and the creation of targets.
 *
 * const files = getAllFilesInDir(`.`);
 * const targets = new Targets(cwd);
 * targets.handlePseudoFile(pseudoFilePath);
 * targets.loadObjectsFromPaths(files);
 * await Promise.all(files.map(f => targets.parseFile(f)));
 * targets.resolveBinder();
 */
export declare class Targets {
    private cwd;
    private fs;
    private rpgParser;
    private pathCache;
    private resolvedSearches;
    private assumePrograms;
    private resolvedObjects;
    private resolvedExports;
    private targets;
    private needsBinder;
    private projectBindingDirectory;
    private suggestions;
    logger: Logger;
    constructor(cwd: string, fs: ReadFileSystem);
    getCwd(): string;
    get rfs(): ReadFileSystem;
    setAssumePrograms(assumePrograms: boolean): void;
    setSuggestions(newSuggestions: TargetSuggestions): void;
    getBinderTarget(): ILEObject;
    getRelative(fullPath: string): string;
    private storeResolved;
    loadProject(withRef?: string): Promise<void>;
    resolvePathToObject(localPath: string, newText?: string): Promise<ILEObject>;
    /**
     * This can be expensive. It should only be called:
     * before loadObjectsFromPaths and parseFile are called.
     * @param filePath Fully qualified path to the file. Assumed to exist.
     */
    handleRefsFile(filePath: string): Promise<void>;
    isReferenceObject(ileObject: ILEObject, remove?: boolean): boolean;
    removeObjectByPath(localPath: string): ILEObject[];
    removeObject(resolvedObject: ILEObject): ILEObject[];
    /**
     * Resolves a search to an object. Use `systemName` parameter for short and long name.
     */
    searchForObject(lookFor: ILEObject): ILEObject;
    searchForAnyObject(lookFor: {
        name: string;
        types: ObjectType[];
    }): ILEObject;
    resolveLocalFile(name: string, baseFile?: string): string | undefined;
    private getObjectType;
    loadObjectsFromPaths(paths: string[]): Promise<ILEObject[]>;
    parseFile(filePath: string): Promise<boolean>;
    private createCmdTarget;
    private createSrvPgmTarget;
    /**
     * Handles all DDS types: pf, lf, dspf
     */
    private createDdsFileTarget;
    private createClTarget;
    private createSqlTargets;
    private createRpgTarget;
    getTarget(object: ILEObject): ILEObjectTarget | undefined;
    getTargets(): ILEObjectTarget[];
    resolveBinder(): void;
    private convertBoundProgramToMultiModuleProgram;
    createOrAppend(parentObject: ILEObject, newDep?: ILEObject): ILEObjectTarget;
    private addNewTarget;
    binderRequired(): boolean;
    getTargetsOfType(type: ObjectType): ILEObjectTarget[];
    getResolvedObjects(type?: ObjectType): ILEObject[];
    getResolvedObject(fullPath: string): ILEObject;
    /**
     * This API is a little trick.
     * You can pass in a valid file extension, or if you pass
     * solely just `pgm`, it will return all programs that
     * have multiple modules.
     */
    getResolvedObjectsByFileExtension(ext: string): ILEObject[];
    getExports(): {
        [name: string]: ILEObject;
    };
    getImpactFor(theObject: ILEObject): ImpactedObject;
    /**
     * This is used when loading in all objects.
     * SQL sources can have two object names: a system name and a long name
     * Sadly the long name is not typically part of the path name, so we need to
     * find the name inside of the source code.
     */
    sqlObjectDataFromPath(fullPath: string): Promise<ObjectRef>;
}