@stechquick/symphony-cli 0.2.271

package/lib/helpers/npmHelper.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmHelper = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const fileHelper_1 = require("@stechquick/symphony-common/lib/helpers/fileHelper");
+const path = tslib_1.__importStar(require("path"));
+const initHelper_1 = require("./initHelper");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+class NpmHelper {
+    static install(settings) {
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Install starting, please wait...") });
+        child_process_1.execSync(`cd ${settings.folderName} && npm install`, { stdio: 'inherit' });
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Install finished successfully.") });
+    }
+    static build(settings) {
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Build starting, please wait...") });
+        this.execCommand(this.BUILD_CMD, settings);
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Build finished successfully.") });
+    }
+    static buildWebpack(settings) {
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Webpack starting, please wait...") });
+        this.execCommand(this.WEBPACK_CMD, settings);
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Webpack finished successfully.") });
+    }
+    static run(environment, settings) {
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Function starting, please wait..."), timeFormat: "datetime" });
+        if (!initHelper_1.InitHelper.AssertInFolder()) {
+            return;
+        }
+        if (settings.build) {
+            this.build();
+        }
+        const args = [path.resolve('./dist/local')];
+        if (settings.debug) {
+            args.unshift('--inspect-brk');
+        }
+        const customArgs = {
+            httpPort: settings.httpPort,
+            httpsPort: settings.httpsPort,
+            hostedPath: settings.hostedPath,
+        };
+        args.push(JSON.stringify(customArgs));
+        log_1.Logger.log({ message: "spawning with: ", additional: args });
+        child_process_1.spawnSync("node", args, { env: Object.assign(process.env, { NODE_ENV: environment }), stdio: 'inherit' });
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Function started successfully."), timeFormat: "datetime" });
+    }
+    static getCurrentPackageVersions() {
+        let retVal = {};
+        const list = child_process_1.execSync("npm list --depth=0", { encoding: "utf8" });
+        if (list && list.length > 0) {
+            const lines = list.split("\n");
+            lines.forEach(line => {
+                if (line.indexOf("@") > -1 && line.indexOf("-- ") > -1) {
+                    const lineValues = line.split("@");
+                    const name = lineValues[lineValues.length - 2].replace("+-- ", "").replace("`-- ", "").replace(" invalid", "");
+                    const version = lineValues[lineValues.length - 1];
+                    retVal[name] = version;
+                }
+            });
+        }
+        return retVal;
+    }
+    static execCommand(command, settings) {
+        fileHelper_1.FileHelper.removeDist();
+        //https://github.com/npm/npx 
+        //npx added instead of "./node_modules/.bin/"
+        //const cwd = "./node_modules/.bin/";
+        const stdio = "inherit";
+        if (settings === null || settings === void 0 ? void 0 : settings.watch) {
+            command = command + " -w";
+        }
+        child_process_1.execSync(command, { stdio });
+    }
+}
+exports.NpmHelper = NpmHelper;
+NpmHelper.BUILD_CMD = "npx tsc";
+NpmHelper.WEBPACK_CMD = "npx webpack";

package/lib/helpers/packageHelper.d.ts

@@ -0,0 +1,14 @@
+export interface IPackageInfo {
+    name: string;
+    usedVersion: string;
+    lastVersion: string;
+}
+export interface IVersionCheckSettings {
+    packageNames: string[];
+    packageJsonFilePath: string;
+}
+export declare class PackageHelper {
+    static getBackwardPackages(settings: IVersionCheckSettings): IPackageInfo[];
+    private static getPackageJson;
+    private static fixChars;
+}

package/lib/helpers/packageHelper.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageHelper = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const compare_versions_1 = tslib_1.__importDefault(require("compare-versions"));
+const npmHelper_1 = require("./npmHelper");
+class PackageHelper {
+    static getBackwardPackages(settings) {
+        const list = [];
+        const cliFilePath = path.join(path.resolve(__dirname), "../.." + settings.packageJsonFilePath);
+        const cliDevDeps = this.getPackageJson(cliFilePath).devDependencies;
+        const appDevDeps = npmHelper_1.NpmHelper.getCurrentPackageVersions();
+        settings.packageNames.forEach(name => {
+            const lastVersion = this.fixChars(cliDevDeps[name]);
+            const usedVersion = appDevDeps[name];
+            if (compare_versions_1.default.compare(lastVersion, usedVersion, ">")) {
+                list.push({ name, usedVersion, lastVersion });
+            }
+        });
+        return list;
+    }
+    static getPackageJson(filePath) {
+        const data = fs.readFileSync(path.resolve(filePath), { encoding: "utf8" });
+        return JSON.parse(data);
+    }
+    static fixChars(value) {
+        return value.replace(/[^0-9.]/g, "");
+    }
+}
+exports.PackageHelper = PackageHelper;

package/lib/helpers/shellHelper.d.ts

@@ -0,0 +1,25 @@
+export interface IExecuteOptions {
+    /**
+     * override std err handler
+     * @returns true to continue executing standart error handler false to quit standart handler
+     */
+    stderr?: (chunkstring: string) => boolean;
+    /**
+     * override std out handler
+     * @returns true to continue executing standart output handler false to quit standart handler
+     */
+    stdout?: (chunkstring: string) => boolean;
+    /**
+     * override exit handler. Caution: should return true, or you should call success or fail. Otherwise execution hangs.
+     * @param code: error code of exit if any
+     * @returns null to continue executing standart exit handler or code and signal for handler to process
+     */
+    exit?: (code: number | null, signal: string | null) => {
+        code: number | null;
+        signal: string | null;
+    } | null;
+    noExitCode?: boolean;
+}
+export declare class ShellHelper {
+    static ExecuteCommand(command: string, args?: Array<string>, options?: IExecuteOptions): Promise<void>;
+}

package/lib/helpers/shellHelper.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellHelper = void 0;
+const child_process_1 = require("child_process");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+class ShellHelper {
+    static ExecuteCommand(command, args, options) {
+        return new Promise((res, rej) => {
+            const process = child_process_1.spawn(command, args);
+            process.stdout.on("data", (chunk) => {
+                var _a;
+                const chunkstring = chunk.toString();
+                if (((_a = options === null || options === void 0 ? void 0 : options.stdout) === null || _a === void 0 ? void 0 : _a.call(options, chunkstring)) === false) {
+                    return;
+                }
+                log_1.Logger.log({ message: chunk.toString() });
+            });
+            process.stderr.on("data", (chunk) => {
+                var _a;
+                const chunkstring = chunk.toString();
+                if (((_a = options === null || options === void 0 ? void 0 : options.stderr) === null || _a === void 0 ? void 0 : _a.call(options, chunkstring)) === false) {
+                    return;
+                }
+                log_1.Logger.log({ message: styling_1.Chalk.create("red.bold", chunkstring) });
+            });
+            const exitHandler = (exit) => (code, signal) => {
+                var _a;
+                const exitOverride = (_a = options === null || options === void 0 ? void 0 : options.exit) === null || _a === void 0 ? void 0 : _a.call(options, code, signal);
+                if (exitOverride) {
+                    code = exitOverride.code;
+                    signal = exitOverride.signal;
+                }
+                if (code) {
+                    if (!(options === null || options === void 0 ? void 0 : options.noExitCode)) {
+                        console.error(`${exit ? "exited" : "closed"} with: `, code, signal);
+                    }
+                    rej(code);
+                    return;
+                }
+                res();
+            };
+            process.on("exit", exitHandler(true));
+            // process.on("close", exitHandler(false));
+            process.on("disconnect", () => {
+                console.error("-----disconnect");
+                rej("------disconnect");
+            });
+        });
+    }
+}
+exports.ShellHelper = ShellHelper;

package/lib/helpers/socketServer/socketServerHelper.d.ts

@@ -0,0 +1,14 @@
+import { NanoServer } from '@stechquick/symphony-nanoserver';
+export declare class SocketServerHelper {
+    private server;
+    private nss;
+    private messageTypeLookup;
+    constructor(server: NanoServer);
+    Start(): this;
+    private onSocketConnection;
+    private onSocketError;
+    private listFilesExecution;
+    private saveFilesExecution;
+    private deleteFilesExecution;
+    private getFilesExecution;
+}

package/lib/helpers/socketServer/socketServerHelper.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketServerHelper = void 0;
+const tslib_1 = require("tslib");
+const symphony_nanoserver_wsplugin_1 = require("@stechquick/symphony-nanoserver-wsplugin");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+const cryptoHelper_1 = require("@stechquick/symphony-common/lib/helpers/cryptoHelper");
+const fileHelper_1 = require("@stechquick/symphony-common/lib/helpers/fileHelper");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+class SocketServerHelper {
+    constructor(server) {
+        this.server = server;
+        this.nss = new symphony_nanoserver_wsplugin_1.NanoSocketServer({
+            onConnection: this.onSocketConnection.bind(this),
+            onError: this.onSocketError.bind(this)
+        });
+        this.messageTypeLookup = {
+            "list_files": this.listFilesExecution.bind(this),
+            "save_files": this.saveFilesExecution.bind(this),
+            "delete_files": this.deleteFilesExecution.bind(this),
+            "get_files": this.getFilesExecution.bind(this),
+            "file_change": this.getFilesExecution.bind(this),
+            "watch_files": this.getFilesExecution.bind(this),
+        };
+    }
+    Start() {
+        this.server.AddPlugin(this.nss);
+        return this;
+    }
+    onSocketConnection(ns) {
+        const timer = setTimeout(() => {
+            log_1.Logger.log({ message: styling_1.Chalk.create("red", "unverified client") });
+            ns.Close(4001, "unverified client");
+        }, 3 * 1000);
+        ns.OnMessage = (msg) => {
+            if (msg != "hello cli") {
+                return;
+            }
+            clearTimeout(timer);
+            ns.Send("hello nemo");
+            ns.OnMessage = verifiedOnMsg;
+        };
+        const verifiedOnMsg = async (msg) => {
+            const request = JSON.parse(msg.toString());
+            const res = await this.messageTypeLookup[request.msg.type](request.msg);
+            if (!res) {
+                return;
+            }
+            const networkRes = {
+                id: cryptoHelper_1.CryptoHelper.CreateGuid(),
+                msg: res,
+                reply: request.id
+            };
+            ns.Send(networkRes);
+        };
+        console.log("connected", ns.ID);
+    }
+    onSocketError(error) {
+    }
+    async listFilesExecution(msg) {
+        const selectedPath = path.resolve(msg.path || ".");
+        return {
+            curPath: selectedPath,
+            type: "list_files_resp",
+            files: fileHelper_1.FileHelper.getFileNamesFormPath({ selectedPath })
+        };
+    }
+    async saveFilesExecution(msg) {
+        try {
+            const filePaths = msg.files.map(file => {
+                var _a;
+                const filePath = path.resolve(file.name + ((_a = file.ext) !== null && _a !== void 0 ? _a : ""));
+                fs.writeFileSync(filePath, file.content, { encoding: "UTF8" });
+                return filePath;
+            });
+            return { type: "save_files_resp", result: true, filePaths };
+        }
+        catch (error) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("red.bold", `Saving files error!`), error, level: log_1.LogLevel.error });
+            return { type: "save_files_resp", result: false };
+        }
+    }
+    async deleteFilesExecution(msg) {
+        try {
+            msg.files.forEach(file => {
+                fs.unlinkSync(path.resolve(file));
+            });
+            return { type: "delete_files_resp", result: true };
+        }
+        catch (error) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("red.bold", `Deleting files error!`), error, level: log_1.LogLevel.error });
+            return { type: "delete_files_resp", result: true };
+        }
+    }
+    async getFilesExecution(msg) {
+        const retFiles = [];
+        msg.files.forEach(file => {
+            const content = fs.readFileSync(path.resolve(file), { encoding: "UTF8" });
+            retFiles.push({ content, name: file, type: "file" });
+        });
+        return { files: retFiles, type: "get_files_resp" };
+    }
+}
+exports.SocketServerHelper = SocketServerHelper;

package/lib/helpers/typeHelper.d.ts

@@ -0,0 +1,3 @@
+export declare class TypeHelper {
+    static convertToBoolean(value: number | string): boolean;
+}

package/lib/helpers/typeHelper.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeHelper = void 0;
+class TypeHelper {
+    static convertToBoolean(value) {
+        switch (value) {
+            case "true":
+            case "True":
+            case 1:
+            case "1":
+                return true;
+            case "false":
+            case "False":
+            case 0:
+            case "0":
+                return false;
+            default:
+                throw new Error(`The '${value}' value can't convertable to boolean!`);
+        }
+    }
+}
+exports.TypeHelper = TypeHelper;

package/lib/helpers/ui/createuiHelper.d.ts

@@ -0,0 +1,10 @@
+export declare class CreateUIHelper {
+    private subPath;
+    private replaceMap;
+    private uiNameRegExp;
+    private uiDescRegExp;
+    private removeRegExp;
+    private createuiSearchPath;
+    constructor();
+    CreateUI(uiName: string, uiDesc: string): Promise<void>;
+}

package/lib/helpers/ui/createuiHelper.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateUIHelper = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const cli_ux_1 = tslib_1.__importDefault(require("cli-ux"));
+const fileHelper_1 = require("@stechquick/symphony-common/lib/helpers/fileHelper");
+class CreateUIHelper {
+    constructor() {
+        this.subPath = "./";
+        this.replaceMap = new Map();
+        this.uiNameRegExp = /{{UIName}}/g;
+        this.uiDescRegExp = /{{UIDesc}}/g;
+        this.removeRegExp = /{{remove}}/g;
+        this.createuiSearchPath = "../../../../templates/createui";
+        this.replaceMap.set(this.removeRegExp, "");
+    }
+    async CreateUI(uiName, uiDesc) {
+        this.replaceMap.set(this.uiNameRegExp, uiName);
+        this.replaceMap.set(this.uiDescRegExp, uiDesc);
+        const existsSubPath = fs.existsSync(this.subPath + uiName);
+        if (existsSubPath) {
+            const answer = await cli_ux_1.default.confirm("App: " + uiName + " already exists. If you have any, you will lose your pending changes. Would you like to overwrite it?");
+            if (!answer) {
+                return;
+            }
+        }
+        const templatePath = path.join(path.resolve(__dirname), "../.." + this.createuiSearchPath);
+        return fileHelper_1.FileHelper.exportFiles({ sourcePath: templatePath, targetPath: "./", replaceMap: this.replaceMap });
+    }
+}
+exports.CreateUIHelper = CreateUIHelper;

package/lib/helpers/ui/quiBuilder.d.ts

@@ -0,0 +1,13 @@
+export declare class FolderCopier {
+    ForEachItemInFolder(folder: string, iterator: (folder: string, item: string, relativeFolder: string, isDirectory: boolean) => void, willIterateFolder?: (folder: string, item: string, relativeFolder: string) => boolean): void;
+    CopyFolder(source: string, destination: string, except?: Array<string>): void;
+    CopyFile(source: string, destination: string, options?: {
+        copyIfExists?: boolean;
+    }): void;
+    DeleteFolder(target: string): void;
+    private ReplaceFile;
+    private substringBetween;
+    private getReplaceFiles;
+    private convertYamlstoJS;
+    Execute(): void;
+}

package/lib/helpers/ui/quiBuilder.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FolderCopier = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+;
+class FolderCopier {
+    ForEachItemInFolder(folder, iterator, willIterateFolder) {
+        function forEachItemInFoderInternal(folder, curRelative) {
+            fs.readdirSync(folder).forEach(item => {
+                const curItemPath = path.join(folder, item);
+                const isDirectory = fs.statSync(curItemPath).isDirectory();
+                if (isDirectory) {
+                    if (!willIterateFolder || (willIterateFolder === null || willIterateFolder === void 0 ? void 0 : willIterateFolder(folder, item, curRelative))) {
+                        forEachItemInFoderInternal(curItemPath, curRelative + "/" + item);
+                        iterator(folder, item, curRelative, true);
+                    }
+                }
+                else {
+                    iterator(folder, item, curRelative, false);
+                }
+            });
+        }
+        forEachItemInFoderInternal(folder, "");
+    }
+    ;
+    CopyFolder(source, destination, except) {
+        const exceptDict = (except === null || except === void 0 ? void 0 : except.length) ? except.reduce((prev, current) => { prev[current] = true; return prev; }, {}) : undefined;
+        this.ForEachItemInFolder(source, (folder, item, relativeFolder, isDirectory) => {
+            if (isDirectory) {
+                return;
+            }
+            if (exceptDict) {
+                const relativeItemPath = path.join(relativeFolder, item);
+                if (exceptDict[relativeItemPath]) {
+                    console.log("Skip: " + relativeItemPath);
+                    return;
+                }
+            }
+            const srcPath = path.resolve(path.join(folder, item));
+            const destPath = path.resolve(path.join(destination, relativeFolder));
+            if (!fs.existsSync(destPath)) {
+                fs.mkdirSync(destPath, { recursive: true });
+            }
+            //console.log(`Dir: ${srcPath}-->${destPath}`);
+            fs.copyFileSync(srcPath, path.join(destPath, item));
+        }, (folder, item, relativeFolder) => {
+            const relativeItemPath = path.join(relativeFolder, item);
+            if (exceptDict === null || exceptDict === void 0 ? void 0 : exceptDict[relativeItemPath]) {
+                console.log("Skip: " + relativeItemPath);
+                return false;
+            }
+            return true;
+        });
+    }
+    CopyFile(source, destination, options = {}) {
+        const pathParsed = path.parse(source);
+        const srcFile = path.resolve(source);
+        if (options.copyIfExists && !fs.existsSync(srcFile)) {
+            log_1.Logger.log({ message: "Skipping copy: " + srcFile });
+            return;
+        }
+        const destPath = path.resolve(destination);
+        if (!fs.existsSync(destPath)) {
+            fs.mkdirSync(destPath, { recursive: true });
+        }
+        const destFile = path.join(destPath, pathParsed.base);
+        console.log(`File: ${srcFile}-->${destFile}`);
+        fs.copyFileSync(srcFile, destFile);
+    }
+    DeleteFolder(target) {
+        if (!fs.existsSync(target)) {
+            return;
+        }
+        this.ForEachItemInFolder(target, (folder, item, relativeFolder, isDirectory) => {
+            const curPath = path.join(folder, item);
+            if (isDirectory) {
+                fs.rmdirSync(curPath);
+            }
+            else {
+                fs.unlinkSync(path.join(folder, item));
+            }
+        });
+    }
+    ReplaceFile(source, skipIfNone, cb) {
+        const srcFile = path.resolve(source);
+        if (!fs.existsSync(srcFile)) {
+            console.log(`${srcFile} does not exists skip: ${skipIfNone}`);
+            if (skipIfNone) {
+                return;
+            }
+        }
+        const fileBody = fs.readFileSync(srcFile, { encoding: "utf-8" });
+        const fileName = path.parse(srcFile).base;
+        const newFileData = cb({ fileBody, fileName });
+        fs.unlinkSync(srcFile);
+        fs.writeFileSync(srcFile.replace(fileName, newFileData.fileName), newFileData.fileBody, { encoding: "utf-8" });
+    }
+    substringBetween(sourceString, start, end) {
+        let startIndex = sourceString.indexOf(start);
+        if (startIndex < 0) {
+            return null;
+        }
+        startIndex = startIndex + start.length;
+        let endIndex = sourceString.length;
+        if (end) {
+            endIndex = sourceString.indexOf(end, startIndex);
+            if (endIndex < 0) {
+                return null;
+            }
+        }
+        return sourceString.substring(startIndex, endIndex);
+    }
+    getReplaceFiles() {
+        return [{
+                fileName: "./dist/client/static/js/componentList.ts",
+                fileReplacer: (fileData) => {
+                    const retVal = { fileName: fileData.fileName.replace(".ts", ".js"), fileBody: "" };
+                    let fileBody = this.substringBetween(fileData.fileBody, "//#region JS Section");
+                    if (!fileBody) {
+                        return retVal;
+                    }
+                    retVal.fileBody = fileBody.replace(": ComponentOptions =", " =");
+                    return retVal;
+                }
+            }];
+    }
+    convertYamlstoJS() {
+        const yamlPaths = ["settings", "localProxy"];
+        let arrangedJSON = Object.create({ settings: {}, proxy: {} });
+        let resolvedPath = "";
+        let fileName = "";
+        yamlPaths.forEach(item => {
+            let tempPath = `./settings/${item}.yaml`;
+            resolvedPath = path.resolve(tempPath);
+            fileName = path.parse(resolvedPath).base;
+            let fileContent = fs.readFileSync(tempPath, "utf8");
+            arrangedJSON[item] = js_yaml_1.default.safeLoad(fileContent);
+        });
+        let concattedYamlString = "const yamlObject = "
+            + JSON.stringify(arrangedJSON, null, '\t')
+            + "\nif (typeof exports === 'object' && typeof module === 'object'){\n \tmodule.exports = yamlObject;\n}else{ \n\twindow['QEditorSettingsProxy'] = yamlObject;\n}";
+        fs.writeFileSync(resolvedPath.replace(fileName, "settings-proxy.js"), concattedYamlString, { encoding: "utf-8" });
+    }
+    Execute() {
+        this.DeleteFolder("./dist");
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Folders copying..."), timeFormat: "datetime" });
+        this.CopyFolder("./node_modules/quick_qui/dist", "./dist", ["build"]); // build'klasörünü hariç tut
+        this.convertYamlstoJS();
+        this.CopyFolder("./settings", "./dist/client/settings", ["localProxy.yaml", "server"]);
+        this.CopyFolder("./settings", "./dist/server/settings");
+        //this.CopyFolder("./certificates", "./dist/server/certificates");
+        this.CopyFolder("./static", "./dist/client/static");
+        this.CopyFile("./worker/a9e657cbf4abb977edda.worker.js", "./dist/client", { copyIfExists: true });
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Folders copied successfully."), timeFormat: "datetime" });
+        this.getReplaceFiles().forEach(item => this.ReplaceFile(item.fileName, true, item.fileReplacer));
+    }
+}
+exports.FolderCopier = FolderCopier;

package/lib/helpers/utils.d.ts

@@ -0,0 +1,8 @@
+export declare class Utils {
+    static getDateAsString({ date, dateSplitter, timeSplitter, dateAndTimeSplitter }?: {
+        date?: Date;
+        dateSplitter?: string;
+        timeSplitter?: string;
+        dateAndTimeSplitter?: string;
+    }): string;
+}

package/lib/helpers/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+class Utils {
+    static getDateAsString({ date, dateSplitter, timeSplitter, dateAndTimeSplitter } = {}) {
+        date = date !== null && date !== void 0 ? date : new Date();
+        dateSplitter = dateSplitter !== null && dateSplitter !== void 0 ? dateSplitter : "-";
+        timeSplitter = timeSplitter !== null && timeSplitter !== void 0 ? timeSplitter : ".";
+        dateAndTimeSplitter = dateAndTimeSplitter !== null && dateAndTimeSplitter !== void 0 ? dateAndTimeSplitter : "@";
+        const locale = "tr-TR";
+        const year = new Intl.DateTimeFormat(locale, { year: 'numeric' }).format(date);
+        const month = new Intl.DateTimeFormat(locale, { month: '2-digit' }).format(date);
+        const day = new Intl.DateTimeFormat(locale, { day: '2-digit' }).format(date);
+        const hour = new Intl.DateTimeFormat(locale, { hour: '2-digit' }).format(date);
+        const minute = new Intl.DateTimeFormat(locale, { minute: '2-digit' }).format(date);
+        const second = new Intl.DateTimeFormat(locale, { second: '2-digit' }).format(date);
+        return `${year}${dateSplitter}${month}${dateSplitter}${day}${dateAndTimeSplitter}${hour}${timeSplitter}${minute}${timeSplitter}${second}`;
+    }
+}
+exports.Utils = Utils;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/command';

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var command_1 = require("@oclif/command");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });

package/lib/pathFinder.d.ts

@@ -0,0 +1,4 @@
+export declare class PathFinder {
+    static dirname: string;
+    static RootPath(fromRootPath: string): string;
+}

package/lib/pathFinder.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathFinder = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+class PathFinder {
+    static RootPath(fromRootPath) {
+        const retVal = path.join(PathFinder.dirname, fromRootPath);
+        return retVal;
+    }
+}
+exports.PathFinder = PathFinder;
+PathFinder.dirname = path.resolve(__dirname + "/..");

package/lib/predeploy/src/fn/fnPostdeploy.d.ts

@@ -0,0 +1,5 @@
+export declare class FnPostDeploy {
+    private static deleteList;
+    static execute(): void;
+    private static deleteTargets;
+}