@ui5/task-adaptation 1.6.2 → 1.6.4-rc.1

package/dist/repositories/localRepository.js

@@ -0,0 +1,62 @@
+import { getLogger } from "@ui5/logger";
+import path from "node:path";
+import fs from "node:fs/promises";
+import FsUtil from "../util/fsUtil.js";
+const log = getLogger("@ui5/task-adaptation::LocalRepository");
+export default class LocalRepository {
+    configuration;
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    async downloadAnnotationFile(_uri) {
+        log.verbose("Downloading annotation files is not supported in LocalRepository.");
+        return new Map();
+    }
+    async getAppVariantIdHierarchy(appId) {
+        const items = [];
+        await this.collectAppVariantIdHierarchyItems(appId, items);
+        return items;
+    }
+    fetch(appId, _cachebusterToken) {
+        return this.readFilesInBaseAppDir(appId);
+    }
+    fetchReuseLib(libName, _cachebusterToken, _lib) {
+        return this.readFilesInBaseAppDir(libName);
+    }
+    async collectAppVariantIdHierarchyItems(appId, items) {
+        items.push({
+            appVariantId: appId,
+            repoName: appId,
+            cachebusterToken: "local"
+        });
+        const appDir = this.getLocalFilesDirectory(appId);
+        const filenames = ["manifest.json", "manifest.appdescr_variant"];
+        const filepaths = filenames.map((filename) => path.join(appDir, filename));
+        const existingManifestPath = await this.getExistingManifestPath(filepaths);
+        if (existingManifestPath.endsWith("manifest.appdescr_variant")) {
+            const manifestContent = await fs.readFile(existingManifestPath, "utf-8");
+            const manifest = JSON.parse(manifestContent);
+            await this.collectAppVariantIdHierarchyItems(manifest.reference, items);
+        }
+    }
+    async getExistingManifestPath(filePaths) {
+        const existenceChecks = await Promise.all(filePaths.map((filePath) => FsUtil.exists(filePath)));
+        const existingIndex = existenceChecks.findIndex((exists) => exists);
+        if (existingIndex !== -1) {
+            return filePaths[existingIndex];
+        }
+        throw new Error(`None of the paths exist: '${filePaths.join("', '")}'.`);
+    }
+    readFilesInBaseAppDir(appId) {
+        const appDir = this.getLocalFilesDirectory(appId);
+        log.verbose(`Fetching base app files from local directory: ${appDir}`);
+        return FsUtil.readFilesRecursively(appDir);
+    }
+    getLocalFilesDirectory(appId) {
+        const baseDir = this.configuration.adpDir
+            ? path.normalize(this.configuration.adpDir).replace(/\\/g, "/").replace(/\/+$/, "").split("/")
+            : [".."];
+        return path.join(process.cwd(), ...baseDir, appId);
+    }
+}
+//# sourceMappingURL=localRepository.js.map

package/dist/repositories/repository.d.ts

@@ -0,0 +1,8 @@
+import { IAppVariantIdHierarchyItem } from "../model/appVariantIdHierarchyItem.js";
+import { IReuseLibInfo } from "../model/types.js";
+export default interface IRepository {
+    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
+    fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
+    fetchReuseLib(libName: string, cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
+    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+}

package/dist/repositories/repository.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repository.js.map

package/dist/util/cf/xsAppJsonUtil.d.ts

@@ -1,4 +1,4 @@
-import { ServiceCredentials } from "../../model/types.js";
+import { IConfiguration, ServiceCredentials } from "../../model/types.js";
 export declare const XSAPP_JSON_FILENAME = "xs-app.json";
 /**
  * Merges multiple xs-app.json contents into one. AppVariant and Reuse Library
@@ -11,3 +11,4 @@ export declare const XSAPP_JSON_FILENAME = "xs-app.json";
 export declare function merge(xsAppFiles: string[]): string | undefined;
 export declare function enhanceRoutesWithEndpointAndService(xsAppJsonContent: string, serviceCredentials: ServiceCredentials): string;
 export declare function enhanceRoutes(serviceCredentials: ServiceCredentials, baseRoutes: any): any;
+export declare function fetchCredentialsAndEnhanceRoutes(xsAppJson: string, { serviceInstanceName, space, appName }: IConfiguration): Promise<string>;

package/dist/util/cf/xsAppJsonUtil.js

@@ -1,4 +1,5 @@
 import { getLogger } from "@ui5/logger";
+import CFUtil from "../cfUtil.js";
 const log = getLogger("@ui5/task-adaptation::XSAppJsonUtil");
 export const XSAPP_JSON_FILENAME = "xs-app.json";
 /**
@@ -78,4 +79,22 @@ export function enhanceRoutes(serviceCredentials, baseRoutes) {
         }
     });
 }
+export async function fetchCredentialsAndEnhanceRoutes(xsAppJson, { serviceInstanceName, space, appName }) {
+    if (!serviceInstanceName) {
+        throw new Error(`Service instance name must be specified in ui5.yaml configuration for app '${appName}'`);
+    }
+    let serviceCredentials;
+    try {
+        // Get valid service keys with proper endpoints structure
+        serviceCredentials = await CFUtil.getOrCreateServiceKeyWithEndpoints(serviceInstanceName, space);
+    }
+    catch (error) {
+        throw new Error(`Failed to get valid service keys for app '${appName}': ${error.message}`);
+    }
+    if (serviceCredentials) {
+        return enhanceRoutesWithEndpointAndService(xsAppJson, serviceCredentials);
+    }
+    log.info(`No endpoints found for app '${appName}'. xs-app.json will not be updated.`);
+    return xsAppJson;
+}
 //# sourceMappingURL=xsAppJsonUtil.js.map

package/dist/util/commonUtil.d.ts

@@ -1,6 +1,7 @@
 import { IConfiguration } from "../model/types.js";
 import Language from "../model/language.js";
 export declare function dotToUnderscore(value: string): string;
+export declare function validateConfiguration<T extends object>(options: T, properties: Array<keyof T>): void;
 export declare function validateObject<T extends object>(options: T, properties: Array<keyof T>, message: string): void;
 export declare function escapeRegex(update: string): string;
 export declare function insertInArray<T>(array: T[], index: number, insert: T): void;

package/dist/util/commonUtil.js

@@ -9,6 +9,9 @@ const MANIFEST_CHANGE = "appdescr_";
 export function dotToUnderscore(value) {
     return value.replace(/\./g, "_");
 }
+export function validateConfiguration(options, properties) {
+    validateObject(options, properties, "should be specified in ui5.yaml configuration");
+}
 export function validateObject(options, properties, message) {
     for (const property of properties) {
         if (!options[property]) {

package/dist/util/fsUtil.d.ts

@@ -6,4 +6,6 @@ export default class FsUtil {
      * @returns true if the path exists, false if not
      */
     private static fileExists;
+    static readFilesRecursively(rootDirectory: string): Promise<Map<string, string>>;
+    static exists(filePath: string): Promise<boolean>;
 }

package/dist/util/fsUtil.js

@@ -36,5 +36,39 @@ export default class FsUtil {
             throw e;
         }
     }
+    static async readFilesRecursively(rootDirectory) {
+        const directoriesToScan = [rootDirectory];
+        const fileReadTasks = [];
+        while (directoriesToScan.length > 0) {
+            const currentDirectory = directoriesToScan.pop();
+            if (!currentDirectory) {
+                continue;
+            }
+            const entries = await fs.readdir(currentDirectory, { withFileTypes: true });
+            for (const entry of entries) {
+                const entryPath = path.join(currentDirectory, entry.name);
+                if (entry.isDirectory()) {
+                    directoriesToScan.push(entryPath);
+                }
+                else if (entry.isFile()) {
+                    fileReadTasks.push((async () => {
+                        const relativeFilePath = path.relative(rootDirectory, entryPath);
+                        const content = await fs.readFile(entryPath, "utf-8");
+                        return [relativeFilePath, content];
+                    })());
+                }
+            }
+        }
+        return new Map(await Promise.all(fileReadTasks));
+    }
+    static async exists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
 }
 //# sourceMappingURL=fsUtil.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ui5/task-adaptation",
-    "version": "1.6.2",
+    "version": "1.6.4-rc.1",
     "description": "Custom task for ui5-builder which allows building UI5 Flexibility Adaptation Projects for SAP BTP, Cloud Foundry environment",
     "main": "index.js",
     "scripts": {
@@ -59,7 +59,6 @@
         "@types/chai-as-promised": "^7.1.4",
         "@types/js-yaml": "^4.0.3",
         "@types/jsdom": "^21.1.6",
-        "@types/lodash": "^4.14.196",
         "@types/mocha": "^9.1.0",
         "@types/semver": "^7.3.8",
         "@types/sinon": "^10.0.16",
@@ -115,7 +114,11 @@
             "src/annotations/transformers/transformer.ts",
             "src/model/configuration.ts",
             "src/model/appVariantIdHierarchyItem.ts",
-            "src/adapters/adapter.ts"
+            "src/adapters/adapter.ts",
+            "src/adapters/previewAdapter.ts",
+            "src/repositories/repository.ts",
+            "src/annotations/annotationManager.ts",
+            "src/processors/processor.ts"
         ],
         "check-coverage": true,
         "statements": 85,

package/scripts/publish.ts

@@ -0,0 +1,256 @@
+import { promises as fs } from "fs";
+import path from "path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { Octokit } from "@octokit/rest";
+import { retry } from "@octokit/plugin-retry";
+
+const OctokitClass = Octokit.plugin(retry);
+
+
+/**
+ * Recursively get all file paths in the workspace root, excluding:
+ *   - test/lib/integration
+ *   - test/fixtures
+ *   - test/expected
+ *   - test/lib/index.perf.ts
+ * Returns relative paths from the root.
+ */
+async function getAllRootFilesExceptTestExclusions(root: string): Promise<string[]> {
+    const excludeDirs = [
+        "test/lib/integration",
+        "test/fixtures",
+        "test/expected",
+        ".git",
+        "coverage",
+        ".DS_Store",
+        "node_modules",
+        ".nyc_output",
+        "coverage",
+        "dist",
+        "dist-debug",
+        "dist.zip",
+        ".env",
+        "test/resources/metadata/download"
+    ];
+    const excludeFiles = [
+        "test/lib/index.perf.ts",
+        "scripts/test-integration-prep.sh",
+        "Jenkinsfile"
+    ];
+
+    async function walk(dir: string): Promise<string[]> {
+        const dirents = await fs.readdir(dir, { withFileTypes: true });
+        const files: string[] = [];
+        for (const dirent of dirents) {
+            const relPath = path.relative(root, path.join(dir, dirent.name));
+            if (excludeDirs.some(ex => relPath === ex || relPath.startsWith(ex + path.sep))) {
+                continue;
+            }
+            if (excludeFiles.includes(relPath)) {
+                continue;
+            }
+            if (dirent.isDirectory()) {
+                files.push(...await walk(path.join(dir, dirent.name)));
+            } else {
+                files.push(relPath);
+            }
+        }
+        return files;
+    }
+    return walk(root);
+}
+
+const FILES = await getAllRootFilesExceptTestExclusions(process.cwd());
+
+
+interface PublishArgs {
+    p?: string;
+    dryRun?: boolean;
+    tag?: string;
+    branch?: string;
+    [key: string]: unknown;
+}
+
+async function publish() {
+    const argv = yargs(hideBin(process.argv))
+        .option("p", {
+            type: "string",
+            description: "GitHub token (-p)",
+            alias: "p"
+        })
+        .option("dryRun", {
+            type: "boolean",
+            description: "Run without publishing",
+            default: false
+        })
+        .option("tag", {
+            type: "string",
+            description: "Publish with a specific tag"
+        })
+        .option("branch", {
+            type: "string",
+            description: "Branch to update (default: main)",
+            default: "main",
+            alias: "b"
+        })
+        .help()
+        .alias("h", "help")
+        .parseSync() as PublishArgs;
+
+    if (argv.dryRun) {
+        console.log("Dry run: no publishing will be performed.");
+        return;
+    }
+    const auth = argv.p;
+    if (auth) {
+        const octokit = new OctokitClass({ auth });
+        const ORGANIZATION = "SAP";
+        const REPO = "ui5-task-adaptation";
+        await uploadToRepo(octokit, ORGANIZATION, REPO, argv.branch);
+        if (argv.tag) {
+            console.log(`Published with tag: ${argv.tag}`);
+        }
+    } else {
+        console.log("Github token is not provided.");
+    }
+}
+
+
+async function getLatestVersion(): Promise<string> {
+    const pkg = await fs.readFile(path.join(process.cwd(), "package.json"), { encoding: "utf-8" });
+    const pkgJson = JSON.parse(pkg);
+    return pkgJson.version;
+}
+
+
+async function uploadToRepo(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    branch: string = "main"
+): Promise<void> {
+    const fileBlobs = await Promise.all(Object.values(FILES).map(file => toBlob(octokit, org, repo, path.join(process.cwd(), file))));
+    const currentCommit = await getCurrentCommit(octokit, org, repo, branch);
+    const newTree = await createNewTree(
+        octokit,
+        org,
+        repo,
+        fileBlobs,
+        FILES,
+        currentCommit.treeSha
+    );
+    const currentVersion = await getLatestVersion();
+    const commitMessage = `Release ${currentVersion}`;
+    const newCommit = await createNewCommit(
+        octokit,
+        org,
+        repo,
+        commitMessage,
+        newTree.sha,
+        currentCommit.commitSha
+    );
+    await setBranchToCommit(octokit, org, repo, branch, newCommit.sha);
+}
+
+
+async function getCurrentCommit(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    branch: string = "main"
+): Promise<{ commitSha: string; treeSha: string }> {
+    const { data: refData } = await octokit.git.getRef({
+        owner: org,
+        repo,
+        ref: `heads/${branch}`,
+    });
+    const commitSha = refData.object.sha
+    const { data: commitData } = await octokit.git.getCommit({
+        owner: org,
+        repo,
+        commit_sha: commitSha,
+    });
+    return {
+        commitSha,
+        treeSha: commitData.tree.sha,
+    }
+}
+
+
+async function toBlob(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    filePath: string
+): Promise<{ sha: string }> {
+    const content = await fs.readFile(filePath, { encoding: "utf8" });
+    const blobData = await octokit.git.createBlob({
+        owner: org,
+        repo,
+        content,
+        encoding: "utf-8",
+    })
+    return blobData.data;
+}
+
+
+async function createNewTree(
+    octokit: InstanceType<typeof OctokitClass>,
+    owner: string,
+    repo: string,
+    blobs: { sha: string }[],
+    paths: string[],
+    parentTreeSha: string
+): Promise<any> {
+    const tree = blobs.map(({ sha }, i) => ({
+        path: paths[i],
+        mode: "100644" as const,
+        type: "blob" as const,
+        sha,
+    }));
+    const { data } = await octokit.git.createTree({
+        owner,
+        repo,
+        tree,
+        base_tree: parentTreeSha,
+    })
+    return data;
+}
+
+
+async function createNewCommit(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    message: string,
+    currentTreeSha: string,
+    currentCommitSha: string
+): Promise<any> {
+    const commit = await octokit.git.createCommit({
+        owner: org,
+        repo,
+        message,
+        tree: currentTreeSha,
+        parents: [currentCommitSha],
+    });
+    return commit.data;
+};
+
+
+async function setBranchToCommit(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    branch: string = "main",
+    commitSha: string
+): Promise<any> {
+    return octokit.git.updateRef({
+        owner: org,
+        repo,
+        ref: `heads/${branch}`,
+        sha: commitSha,
+    });
+}
+
+publish();

package/scripts/test-integration-prep.sh

@@ -0,0 +1,4 @@
+for d in test/fixtures/*/ ; do
+    echo "$d"
+    npm --prefix $d i
+done

package/dist/annotationManager.d.ts

@@ -1,17 +0,0 @@
-import AbapRepoManager from "./repositories/abapRepoManager.js";
-import { IConfiguration } from "./model/types.js";
-import Language from "./model/language.js";
-export interface IAnnotationFiles {
-    annotationName: string;
-    annotationFileName: string;
-}
-export default class AnnotationManager {
-    private abapRepoManager;
-    private configuration;
-    constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager);
-    ANNOTATIONS_FOLDER: string;
-    process(baseAppManifest: any, languages: Language[], appVariantId: string, prefix: string): Promise<Map<string, string>>;
-    private updateManifestModel;
-    private createManifestModel;
-    private enhanceManifestModel;
-}

package/dist/processors/abapProcessor.d.ts

@@ -1,18 +0,0 @@
-import AbapRepoManager from "../repositories/abapRepoManager.js";
-import AnnotationManager from "../annotationManager.js";
-import { IAppVariantIdHierarchyItem } from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration } from "../model/types.js";
-import IProcessor from "./processor.js";
-import { IAdapter } from "../adapters/adapter.js";
-export default class AbapProcessor implements IProcessor {
-    private abapRepoManager;
-    private configuration;
-    private annotationManager;
-    constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager, annotationManager: AnnotationManager);
-    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
-    getAdapter(): IAdapter;
-    fetch(repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
-    fetchReuseLib(): Promise<Map<string, string>>;
-    validateConfiguration(): void;
-    getConfigurationType(): string;
-}

package/dist/processors/abapProcessor.js

@@ -1,43 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { cached } from "../cache/cacheHolder.js";
-import { validateObject } from "../util/commonUtil.js";
-import AbapAdapter from "../adapters/abapAdapter.js";
-export default class AbapProcessor {
-    abapRepoManager;
-    configuration;
-    annotationManager;
-    constructor(configuration, abapRepoManager, annotationManager) {
-        this.configuration = configuration;
-        this.abapRepoManager = abapRepoManager;
-        this.annotationManager = annotationManager;
-    }
-    getAppVariantIdHierarchy(appId) {
-        return this.abapRepoManager.getAppVariantIdHierarchy(appId);
-    }
-    getAdapter() {
-        return new AbapAdapter(this.configuration, this.annotationManager);
-    }
-    fetch(repoName, _cachebusterToken) {
-        return this.abapRepoManager.fetch(repoName);
-    }
-    fetchReuseLib() {
-        throw new Error("Preview is not available on SAP S/4HANA On-Premise or Cloud Systems. Please create a ticket on CA-UI5-FL-ADP-BAS component.");
-    }
-    validateConfiguration() {
-        // validate general app config
-        const properties = ["appName"];
-        validateObject(this.configuration, properties, "should be specified in ui5.yaml configuration");
-    }
-    getConfigurationType() {
-        return "abap";
-    }
-}
-__decorate([
-    cached()
-], AbapProcessor.prototype, "fetch", null);
-//# sourceMappingURL=abapProcessor.js.map

package/dist/processors/cfProcessor.d.ts

@@ -1,14 +0,0 @@
-import { IAppVariantIdHierarchyItem } from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration, IReuseLibInfo } from "../model/types.js";
-import IProcessor from "./processor.js";
-import { IAdapter } from "../adapters/adapter.js";
-export default class CFProcessor implements IProcessor {
-    protected configuration: IConfiguration;
-    constructor(configuration: IConfiguration);
-    getAdapter(): IAdapter;
-    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
-    fetch(_repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
-    fetchReuseLib(_libName: string, _cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
-    validateConfiguration(): void;
-    getConfigurationType(): string;
-}

package/dist/processors/cfProcessor.js

@@ -1,46 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import HTML5RepoManager from "../repositories/html5RepoManager.js";
-import { cached } from "../cache/cacheHolder.js";
-import { validateObject } from "../util/commonUtil.js";
-import CFAdapter from "../adapters/cfAdapter.js";
-export default class CFProcessor {
-    configuration;
-    constructor(configuration) {
-        this.configuration = configuration;
-    }
-    getAdapter() {
-        return new CFAdapter(this.configuration);
-    }
-    async getAppVariantIdHierarchy(appId) {
-        const metadata = await HTML5RepoManager.getMetadata(this.configuration);
-        return [{
-                repoName: this.configuration.appName,
-                appVariantId: appId,
-                cachebusterToken: metadata.changedOn
-            }];
-    }
-    fetch(_repoName, _cachebusterToken) {
-        return HTML5RepoManager.getBaseAppFiles(this.configuration);
-    }
-    fetchReuseLib(_libName, _cachebusterToken, lib) {
-        return HTML5RepoManager.getReuseLibFiles(this.configuration, lib);
-    }
-    validateConfiguration() {
-        validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
-    }
-    getConfigurationType() {
-        return "cf";
-    }
-}
-__decorate([
-    cached()
-], CFProcessor.prototype, "fetch", null);
-__decorate([
-    cached()
-], CFProcessor.prototype, "fetchReuseLib", null);
-//# sourceMappingURL=cfProcessor.js.map

package/dist/processors/previewProcessor.d.ts

@@ -1,8 +0,0 @@
-import { IAdapter } from "../adapters/adapter.js";
-import { IConfiguration } from "../model/types.js";
-import CFProcessor from "./cfProcessor.js";
-import IProcessor from "./processor.js";
-export default class PreviewProcessor extends CFProcessor implements IProcessor {
-    constructor(configuration: IConfiguration);
-    getAdapter(): IAdapter;
-}

package/dist/processors/previewProcessor.js

@@ -1,11 +0,0 @@
-import PreviewAdapter from "../adapters/previewAdapter.js";
-import CFProcessor from "./cfProcessor.js";
-export default class PreviewProcessor extends CFProcessor {
-    constructor(configuration) {
-        super(configuration);
-    }
-    getAdapter() {
-        return new PreviewAdapter(this.configuration);
-    }
-}
-//# sourceMappingURL=previewProcessor.js.map

package/dist/processors/processor.d.ts

@@ -1,10 +0,0 @@
-import { IAppVariantIdHierarchyItem } from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration, IReuseLibInfo } from "../model/types.js";
-import { IAdapter } from "../adapters/adapter.js";
-export default interface IProcessor {
-    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
-    getAdapter(): IAdapter;
-    fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
-    fetchReuseLib(repoName: string, cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
-}
-export declare function determineProcessor(configuration: IConfiguration): IProcessor;