sb-mig 3.1.2 → 3.1.6

package/dist/utils/discover.js

@@ -0,0 +1,481 @@
+// component resolution file borrowed from great storyblok-migrate
+// https://github.com/maoberlehner/storyblok-migrate
+// edit: changed a lot in here, but inspiration still is valid :)
+import glob from "glob";
+import path from "path";
+import storyblokConfig from "../config/config.js";
+import { getFileContentWithRequire } from "./main.js";
+export var SCOPE;
+(function (SCOPE) {
+    SCOPE["local"] = "local";
+    SCOPE["external"] = "external";
+    SCOPE["lock"] = "lock";
+    SCOPE["all"] = "all";
+})(SCOPE || (SCOPE = {}));
+export var LOOKUP_TYPE;
+(function (LOOKUP_TYPE) {
+    LOOKUP_TYPE["packagName"] = "packageName";
+    LOOKUP_TYPE["fileName"] = "fileName";
+})(LOOKUP_TYPE || (LOOKUP_TYPE = {}));
+// problem with glob sync is, that when there is only one folder to search for
+// we have to omit { } and when a lot, we have to use {folder1, folder2}
+// so this function will normalize it based on amount of folders provided
+const normalizeDiscover = ({ segments }) => {
+    if (segments.length === 1) {
+        return segments[0];
+    }
+    return `{${segments.join(",")}}`;
+};
+// export const compare = (request: CompareRequest): CompareResult => {
+export const compare = (request) => {
+    // TODO: figure out types
+    const splittedLocal = request.local.map((path) => {
+        return {
+            name: path.split("/")[path.split("/").length - 1],
+            path,
+        };
+    });
+    const splittedExternal = request.external.map((path) => {
+        return {
+            name: path.split("/")[path.split("/").length - 1],
+            path,
+        };
+    });
+    // we only want to modify external array, because we want sometimes remove stuff which are already on local (overwrite node_modules ones)
+    const result = {
+        local: splittedLocal,
+        external: splittedExternal.filter((externalComponent) => {
+            if (splittedLocal.find((localComponent) => externalComponent.name === localComponent.name)) {
+                return false;
+            }
+            return true;
+        }),
+    };
+    return result;
+};
+export const discoverManyByPackageName = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    let listOfPackagesJsonFiles;
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### MANY by PACKAGE - LOCAL - packageName
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", "package.json");
+            listOfPackagesJsonFiles = glob.sync(pattern, { follow: true });
+            listOfFiles = listOfPackagesJsonFiles
+                .filter(async (file) => request.packageNames.includes(await getFileContentWithRequire({ file }).name)) // filter only package.json from provided request.packageNames
+                .map((file) => {
+                // get path to folder in which current package.json is
+                const fileFolderPath = file
+                    .split("/")
+                    .slice(0, -1)
+                    .join("/");
+                const allStoryblokSchemaFilesWithinFolderPattern = path.join(`${fileFolderPath}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}`);
+                return glob.sync(allStoryblokSchemaFilesWithinFolderPattern, { follow: true });
+            })
+                .flat();
+            break;
+        case SCOPE.external:
+            // ### MANY by PACKAGE - EXTERNAL - packageName
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", "package.json");
+            listOfPackagesJsonFiles = glob.sync(pattern, { follow: true });
+            listOfFiles = listOfPackagesJsonFiles
+                .filter((file) => request.packageNames.includes(getFileContentWithRequire({ file }).name)) // filter only package.json from provided request.packageNames
+                .map((file) => {
+                // get path to folder in which current package.json is
+                const fileFolderPath = file
+                    .split("/")
+                    .slice(0, -1)
+                    .join("/");
+                const allStoryblokSchemaFilesWithinFolderPattern = path.join(`${fileFolderPath}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}`);
+                return glob.sync(allStoryblokSchemaFilesWithinFolderPattern, { follow: true });
+            })
+                .flat();
+            break;
+        case SCOPE.all:
+            // ### MANY by PACKAGE - ALL - packageName
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", "package.json");
+            listOfPackagesJsonFiles = glob.sync(pattern, { follow: true });
+            listOfFiles = listOfPackagesJsonFiles
+                .filter((file) => request.packageNames.includes(getFileContentWithRequire({ file }).name)) // filter only package.json from provided request.packageNames
+                .map((file) => {
+                // get path to folder in which current package.json is
+                const fileFolderPath = file
+                    .split("/")
+                    .slice(0, -1)
+                    .join("/");
+                const allStoryblokSchemaFilesWithinFolderPattern = path.join(`${fileFolderPath}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}`);
+                return glob.sync(allStoryblokSchemaFilesWithinFolderPattern, { follow: true });
+            })
+                .flat();
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverOneByPackageName = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    let listOfPackagesJsonFiles;
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### ONE by PACKAGE - LOCAL - packageName
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", "package.json");
+            listOfPackagesJsonFiles = glob.sync(pattern, { follow: true });
+            listOfFiles = listOfPackagesJsonFiles
+                .filter((file) => getFileContentWithRequire({ file }).name ===
+                request.packageName) // filter only package.json from provided request.packageName
+                .map((file) => {
+                // get path to folder in which current package.json is
+                const fileFolderPath = file
+                    .split("/")
+                    .slice(0, -1)
+                    .join("/");
+                const allStoryblokSchemaFilesWithinFolderPattern = path.join(`${fileFolderPath}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}`);
+                return glob.sync(allStoryblokSchemaFilesWithinFolderPattern, { follow: true });
+            })
+                .flat();
+            break;
+        case SCOPE.external:
+            // ### ONE by PACKAGE - EXTERNAL - packageName
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", "package.json");
+            listOfPackagesJsonFiles = glob.sync(pattern, { follow: true });
+            listOfFiles = listOfPackagesJsonFiles
+                .filter((file) => getFileContentWithRequire({ file }).name ===
+                request.packageName) // filter only package.json from provided request.packageName
+                .map((file) => {
+                // get path to folder in which current package.json is
+                const fileFolderPath = file
+                    .split("/")
+                    .slice(0, -1)
+                    .join("/");
+                const allStoryblokSchemaFilesWithinFolderPattern = path.join(`${fileFolderPath}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}`);
+                return glob.sync(allStoryblokSchemaFilesWithinFolderPattern, { follow: true });
+            })
+                .flat();
+            break;
+        case SCOPE.all:
+            // ### ONE by PACKAGE - ALL - packageName
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", "package.json");
+            listOfPackagesJsonFiles = glob.sync(pattern, { follow: true });
+            listOfFiles = listOfPackagesJsonFiles
+                .filter((file) => getFileContentWithRequire({ file }).name ===
+                request.packageName) // filter only package.json from provided request.packageName
+                .map((file) => {
+                // get path to folder in which current package.json is
+                const fileFolderPath = file
+                    .split("/")
+                    .slice(0, -1)
+                    .join("/");
+                const allStoryblokSchemaFilesWithinFolderPattern = path.join(`${fileFolderPath}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}`);
+                return glob.sync(allStoryblokSchemaFilesWithinFolderPattern, { follow: true });
+            })
+                .flat();
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverMany = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### MANY - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.schemaFileExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### MANY - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.schemaFileExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### MANY - ALL - fileName ###
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.schemaFileExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverManyDatasources = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### MANY - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.datasourceExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### MANY - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.datasourceExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### MANY - ALL - fileName ###
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.datasourceExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverDatasources = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### ALL - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", `[^_]*.${storyblokConfig.datasourceExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### ALL - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", `[^_]*.${storyblokConfig.datasourceExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### ALL - LOCAL - fileName ###
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", `[^_]*.${storyblokConfig.datasourceExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverOne = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### ONE - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", `${request.fileName}.${storyblokConfig.schemaFileExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### ONE - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", `${request.fileName}.${storyblokConfig.schemaFileExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### ONE - ALL - fileName ###
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", `${request.fileName}.${storyblokConfig.schemaFileExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discover = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    const filesPattern = (componentDirectories) => {
+        return componentDirectories.length === 1
+            ? path.join(`${directory}/${componentDirectories[0]}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}` // all files with 'ext' extension, without files beggining with _
+            )
+            : path.join(`${directory}/{${componentDirectories.join(",")}}`, "**", `[^_]*.${storyblokConfig.schemaFileExt}` // all files with 'ext' extension, without files beggining with _
+            );
+    };
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### ALL - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = filesPattern(onlyLocalComponentsDirectories);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### ALL - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = filesPattern(onlyNodeModulesPackagesComponentsDirectories);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### ALL - LOCAL - fileName ###
+            pattern = filesPattern(storyblokConfig.componentsDirectories);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverManyStyles = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### MANY - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.scss`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### MANY - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.scss`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### MANY - ALL - fileName ###
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.scss`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverRoles = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### ALL - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", `[^_]*.${storyblokConfig.rolesExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### ALL - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", `[^_]*.${storyblokConfig.rolesExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### ALL - LOCAL - fileName ###
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", `[^_]*.${storyblokConfig.rolesExt}` // all files with 'ext' extension, without files beggining with _
+            );
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};
+export const discoverManyRoles = (request) => {
+    const rootDirectory = "./";
+    const directory = path.resolve(process.cwd(), rootDirectory);
+    let pattern;
+    let listOfFiles = [""];
+    switch (request.scope) {
+        case SCOPE.local:
+            // ### ALL - LOCAL - fileName ###
+            const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => !path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyLocalComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.rolesExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.external:
+            // ### ALL - EXTERNAL - fileName ###
+            const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((path) => path.includes("node_modules"));
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: onlyNodeModulesPackagesComponentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.rolesExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        case SCOPE.all:
+            // ### ALL - LOCAL - fileName ###
+            pattern = path.join(`${directory}/${normalizeDiscover({
+                segments: storyblokConfig.componentsDirectories,
+            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.rolesExt}`);
+            listOfFiles = glob.sync(pattern, { follow: true });
+            break;
+        default:
+            break;
+    }
+    return listOfFiles;
+};

package/dist/utils/files.d.ts

@@ -0,0 +1,12 @@
+export declare const isDirectoryExists: (path: string) => boolean;
+export declare const createDir: (dirPath: string) => Promise<void>;
+export declare const createJsonFile: (content: string, pathWithFilename: string) => Promise<void>;
+export declare const copyFolder: (src: string, dest: string) => Promise<unknown>;
+export declare const copyFile: (src: string, dest: string) => Promise<void>;
+interface CreateAndSaveToFile {
+    prefix: string;
+    folder: string;
+    res: any;
+}
+export declare const createAndSaveToFile: ({ prefix, folder, res, }: CreateAndSaveToFile) => Promise<void>;
+export {};

package/dist/utils/files.js

@@ -0,0 +1,54 @@
+import * as fs from "fs";
+import pkg from "ncp";
+import { generateDatestamp } from "./others.js";
+import storyblokConfig from "../config/config.js";
+import Logger from "./logger.js";
+const { ncp } = pkg;
+export const isDirectoryExists = (path) => fs.existsSync(path);
+export const createDir = async (dirPath) => {
+    await fs.promises.mkdir(`${process.cwd()}/${dirPath}`, {
+        recursive: true,
+    });
+};
+export const createJsonFile = async (content, pathWithFilename) => {
+    await fs.promises.writeFile(pathWithFilename, content, { flag: "w" });
+};
+export const copyFolder = async (src, dest) => {
+    return new Promise((resolve, reject) => {
+        ncp(src, dest, function (err) {
+            if (err) {
+                reject({
+                    failed: true,
+                    message: `${src} copied unsuccessfully.`,
+                });
+            }
+            resolve({
+                failed: false,
+                message: `${src} copied successfully.`,
+            });
+        });
+    });
+};
+export const copyFile = async (src, dest) => {
+    const directory = dest.split("/").slice(0, dest.split("/").length - 1);
+    const fileName = src.split("/")[src.split("/").length - 1];
+    if (!isDirectoryExists(directory.join("/"))) {
+        await createDir(directory.join("/"));
+    }
+    fs.copyFile(src, dest, (err) => {
+        if (err) {
+            console.error(`There is no file to copy, named ${fileName}`);
+            console.log(err);
+            return false;
+        }
+        console.log(`${fileName} was copied to ${dest}`);
+        return true;
+    });
+};
+export const createAndSaveToFile = async ({ prefix, folder, res, }) => {
+    const datestamp = new Date();
+    const filename = `${prefix}${generateDatestamp(datestamp)}`;
+    await createDir(`${storyblokConfig.sbmigWorkingDirectory}/${folder}/`);
+    await createJsonFile(JSON.stringify(res, undefined, 2), `${storyblokConfig.sbmigWorkingDirectory}/${folder}/${filename}.json`);
+    Logger.success(`All groups written to a file:  ${filename}`);
+};

package/dist/utils/interfaces.d.ts

@@ -0,0 +1,4 @@
+import { AnyFlags, Result } from "meow";
+export interface CLIOptions extends Omit<Result<AnyFlags>, "flags"> {
+    flags: any;
+}

package/dist/utils/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+export default class Logger {
+    static log(content: any): void;
+    static success(content: any): void;
+    static warning(content: any): void;
+    static error(content: any, { verbose }?: {
+        verbose: boolean;
+    }): void;
+}

package/dist/utils/logger.js

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+export default class Logger {
+    static log(content) {
+        console.log(content);
+    }
+    static success(content) {
+        console.log(chalk.green(`✓ ${content}`));
+    }
+    static warning(content) {
+        console.log(chalk.yellow(`! ${content}`));
+    }
+    static error(content, { verbose } = { verbose: false }) {
+        if (verbose) {
+            console.log(content);
+        }
+        else {
+            console.log(chalk.red(`✘ ${content}`));
+        }
+    }
+}

package/dist/utils/main.d.ts

@@ -0,0 +1,13 @@
+export declare const prop: (k: any) => (o: any) => any;
+export declare const pipe: (...fns: any[]) => (x: any) => any;
+export declare const unpackElements: (input: string[]) => string[];
+export declare const unpackOne: (input: string[]) => string | undefined;
+export declare const getFileContent: (data: {
+    file: string;
+}) => any;
+export declare const getFileContentWithRequire: (data: {
+    file: string;
+}) => any;
+export declare const getFilesContentWithRequire: (data: {
+    files: string[];
+}) => any[];

package/dist/utils/main.js

@@ -0,0 +1,28 @@
+import { createRequire } from "module";
+export const prop = (k) => (o) => o[k];
+export const pipe = (...fns) => (x) => [...fns].reduce((acc, f) => f(acc), x);
+export const unpackElements = (input) => {
+    const [_1, _2, ...elementsForUse] = input;
+    return elementsForUse;
+};
+export const unpackOne = (input) => {
+    const [_1, _2, elementForUse] = input;
+    return elementForUse;
+};
+export const getFileContent = (data) => {
+    return import(data.file)
+        .then((res) => {
+        return res.default;
+    })
+        .catch(() => {
+        console.log("Cannot find requested file. (in terms of storyblok.config.js, using default values. ");
+    });
+};
+export const getFileContentWithRequire = (data) => {
+    const require = createRequire(import.meta.url);
+    return require(data.file);
+};
+export const getFilesContentWithRequire = (data) => {
+    const require = createRequire(import.meta.url);
+    return data.files.map((file) => require(file));
+};

package/dist/utils/others.d.ts

@@ -0,0 +1 @@
+export declare const generateDatestamp: (datestamp: Date) => string;

package/dist/utils/others.js

@@ -0,0 +1 @@
+export const generateDatestamp = (datestamp) => `${datestamp.getFullYear()}-${datestamp.getMonth()}-${datestamp.getDay()}_${datestamp.getTime()}`;