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

IBM i dependency management tool

import { Logger } from '../logger';
import { ReadFileSystem } from '../readFileSystem';
import { TargetsLanguageProvider } from './languages';
export type ObjectType = "PGM" | "SRVPGM" | "MODULE" | "FILE" | "BNDDIR" | "DTAARA" | "CMD" | "MENU" | "DTAQ";
export interface ParserError {
    filePath: string;
    content: string;
    ileObject: ILEObject;
    error: Error;
}
export type ParserErrorCallback = (error: ParserError) => void;
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[];
}
export interface FileOptions {
    isFree?: boolean;
    text?: string;
}
/**
 * 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;
    static LanguageProvider: TargetsLanguageProvider;
    private pathCache;
    private resolvedSearches;
    private assumePrograms;
    private resolvedObjects;
    private resolvedExports;
    private targets;
    private needsBinder;
    private projectBindingDirectory;
    private actionSuggestions;
    private parserErrorCallback;
    logger: Logger;
    constructor(cwd: string, fs: ReadFileSystem);
    static get ignoredObjects(): string[];
    setParserErrorCallback(callback: ParserErrorCallback): void;
    getCwd(): string;
    get rfs(): ReadFileSystem;
    get suggestions(): TargetSuggestions;
    setAssumePrograms(assumePrograms: boolean): void;
    shouldAssumePrograms(): boolean;
    setSuggestions(newSuggestions: TargetSuggestions): void;
    getBinderTarget(): ILEObject;
    getRelative(fullPath: string): string;
    getFull(relativePath: string): string;
    storeResolved(localPath: string, ileObject: ILEObject): void;
    loadProject(options?: {
        withRef?: string;
        additionalExtensions?: string[];
    }): Promise<void>;
    private extCanBeProgram;
    resolvePathToObject(localPath: string, newText?: string): Promise<ILEObject | undefined>;
    /**
     * 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>;
    handleNewRefObject(ileObject: ILEObject): void;
    isReferenceObject(ileObject: ILEObject, remove?: boolean): boolean;
    getAllHeaders(): string[];
    getAffectedByHeader(headers: string[]): ILEObject[];
    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): Promise<string>;
    getObjectType(relativePath: string, ext: string): ObjectType | undefined;
    loadObjectsFromPaths(paths: string[]): Promise<ILEObject[]>;
    parseFile(filePath: string): Promise<boolean>;
    getTarget(object: ILEObject): ILEObjectTarget | undefined;
    getTargets(): ILEObjectTarget[];
    resolveBinder(): void;
    private convertBoundProgramToMultiModuleProgram;
    createOrAppend(parentObject: ILEObject, newDep?: ILEObject): ILEObjectTarget;
    addNewTarget(dep: ILEObjectTarget): void;
    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;
    };
    /**
     * Returns a list of objects that will be impacted if the given object is changed.
     */
    getImpactFor(theObject: ILEObject): ImpactedObject;
    /**
     * Returns a list of all the required objects to build this target
     */
    getRequiredChildren(bases: (ILEObject | ILEObjectTarget)[]): ILEObject[];
    /**
     * 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.
     */
    private sqlObjectDataFromPath;
}