@speedkit/cli 2.4.1

package/dist/services/integration-api/error/handler/customer-config-legacy-handler.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const customer_config_legacy_error_1 = tslib_1.__importDefault(require("../customer-config-legacy-error"));
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class CustomerConfigLegacyHandler {
+    canHandle(error) {
+        return error instanceof customer_config_legacy_error_1.default;
+    }
+    handle(error) {
+        core_1.ux.log();
+        core_1.ux.log(chalk_1.default.red(`config ${chalk_1.default.bold.white(error.context.configName)} not found`));
+        core_1.ux.log();
+        core_1.ux.log(chalk_1.default.italic("Is this still a legacy customer config format?"));
+        core_1.ux.log(chalk_1.default.italic("Make sure to export the different app configs under their config names like:"));
+        core_1.ux.log();
+        core_1.ux.log(chalk_1.default.bgBlack.hidden(" module.exports = { production, staging } "));
+        core_1.ux.log(chalk_1.default.bgBlack.white(" module.exports = { production, staging } "));
+        core_1.ux.log(chalk_1.default.bgBlack.hidden(" module.exports = { production, staging } "));
+        core_1.ux.exit(1);
+    }
+}
+exports.default = CustomerConfigLegacyHandler;

package/dist/services/integration-api/error/handler/origin-handler.d.ts

@@ -0,0 +1,6 @@
+import ErrorHandlerInterface from "../../../error-handling/interface/error-handler-interface";
+import OriginError from "../origin-error";
+export default class OriginHandler implements ErrorHandlerInterface {
+    canHandle(error: Error): boolean;
+    handle(error: OriginError): void;
+}

package/dist/services/integration-api/error/handler/origin-handler.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const origin_error_1 = tslib_1.__importDefault(require("../origin-error"));
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class OriginHandler {
+    canHandle(error) {
+        return error instanceof origin_error_1.default;
+    }
+    handle(error) {
+        core_1.ux.log();
+        core_1.ux.log(chalk_1.default.red(error.context.message));
+        core_1.ux.log();
+        core_1.ux.log(chalk_1.default.italic("Example entry:"));
+        core_1.ux.log(chalk_1.default.bgBlack.hidden(" origins: ['https://speedkit.com', 'https://baqend.com'], "));
+        core_1.ux.log(chalk_1.default.bgBlack.white(" origins: ['https://speedkit.com', 'https://baqend.com'], "));
+        core_1.ux.log(chalk_1.default.bgBlack.hidden(" origins: ['https://speedkit.com', 'https://baqend.com'], "));
+        core_1.ux.exit(1);
+    }
+}
+exports.default = OriginHandler;

package/dist/services/integration-api/error/load-customer-error.d.ts

@@ -0,0 +1,4 @@
+import DeployAppError from "../../deploy/error/deploy-app-error";
+export default class LoadCustomerError extends DeployAppError {
+    constructor(customerPath: string);
+}

package/dist/services/integration-api/error/load-customer-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const deploy_app_error_1 = tslib_1.__importDefault(require("../../deploy/error/deploy-app-error"));
+class LoadCustomerError extends deploy_app_error_1.default {
+    constructor(customerPath) {
+        super(`Could not resolve customer app name in ${customerPath}`);
+    }
+}
+exports.default = LoadCustomerError;

package/dist/services/integration-api/error/mandatory-file-missing-error.d.ts

@@ -0,0 +1,3 @@
+export default class MandatoryFileMissingError extends Error {
+    constructor(fileName: string);
+}

package/dist/services/integration-api/error/mandatory-file-missing-error.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MandatoryFileMissingError extends Error {
+    constructor(fileName) {
+        super(`Mandatory file "${fileName}" is missing`);
+    }
+}
+exports.default = MandatoryFileMissingError;

package/dist/services/integration-api/error/origin-error.d.ts

@@ -0,0 +1,3 @@
+import ApplicationError from "../../error-handling/error/application-error";
+export default class OriginError extends ApplicationError {
+}

package/dist/services/integration-api/error/origin-error.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const application_error_1 = tslib_1.__importDefault(require("../../error-handling/error/application-error"));
+class OriginError extends application_error_1.default {
+}
+exports.default = OriginError;

package/dist/services/integration-api/external/external-file-reader.d.ts

@@ -0,0 +1,4 @@
+import { RoFile } from "../struct/ro-file";
+export declare class ExternalFileReader {
+    load(assetName: string): Promise<RoFile>;
+}

package/dist/services/integration-api/external/external-file-reader.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalFileReader = void 0;
+const tslib_1 = require("tslib");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const ro_file_1 = require("../struct/ro-file");
+class ExternalFileReader {
+    async load(assetName) {
+        const response = await (0, node_fetch_1.default)(assetName);
+        if (!response.ok) {
+            throw new Error(`Could not retrieve asset "${assetName}". Server respond with ${response.status} ${response.statusText}`);
+        }
+        const [fileName, extension] = assetName.split('/').pop().split('.');
+        return new ro_file_1.RoFile(fileName, assetName, await response.text());
+    }
+}
+exports.ExternalFileReader = ExternalFileReader;

package/dist/services/integration-api/factory/integration-api-service-factory.d.ts

@@ -0,0 +1,13 @@
+import IntegrationApiService from "../integration-api-service";
+import { IntegrationApiContextInterface } from "../integration-api-model";
+import { UserCliConfig } from "../../../helpers/cli-config";
+export default class IntegrationApiServiceFactory {
+    private context;
+    private cliConfig;
+    service?: IntegrationApiService;
+    private fileReader?;
+    constructor(context: IntegrationApiContextInterface, cliConfig: UserCliConfig);
+    buildService(): IntegrationApiService;
+    private build;
+    private getFileReader;
+}

package/dist/services/integration-api/factory/integration-api-service-factory.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const context_runtime_error_1 = tslib_1.__importDefault(require("../../context/error/context-runtime-error"));
+const integration_api_service_1 = tslib_1.__importDefault(require("../integration-api-service"));
+const file_reader_1 = tslib_1.__importDefault(require("../file-reader"));
+const mandatory_files_validator_1 = tslib_1.__importDefault(require("../validator/mandatory-files-validator"));
+const customer_config_handler_1 = tslib_1.__importDefault(require("../handler/customer-config-handler"));
+const customer_config_validator_1 = tslib_1.__importDefault(require("../validator/customer-config-validator"));
+const install_resource_handler_1 = tslib_1.__importDefault(require("../handler/install-resource-handler"));
+const module_handler_1 = tslib_1.__importDefault(require("../handler/module-handler"));
+const server_config_handler_1 = tslib_1.__importDefault(require("../handler/server-config-handler"));
+const file_writer_1 = tslib_1.__importDefault(require("../file-writer"));
+const cli_1 = require("../../cli");
+const virtual_file_handler_1 = require("../virtual/virtual-file-handler");
+class IntegrationApiServiceFactory {
+    context;
+    cliConfig;
+    service = undefined;
+    fileReader;
+    constructor(context, cliConfig) {
+        this.context = context;
+        this.cliConfig = cliConfig;
+    }
+    buildService() {
+        if (!(this.service instanceof integration_api_service_1.default)) {
+            this.build();
+        }
+        return this.service;
+    }
+    build() {
+        if (!this.context.basePath) {
+            throw new context_runtime_error_1.default({ message: 'basePath is undefined' });
+        }
+        if (!this.context.configName) {
+            throw new context_runtime_error_1.default({ message: 'configName is undefined' });
+        }
+        const fileReader = this.getFileReader();
+        const cli = (new cli_1.CliServiceFactory()).getService();
+        const virtualFileHandler = new virtual_file_handler_1.VirtualFileHandler(cli);
+        this.service = new integration_api_service_1.default(fileReader, virtualFileHandler, new mandatory_files_validator_1.default(), [
+            new customer_config_handler_1.default(fileReader, cli, new customer_config_validator_1.default(), this.context.configName, this.cliConfig.testApp),
+            new install_resource_handler_1.default(fileReader),
+            new server_config_handler_1.default(fileReader),
+            new module_handler_1.default(fileReader),
+        ], new file_writer_1.default(this.context.basePath), this.context.whiteList.length < 1);
+    }
+    getFileReader() {
+        if (!this.fileReader) {
+            this.fileReader = new file_reader_1.default(this.context.configName, this.context.basePath, this.context.whiteList, this.context.blockedFolders);
+        }
+        return this.fileReader;
+    }
+}
+exports.default = IntegrationApiServiceFactory;

package/dist/services/integration-api/file-list.d.ts

@@ -0,0 +1,18 @@
+import { CustomerConfigInterface, FileInterface, FileListInterface, InstallResourceInterface, ModuleInterface, ServerConfigInterface } from "./integration-api-model";
+import { RoFile } from "./struct/ro-file";
+import { VirtualFile } from "./struct/virtual-file";
+export default class FileList implements FileListInterface {
+    files: FileInterface[];
+    addFile(file: FileInterface): void;
+    hasFile(fileName: string): boolean;
+    getInstallResources(): InstallResourceInterface[];
+    getModules(): ModuleInterface[];
+    getServerConfig(): ServerConfigInterface;
+    getCustomerConfig(): CustomerConfigInterface;
+    getTypes(): any[];
+    getByType(type: any): FileInterface[];
+    getByName<T>(name: string): T;
+    filter(callback: (file: FileInterface) => boolean): void;
+    concat(fileList: FileListInterface): void;
+    replace(replaceWith: InstallResourceInterface | ModuleInterface | ServerConfigInterface | FileInterface | RoFile | VirtualFile): void;
+}

package/dist/services/integration-api/file-list.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const module_file_1 = tslib_1.__importDefault(require("./struct/module-file"));
+const server_config_file_1 = tslib_1.__importDefault(require("./struct/server-config-file"));
+const customer_config_file_1 = tslib_1.__importDefault(require("./struct/customer-config-file"));
+const install_resource_file_1 = tslib_1.__importDefault(require("./struct/install-resource-file"));
+class FileList {
+    files = [];
+    addFile(file) {
+        this.files.push(file);
+    }
+    hasFile(fileName) {
+        for (let iteration = 0; iteration < this.files.length; iteration++) {
+            let file = this.files[iteration];
+            if (file.name === fileName) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getInstallResources() {
+        return this.files.filter((file) => {
+            return file instanceof install_resource_file_1.default;
+        });
+    }
+    getModules() {
+        return this.files.filter((file) => {
+            return file instanceof module_file_1.default;
+        });
+    }
+    getServerConfig() {
+        const configFiles = this.files.filter((file) => {
+            return file instanceof server_config_file_1.default;
+        });
+        return configFiles.shift();
+    }
+    getCustomerConfig() {
+        const configFiles = this.files.filter((file) => {
+            return file instanceof customer_config_file_1.default;
+        });
+        return configFiles.shift();
+    }
+    getTypes() {
+        const types = this.files.map((file) => {
+            return file.type;
+        }).sort();
+        return [...new Set(types)];
+    }
+    getByType(type) {
+        return this.files.filter((file) => {
+            return file instanceof type;
+        });
+    }
+    getByName(name) {
+        const files = this.files.filter((file) => {
+            return file.name === name;
+        });
+        return files[0];
+    }
+    filter(callback) {
+        this.files = this.files.filter((file) => callback(file));
+    }
+    concat(fileList) {
+        fileList.files.forEach(file => this.files.push(file));
+    }
+    replace(replaceWith) {
+        const files = [];
+        for (const file of this.files) {
+            if (file.name === replaceWith.name) {
+                files.push(replaceWith);
+                continue;
+            }
+            files.push(file);
+        }
+        this.files = files;
+    }
+}
+exports.default = FileList;

package/dist/services/integration-api/file-reader.d.ts

@@ -0,0 +1,15 @@
+export default class FileReader {
+    readonly configName: string;
+    private readonly basePath;
+    private readonly whiteList;
+    private readonly blockedFolders;
+    allowedExtensions: string[];
+    constructor(configName: string, basePath: string, whiteList?: string[], blockedFolders?: string[]);
+    getFileList(dirName?: string): Promise<string[]>;
+    getContent(path: string): Promise<string>;
+    isAllowedFolder(folderName: string): boolean;
+    isAllowedFile(fileName: string): boolean;
+    getFileExtension(fileName: string): string;
+    isWhiteListed(fileName: string): boolean;
+    private mapEnvironment;
+}

package/dist/services/integration-api/file-reader.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const promises_1 = require("fs/promises");
+const CUSTOMER_CONFIG_FILE = 'config_customer';
+const DEFAULT_ENV = 'production';
+class FileReader {
+    configName;
+    basePath;
+    whiteList;
+    blockedFolders;
+    allowedExtensions = ['js', 'es6', 'json', 'css'];
+    constructor(configName, basePath, whiteList = [], blockedFolders = []) {
+        this.configName = configName;
+        this.basePath = basePath;
+        this.whiteList = whiteList;
+        this.blockedFolders = blockedFolders;
+    }
+    async getFileList(dirName = this.basePath) {
+        let files = [];
+        const items = await fs_1.promises.readdir(dirName, { withFileTypes: true });
+        for (const item of items) {
+            if (item.isDirectory()) {
+                if (this.isAllowedFolder(item.name)) {
+                    files = [
+                        ...files,
+                        ...(await this.getFileList(path_1.default.resolve(dirName, item.name))),
+                    ];
+                }
+                continue;
+            }
+            if (this.isAllowedFile(item.name)) {
+                files.push(path_1.default.resolve(dirName, item.name));
+            }
+        }
+        return this.mapEnvironment(files);
+    }
+    async getContent(path) {
+        return (0, promises_1.readFile)(path, 'utf-8');
+    }
+    isAllowedFolder(folderName) {
+        return !this.blockedFolders.some((entry) => {
+            return folderName.includes(entry);
+        });
+    }
+    isAllowedFile(fileName) {
+        const extension = this.getFileExtension(fileName);
+        return this.allowedExtensions.indexOf(extension) !== -1 && this.isWhiteListed(fileName);
+    }
+    getFileExtension(fileName) {
+        return fileName.slice((fileName.lastIndexOf(".") - 1 >>> 0) + 2);
+    }
+    isWhiteListed(fileName) {
+        // always true if whitelist is empty
+        if (this.whiteList.length === 0) {
+            return true;
+        }
+        // customer_config is always whitelisted
+        if (fileName.includes(CUSTOMER_CONFIG_FILE)) {
+            return true;
+        }
+        return this.whiteList.some(entry => {
+            return fileName.includes(entry);
+        });
+    }
+    mapEnvironment(fileList) {
+        const envFileList = {};
+        // create mapped object with all environment versions of a file
+        for (let index = 0; index < fileList.length; index++) {
+            const shortFileName = path_1.default.basename(fileList[index]);
+            const fullFileName = fileList[index];
+            let fileName = shortFileName.split('.').slice(0, -1).join('.');
+            let env = fileName.split('.').pop();
+            if (env === fileName) {
+                env = DEFAULT_ENV;
+            }
+            const fileKey = (env === DEFAULT_ENV) ? fileName : fileName.split('.').slice(0, -1).join('.');
+            envFileList[fileKey] = { ...envFileList[fileKey], [env]: fullFileName };
+        }
+        // map object to current environment with fallback on production
+        return Array.from(Object.values(envFileList)).map((envFile) => {
+            if (this.configName in envFile) {
+                return envFile[this.configName];
+            }
+            if (DEFAULT_ENV in envFile) {
+                return envFile[DEFAULT_ENV];
+            }
+            // if no env was found return original fileName
+            for (const key in envFile) {
+                return envFile[key];
+            }
+        }).filter(value => !!value);
+    }
+}
+exports.default = FileReader;

package/dist/services/integration-api/file-writer.d.ts

@@ -0,0 +1,9 @@
+export default class FileWriter {
+    basePath: string;
+    constructor(basePath: string);
+    writeFile(fileName: string, extension: string, content: string): void;
+    mkdir(directoryPath: string): void;
+    hasFile(fileName: string, extension: string): boolean;
+    removeFile(fileName: string, extension: string): void;
+    private getPath;
+}

package/dist/services/integration-api/file-writer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const node_fs_1 = require("node:fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+class FileWriter {
+    basePath;
+    constructor(basePath) {
+        this.basePath = basePath;
+    }
+    writeFile(fileName, extension, content) {
+        (0, node_fs_1.writeFileSync)(this.getPath(fileName, extension), content);
+    }
+    mkdir(directoryPath) {
+        (0, node_fs_1.mkdirSync)(path_1.default.resolve(this.basePath, directoryPath), { recursive: true });
+    }
+    hasFile(fileName, extension) {
+        return (0, node_fs_1.existsSync)(this.getPath(fileName, extension));
+    }
+    removeFile(fileName, extension) {
+        (0, node_fs_1.unlinkSync)(this.getPath(fileName, extension));
+    }
+    getPath(fileName, extension) {
+        return path_1.default.resolve(this.basePath, `${fileName}.${extension}`);
+    }
+}
+exports.default = FileWriter;

package/dist/services/integration-api/handler/customer-config-handler.d.ts

@@ -0,0 +1,16 @@
+import FileHandler from "./file-handler";
+import FileReader from "../file-reader";
+import CustomerConfigValidator from "../validator/customer-config-validator";
+import { CliService } from "../../cli";
+import { CustomerConfigInterface } from "../integration-api-model";
+export default class CustomerConfigHandler extends FileHandler {
+    private cli;
+    private validator;
+    private configName;
+    private testApp?;
+    allowedFile: string;
+    constructor(fileReader: FileReader, cli: CliService, validator: CustomerConfigValidator, configName: string, testApp?: string);
+    canHandle(filePath: string): boolean;
+    handle(filePath: string): Promise<CustomerConfigInterface>;
+    private loadConfig;
+}

package/dist/services/integration-api/handler/customer-config-handler.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_handler_1 = tslib_1.__importDefault(require("./file-handler"));
+const customer_config_file_1 = tslib_1.__importDefault(require("../struct/customer-config-file"));
+const customer_config_1 = tslib_1.__importDefault(require("../struct/customer-config"));
+const customer_config_legacy_error_1 = tslib_1.__importDefault(require("../error/customer-config-legacy-error"));
+const vm = tslib_1.__importStar(require("vm"));
+const customer_config_error_1 = tslib_1.__importDefault(require("../error/customer-config-error"));
+class CustomerConfigHandler extends file_handler_1.default {
+    cli;
+    validator;
+    configName;
+    testApp;
+    allowedFile = 'config_customer';
+    constructor(fileReader, cli, validator, configName, testApp) {
+        super(fileReader);
+        this.cli = cli;
+        this.validator = validator;
+        this.configName = configName;
+        this.testApp = testApp;
+    }
+    canHandle(filePath) {
+        return this.allowedFile === this.getFileName(filePath);
+    }
+    async handle(filePath) {
+        const fileContent = await this.fileReader.getContent(filePath);
+        const config = await this.loadConfig(fileContent);
+        this.validator.validate(config);
+        return new customer_config_file_1.default(this.getFileName(filePath), filePath, fileContent, config, this.configName);
+    }
+    async loadConfig(fileContent) {
+        if (fileContent.includes('process.env.TEST_APP') && (this.testApp === null) || this.testApp.length === 0) {
+            throw new customer_config_error_1.default('please specify env TEST_APP in your .env or configFile file');
+        }
+        const customerConfigContext = {
+            module: { exports: {} },
+            process: {
+                env: { TEST_APP: this.testApp } // make TEST_APP available for vm
+            }
+        };
+        vm.runInNewContext(fileContent, customerConfigContext);
+        const configs = customerConfigContext?.module?.exports;
+        if (Array.isArray(configs) || typeof configs === 'string' || 'origins' in configs || 'name' in configs) {
+            throw new customer_config_legacy_error_1.default({ configName: this.configName });
+        }
+        if (this.configName in configs) {
+            return customer_config_1.default.createFrom(configs[this.configName], this.configName);
+        }
+        this.cli.writeWarning(`config: ${this.configName} does not exist.`);
+        const selectedConfig = await this.cli.select('please select config: ', Object.keys(configs).map(option => ({ name: option, value: option })));
+        return customer_config_1.default.createFrom(configs[selectedConfig], selectedConfig);
+    }
+}
+exports.default = CustomerConfigHandler;

package/dist/services/integration-api/handler/file-handler.d.ts

@@ -0,0 +1,9 @@
+import FileReader from "../file-reader";
+import { FileInterface, IntegrationApiHandler } from "../integration-api-model";
+export default abstract class FileHandler implements IntegrationApiHandler {
+    protected fileReader: FileReader;
+    constructor(fileReader: FileReader);
+    canHandle(filePath: string): boolean;
+    abstract handle(filePath: string): Promise<FileInterface>;
+    protected getFileName(path: string): string;
+}

package/dist/services/integration-api/handler/file-handler.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FileHandler {
+    fileReader;
+    constructor(fileReader) {
+        this.fileReader = fileReader;
+    }
+    canHandle(filePath) {
+        return false;
+    }
+    getFileName(path) {
+        let fileName = path.replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.');
+        // remove environmentName for internal references
+        if (fileName.split('.').pop() === this.fileReader.configName) {
+            fileName = fileName.split('.').slice(0, -1).join('.');
+        }
+        return fileName;
+    }
+}
+exports.default = FileHandler;

package/dist/services/integration-api/handler/install-resource-handler.d.ts

@@ -0,0 +1,33 @@
+import FileHandler from "./file-handler";
+import { InstallResourceInterface } from "../integration-api-model";
+export default class InstallResourceHandler extends FileHandler {
+    allowedFiles: string[];
+    readonly remoteKeyMapping: {
+        config_SpeedKit: string;
+        config_documentHandler: string;
+        config_dynamicBlocks: string;
+        config_loadHandler: string;
+        custom_loader: string;
+        custom_sw: string;
+        custom_documentHandler: string;
+        custom_dynamicFetcher: string;
+        config_dynamicStyles: string;
+    };
+    canHandle(filePath: string): boolean;
+    handle(filePath: string): Promise<InstallResourceInterface>;
+    private getRemoteKey;
+    /**
+     *
+     * @param fileName
+     * @param filePath
+     * @private
+     */
+    private getFileContent;
+    /**
+     *
+     *
+     * @param content
+     * @private
+     */
+    private replaceWithDebugPackage;
+}

package/dist/services/integration-api/handler/install-resource-handler.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_handler_1 = tslib_1.__importDefault(require("./file-handler"));
+const install_resource_file_1 = tslib_1.__importDefault(require("../struct/install-resource-file"));
+const application_error_1 = tslib_1.__importDefault(require("../../error-handling/error/application-error"));
+const PREDICTIVE_PRELOADING = 'predictive-preloading';
+class InstallResourceHandler extends file_handler_1.default {
+    allowedFiles = [
+        'config_SpeedKit',
+        'config_documentHandler',
+        'config_dynamicBlocks',
+        'config_loadHandler',
+        'custom_loader',
+        'custom_sw',
+        'custom_documentHandler',
+        'custom_dynamicFetcher',
+        'config_dynamicStyles',
+    ];
+    remoteKeyMapping = {
+        'config_SpeedKit': 'config',
+        'config_documentHandler': 'documentHandlerConfig',
+        'config_dynamicBlocks': 'dynamicFetcherConfig',
+        'config_loadHandler': 'custom',
+        'custom_loader': 'loader',
+        'custom_sw': 'sw',
+        'custom_documentHandler': 'documentHandler',
+        'custom_dynamicFetcher': 'dynamicFetcher',
+        'config_dynamicStyles': 'customStyle',
+    };
+    canHandle(filePath) {
+        return this.allowedFiles.indexOf(this.getFileName(filePath)) !== -1;
+    }
+    async handle(filePath) {
+        const fileName = this.getFileName(filePath);
+        return new install_resource_file_1.default(fileName, filePath, await this.getFileContent(fileName, filePath), this.getRemoteKey(fileName));
+    }
+    getRemoteKey(fileName) {
+        if (!this.remoteKeyMapping[fileName]) {
+            throw new application_error_1.default({ message: `unknown fileName ${fileName}` });
+        }
+        return this.remoteKeyMapping[fileName];
+    }
+    /**
+     *
+     * @param fileName
+     * @param filePath
+     * @private
+     */
+    async getFileContent(fileName, filePath) {
+        const content = await this.fileReader.getContent(filePath);
+        if (fileName === 'config_loadHandler' && content.includes(PREDICTIVE_PRELOADING)) {
+            return this.replaceWithDebugPackage(content);
+        }
+        return content;
+    }
+    /**
+     *
+     *
+     * @param content
+     * @private
+     */
+    replaceWithDebugPackage(content) {
+        return content.replace(PREDICTIVE_PRELOADING, `${PREDICTIVE_PRELOADING}.debug.min.js`);
+    }
+}
+exports.default = InstallResourceHandler;