@genexus/mercury 0.35.1 → 0.36.0

package/dist/cli/bundle.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli/bundle.js

@@ -1,191 +0,0 @@
-#!/usr/bin/env node
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { Worker, isMainThread, parentPort } from "worker_threads";
-import { BASE_BUNDLES_OUT_DIR, CSS_BUNDLES_OUT_DIR, SCSS_BUNDLES_INPUT_DIR
-// SCSS_BUNDLES_OUT_DIR
- } from "./internal/constants.js";
-import { ensureDirectoryExistsAndItsClear, getFilesInDir, refreshAngularBrowser
-// copyDirectories
- } from "./internal/file-management.js";
-import { transpileCssBundleWithPlaceholder } from "./internal/transpile-bundle-and-create-mappings.js";
-import { measureTime } from "./internal/utils.js";
-import { createBundlesWithCustomPaths } from "./internal/create-bundles-with-custom-paths.js";
-import { printBundleWasTranspiled } from "./internal/print-utils.js";
-import { getArguments } from "./internal/validate-args.js";
-import { printRebuilding, stopRebuildingStdout, watchFileSystemChanges } from "./internal/watch-fs.js";
-const MESSAGE_TYPE = {
-    SUCCESS: "Success",
-    ERROR: "Error"
-};
-if (isMainThread) {
-    const [, , ...args] = process.argv;
-    const watchMode = args.find(arg => arg === "--watch");
-    const ciMode = args.find(arg => arg === "--ci");
-    let cliArgs;
-    // Check if the bundles processing is running in watch mode
-    if (watchMode || ciMode) {
-        cliArgs = getArguments();
-        if (!cliArgs) {
-            process.exit();
-        }
-    }
-    // This is a WA to have __filename and __dirname in ES modules
-    const __filename = fileURLToPath(import.meta.url);
-    const THREADS = Math.min(8, os.cpus().length / 2);
-    const workers = [];
-    /**
-     * Files to transpile
-     */
-    let allFilesToProcess = [];
-    let firstBuild = true;
-    // - - - - - - - - - - - - Sets to implement cache - - - - - - - - - - - -
-    const BUNDLES_TO_AVOID_REBUILD = [
-        "all",
-        "base/icons",
-        "resets/box-sizing",
-        "utils/form--full"
-    ];
-    const CSS_FILES_TO_AVOID_REMOVE = new Set(BUNDLES_TO_AVOID_REBUILD.map(bundleName => path.join(CSS_BUNDLES_OUT_DIR, bundleName + ".css")));
-    const SCSS_FILES_TO_AVOID_TRANSPILE = new Set(BUNDLES_TO_AVOID_REBUILD.map(bundleName => path.join(SCSS_BUNDLES_INPUT_DIR, bundleName + ".scss")));
-    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-    const createWorkers = () => {
-        for (let index = 0; index < THREADS; index++) {
-            const worker = new Worker(__filename);
-            workers.push(worker);
-        }
-    };
-    const ensureAllDirectoryExists = (filesToProcess) => {
-        const CSS_CREATED_DIRS = new Set();
-        return filesToProcess.map(async (fileMetadata) => {
-            const cssOutDir = fileMetadata.dir.replace(SCSS_BUNDLES_INPUT_DIR, CSS_BUNDLES_OUT_DIR);
-            // Create the file directory if it does not exists
-            if (CSS_CREATED_DIRS.has(cssOutDir)) {
-                return Promise.resolve();
-            }
-            CSS_CREATED_DIRS.add(cssOutDir);
-            return fs.mkdir(cssOutDir, { recursive: true });
-        });
-    };
-    const compileBundles = async (options) => {
-        let completedProcessingIndex = 0;
-        // First build where the directory has to be discovered
-        if (firstBuild) {
-            allFilesToProcess = await getFilesInDir(SCSS_BUNDLES_INPUT_DIR);
-            createWorkers();
-        }
-        const ACTUAL_FILES_TO_PROCESS = structuredClone(allFilesToProcess).filter(fileMetadata => !options ||
-            !options.scssFilesToAvoidTranspile.has(fileMetadata.filePath));
-        const TOTAL_FILES = ACTUAL_FILES_TO_PROCESS.length;
-        // Clear bundle directories
-        await ensureDirectoryExistsAndItsClear(BASE_BUNDLES_OUT_DIR, options?.cssFilesToAvoidRemove);
-        // Ensure all directories exists before transpiling any bundle
-        await Promise.all(ensureAllDirectoryExists(ACTUAL_FILES_TO_PROCESS));
-        let workersProcessingMetadata = 0;
-        let thereWasAnError = false;
-        const sendFileMetadataToWorker = (worker, fileMetadata) => {
-            worker.postMessage({ fileMetadata, cliArgs }); // Send the data to process the file
-            workersProcessingMetadata++;
-        };
-        const updateFileProcessingStatus = () => {
-            completedProcessingIndex++;
-            workersProcessingMetadata--;
-        };
-        return new Promise((resolve, reject) => workers.forEach(worker => {
-            let fileMetadata = ACTUAL_FILES_TO_PROCESS.pop();
-            sendFileMetadataToWorker(worker, fileMetadata);
-            // When the worker completes the processing, increase the index and
-            // check if there is work remaining to process in the thread
-            worker.on("message", message => {
-                updateFileProcessingStatus();
-                if (message === MESSAGE_TYPE.ERROR) {
-                    thereWasAnError = true;
-                }
-                // Stop all workers when there is an error
-                if (thereWasAnError) {
-                    worker.removeAllListeners("message");
-                    if (workersProcessingMetadata === 0) {
-                        reject();
-                    }
-                    return;
-                }
-                if (!watchMode && !ciMode) {
-                    printBundleWasTranspiled(fileMetadata.filePath);
-                }
-                // All metadatas were processed. Resolve the Promise
-                if (completedProcessingIndex === TOTAL_FILES) {
-                    worker.removeAllListeners("message");
-                    resolve(ACTUAL_FILES_TO_PROCESS);
-                }
-                // There is more metadata to be processed, add a new processing in
-                // the thread
-                else if (ACTUAL_FILES_TO_PROCESS.length > 0) {
-                    fileMetadata = ACTUAL_FILES_TO_PROCESS.pop();
-                    sendFileMetadataToWorker(worker, fileMetadata);
-                }
-                // Waiting for the last compilation to end. There is nothing to do,
-                // so we need to remove the listeners to ensure the following
-                // processing uses the workers in a "fresh" state
-                else {
-                    worker.removeAllListeners("message");
-                }
-            });
-        }));
-    };
-    const compileAndCreateBundles = async () => {
-        printRebuilding(firstBuild);
-        try {
-            // Compile all CSSs into the standard output (dist/bundles/css)
-            await compileBundles(firstBuild
-                ? undefined
-                : {
-                    cssFilesToAvoidRemove: CSS_FILES_TO_AVOID_REMOVE,
-                    scssFilesToAvoidTranspile: SCSS_FILES_TO_AVOID_TRANSPILE
-                });
-            // Clear the CLI dir output target
-            await ensureDirectoryExistsAndItsClear(cliArgs.outDirPath);
-            // Remove "Rebuilding..." message, since the next function will print
-            // some output in the console
-            stopRebuildingStdout();
-            // Copy the files from the standard output (dist/bundles/css) to the CLI
-            // output by applying the transformations for the icons and custom fonts
-            // paths.
-            //
-            // Last true value meaning: Don't hash the bundles in watch mode to avoid
-            // issues with Angular that caches the bundle mapping file, causing to
-            // not update the hashes for the fetches
-            await createBundlesWithCustomPaths(cliArgs, true);
-            refreshAngularBrowser();
-            firstBuild = false;
-        }
-        catch (err) {
-            stopRebuildingStdout();
-            if (err) {
-                console.log(err);
-            }
-        }
-    };
-    if (watchMode) {
-        measureTime(compileAndCreateBundles).finally(() => watchFileSystemChanges(compileAndCreateBundles));
-    }
-    else if (ciMode) {
-        await compileAndCreateBundles();
-        process.exit();
-    }
-    // There is no need to wait for any changes, since the watch mode is not enabled
-    else {
-        await measureTime(compileBundles);
-        process.exit();
-    }
-}
-// Worker thread code
-else {
-    parentPort.on("message", (data) => transpileCssBundleWithPlaceholder(data.fileMetadata, data.cliArgs)
-        .then(() => parentPort.postMessage(MESSAGE_TYPE.SUCCESS))
-        .catch(err => {
-        console.error(err);
-        parentPort.postMessage(MESSAGE_TYPE.ERROR);
-    }));
-}

package/dist/cli/internal/constants.d.ts

@@ -1,19 +0,0 @@
-export declare const KB = 1000;
-export declare const SCSS_BUNDLES_INPUT_DIR: string;
-export declare const BASE_BUNDLES_OUT_DIR: string;
-export declare const SCSS_BUNDLES_OUT_DIR: string;
-export declare const CSS_BUNDLES_OUT_DIR: string;
-export declare const BASE_BUNDLE = "base/base";
-export declare const BASE_GLOBANT_BUNDLE = "base/base-globant";
-export declare const BUNDLE_MAPPING_TO_HASH_FILE = "bundle-to-hash-mappings.ts";
-export declare const BASE_CSS_FILE = "base.css";
-export declare const BASE_GLOBANT_CSS_FILE = "base-globant.css";
-export declare const ICONS_PATH_PLACEHOLDER = "{{ICONS_PATH}}";
-export declare const FONT_FACE_PATH_PLACEHOLDER = "{{FONT_FACE_PATH}}";
-export declare const DEFAULT_FONT_FACE_PATH = "./assets/fonts/";
-export declare const DEFAULT_ICONS_PATH = "./assets/icons/";
-export declare const DEFAULT_OUT_DIR_PATH = "./.mercury";
-export declare const SEPARATE_BY_COMMA_REGEX: RegExp;
-export declare const SPECIAL_CHARS_IN_BUNDLE_NAME_REGEX: RegExp;
-export declare const HASH_LENGTH = 16;
-export declare const HASH_AND_LETTER_LENGTH: number;

package/dist/cli/internal/constants.js

@@ -1,24 +0,0 @@
-import path from "node:path";
-// import type { BundleAssociationMetadata } from "./types";
-export const KB = 1000;
-export const SCSS_BUNDLES_INPUT_DIR = path.join("src", "bundles", "scss");
-export const BASE_BUNDLES_OUT_DIR = path.join("dist", "bundles");
-export const SCSS_BUNDLES_OUT_DIR = path.join(BASE_BUNDLES_OUT_DIR, "scss");
-export const CSS_BUNDLES_OUT_DIR = path.join(BASE_BUNDLES_OUT_DIR, "css");
-export const BASE_BUNDLE = "base/base";
-export const BASE_GLOBANT_BUNDLE = "base/base-globant";
-// Files
-export const BUNDLE_MAPPING_TO_HASH_FILE = "bundle-to-hash-mappings.ts";
-export const BASE_CSS_FILE = "base.css";
-export const BASE_GLOBANT_CSS_FILE = "base-globant.css";
-// Placeholders
-export const ICONS_PATH_PLACEHOLDER = "{{ICONS_PATH}}";
-export const FONT_FACE_PATH_PLACEHOLDER = "{{FONT_FACE_PATH}}";
-// Defaults
-export const DEFAULT_FONT_FACE_PATH = "./assets/fonts/";
-export const DEFAULT_ICONS_PATH = "./assets/icons/";
-export const DEFAULT_OUT_DIR_PATH = "./.mercury";
-export const SEPARATE_BY_COMMA_REGEX = /\s*,\s*/g;
-export const SPECIAL_CHARS_IN_BUNDLE_NAME_REGEX = /[/-]/g;
-export const HASH_LENGTH = 16;
-export const HASH_AND_LETTER_LENGTH = HASH_LENGTH + 1;

package/dist/cli/internal/create-bundles-with-custom-paths.d.ts

@@ -1,10 +0,0 @@
-import type { CLIArguments, FileMetadata } from "./types";
-export declare const createBundleWithCustomPath: (args: CLIArguments, options: {
-    bundleFolder: string;
-    fileBaseDirToWrite: string;
-}, fileMetadata: FileMetadata, avoidAllHashes: boolean, actualFilePath: string) => {
-    bundleName: string;
-    bundleNameWithHash: string;
-    fileSize: string;
-};
-export declare const createBundlesWithCustomPaths: (args: CLIArguments, avoidAllHashes?: boolean) => Promise<void>;

package/dist/cli/internal/create-bundles-with-custom-paths.js

@@ -1,114 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { BASE_BUNDLE, BASE_CSS_FILE, BASE_GLOBANT_BUNDLE, BASE_GLOBANT_CSS_FILE, BUNDLE_MAPPING_TO_HASH_FILE, DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH, HASH_AND_LETTER_LENGTH } from "./constants.js";
-import { getFilesInDir } from "./file-management.js";
-import { getBundleFolderAndFileBaseDir, getBundleName, getFileNameWithHash, getFileNameWithoutExt, getFileSize, getHash, sanitizeBundleName } from "./utils.js";
-import { printBundleWasCreated, printBundleWasCreatedTableHeader } from "./print-utils.js";
-export const createBundleWithCustomPath = (args, options, fileMetadata, avoidAllHashes, actualFilePath) => {
-    const { avoidHash, fontFacePath, iconsPath } = args;
-    const { bundleFolder, fileBaseDirToWrite } = options;
-    const fileNameWithoutExt = getFileNameWithoutExt(fileMetadata);
-    const bundleName = getBundleName(fileMetadata);
-    // Copy CSS bundle
-    let css = fs.readFileSync(actualFilePath ?? fileMetadata.filePath, {
-        encoding: "utf8"
-    });
-    if (fontFacePath !== DEFAULT_FONT_FACE_PATH) {
-        css = css.replaceAll(DEFAULT_FONT_FACE_PATH, fontFacePath);
-    }
-    if (iconsPath !== DEFAULT_ICONS_PATH) {
-        css = css.replaceAll(DEFAULT_ICONS_PATH, iconsPath);
-    }
-    const fileNameWithHash = avoidAllHashes || avoidHash.has(bundleName)
-        ? fileNameWithoutExt
-        : getFileNameWithHash(fileNameWithoutExt, getHash(css));
-    const fileNameToWriteCss = `${fileNameWithHash}.css`;
-    const filePathWithHash = path.join(fileBaseDirToWrite, fileNameToWriteCss);
-    // Create the CSS bundle with hash
-    fs.writeFileSync(filePathWithHash, css);
-    return {
-        bundleName,
-        bundleNameWithHash: sanitizeBundleName(`${bundleFolder}/${fileNameWithHash}`),
-        fileSize: getFileSize(css)
-    };
-};
-export const createBundlesWithCustomPaths = async (args, avoidAllHashes = false) => {
-    const hasGlobantVariant = args.globant;
-    const outDir = path.join(args.outDirPath);
-    const CREATED_DIRS = new Set();
-    // This is a WA to have __filename and __dirname in ES modules
-    const __filename = fileURLToPath(import.meta.url);
-    // Directory name where the script is located (<path from root to node_modules/@genexus/mercury>/dist/cli/)
-    const __dirname = path.dirname(__filename);
-    const cssOutput = path.join(__dirname, "../../bundles/css");
-    /**
-     * Files to transpile
-     */
-    const allFilesToCopy = await getFilesInDir(cssOutput);
-    let largestBundleLength = BUNDLE_MAPPING_TO_HASH_FILE.length;
-    let largestFileSizeLength = 0;
-    allFilesToCopy.forEach(fileMetadata => {
-        const options = getBundleFolderAndFileBaseDir(fileMetadata, outDir);
-        largestBundleLength = Math.max(largestBundleLength, options.bundleFolder.length + fileMetadata.fileName.length);
-    });
-    if (!avoidAllHashes) {
-        largestBundleLength += HASH_AND_LETTER_LENGTH;
-    }
-    const copiedFiles = [];
-    allFilesToCopy.forEach(fileMetadata => {
-        const bundleName = getBundleName(fileMetadata);
-        const options = getBundleFolderAndFileBaseDir(fileMetadata, outDir);
-        const { fileBaseDirToWrite } = options;
-        let actualFilePath = fileMetadata.filePath;
-        if (!CREATED_DIRS.has(fileBaseDirToWrite)) {
-            CREATED_DIRS.add(fileBaseDirToWrite);
-            fs.mkdirSync(path.join(fileBaseDirToWrite), { recursive: true });
-        }
-        // There is no need to copy the base-globant.css file, since the base.css
-        // file already contains this file
-        if (hasGlobantVariant) {
-            if (bundleName === BASE_GLOBANT_BUNDLE) {
-                return;
-            }
-            // Replace the content of the base bundle with the Globant variant
-            if (bundleName === BASE_BUNDLE) {
-                actualFilePath = actualFilePath.replace(BASE_CSS_FILE, BASE_GLOBANT_CSS_FILE);
-            }
-        }
-        copiedFiles.push(createBundleWithCustomPath(args, options, fileMetadata, avoidAllHashes, actualFilePath));
-    });
-    copiedFiles.sort((a, b) => (a.bundleName <= b.bundleName ? -1 : 0));
-    const bundleMappingFileContent = `export const bundleToHashMappings = {\n${copiedFiles.map(entry => `  "${entry.bundleName}": "${entry.bundleNameWithHash}"`).join(",\n")}\n} as const;\n`;
-    const bundleMappingFileSize = getFileSize(bundleMappingFileContent);
-    const bundleMappingFilePath = path.join(outDir, BUNDLE_MAPPING_TO_HASH_FILE);
-    // Compute the largest fileName length
-    largestFileSizeLength = copiedFiles.reduce((acc, copiedFile) => Math.max(acc, copiedFile.fileSize.length), bundleMappingFileSize.length);
-    printBundleWasCreatedTableHeader({
-        largestBundleLength: avoidAllHashes
-            ? largestBundleLength
-            : largestBundleLength + 1,
-        outDir
-    });
-    // Print bundle created message
-    for (let index = 0; index < copiedFiles.length; index++) {
-        const entry = copiedFiles[index];
-        printBundleWasCreated({
-            bundleNameWithHash: `${entry.bundleNameWithHash}.css`,
-            fileSize: entry.fileSize,
-            largestBundleLength,
-            largestFileSizeLength,
-            outDir
-        });
-    }
-    fs.writeFileSync(bundleMappingFilePath, bundleMappingFileContent);
-    // Separate the TS file
-    console.log("");
-    printBundleWasCreated({
-        bundleNameWithHash: BUNDLE_MAPPING_TO_HASH_FILE,
-        fileSize: getFileSize(bundleMappingFileContent),
-        largestBundleLength,
-        largestFileSizeLength,
-        outDir
-    });
-};

package/dist/cli/internal/file-management.d.ts

@@ -1,5 +0,0 @@
-import type { FileMetadata } from "./types";
-export declare const ensureDirectoryExistsAndItsClear: (dirPath: string, filesToNotRemove?: Set<string>) => Promise<void>;
-export declare const getFilesInDir: (dir: string) => Promise<FileMetadata[]>;
-export declare const copyDirectories: (srcDir: string, outDir: string) => void;
-export declare const refreshAngularBrowser: () => void;

package/dist/cli/internal/file-management.js

@@ -1,53 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { readdir, rm } from "node:fs/promises";
-export const ensureDirectoryExistsAndItsClear = async (dirPath, filesToNotRemove) => {
-    // First build
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-        return;
-    }
-    // Incremental rebuild keeps some file without any changes, so we must skip
-    // the file deletion
-    if (filesToNotRemove) {
-        const filesInDir = await getFilesInDir(dirPath);
-        await Promise.all(filesInDir.map(file => filesToNotRemove.has(file.filePath)
-            ? Promise.resolve()
-            : rm(file.filePath)));
-    }
-    // Incremental rebuild did not include any file to exclude its removal
-    else {
-        fs.rmSync(dirPath, { recursive: true });
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-};
-export const getFilesInDir = async (dir) => {
-    const filesAndDirs = await readdir(dir, {
-        withFileTypes: true,
-        recursive: true
-    });
-    const files = [];
-    for (let index = 0; index < filesAndDirs.length; index++) {
-        const file = filesAndDirs[index];
-        if (file.isFile()) {
-            files.push({
-                dir: file.parentPath,
-                fileName: file.name,
-                filePath: path.join(file.parentPath, file.name)
-            });
-        }
-    }
-    return files;
-};
-export const copyDirectories = (srcDir, outDir) => fs.cpSync(srcDir, outDir, { recursive: true });
-export const refreshAngularBrowser = () => {
-    const ANGULAR_FILE_TO_TRIGGER_RELOAD = path.join(process.cwd(), "../showcase/src/index.html");
-    const FILE_CONTENT = fs.readFileSync(ANGULAR_FILE_TO_TRIGGER_RELOAD, {
-        encoding: "utf8"
-    });
-    // Trigger a dummy write in the index.html
-    fs.writeFileSync(ANGULAR_FILE_TO_TRIGGER_RELOAD, FILE_CONTENT + "\n");
-    // Rollback that write to not provoke any changes, but do it after the
-    // debounce of the Angular CLI has completed the queued HMR
-    setTimeout(() => fs.writeFileSync(ANGULAR_FILE_TO_TRIGGER_RELOAD, FILE_CONTENT), 300);
-};

package/dist/cli/internal/print-utils.d.ts

@@ -1,18 +0,0 @@
-export declare const printBundleWasCreatedTableHeader: (args: {
-    outDir: string;
-    largestBundleLength: number;
-}) => void;
-export declare const printBundleWasCreated: (args: {
-    outDir: string;
-    bundleNameWithHash: string;
-    largestBundleLength: number;
-    largestFileSizeLength: number;
-    fileSize: string;
-}) => void;
-export declare const printBundleWasTranspiled: (filePath: string) => void;
-export declare const printArgumentDoesNotExistsError: (arg: string) => void;
-export declare const printDuplicatedArgumentError: (arg: string) => void;
-export declare const printInvalidArgumentError: (arg: string) => void;
-export declare const printMissingFontPathArgumentWarning: () => void;
-export declare const printMissingIconsPathArgumentWarning: () => void;
-export declare const printMissingOutDirPathArgumentWarning: () => void;

package/dist/cli/internal/print-utils.js

@@ -1,35 +0,0 @@
-import { styleText } from "node:util";
-import { DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH, DEFAULT_OUT_DIR_PATH, SCSS_BUNDLES_INPUT_DIR, SCSS_BUNDLES_OUT_DIR } from "./constants.js";
-import path from "node:path";
-const separator = () => styleText(["gray"], " | ");
-export const printBundleWasCreatedTableHeader = (args) => console.log(styleText(["white", "bold"], "Files") +
-    " ".repeat(args.largestBundleLength + args.outDir.length - "Files".length) +
-    separator() +
-    styleText(["white", "bold"], "Raw size"));
-export const printBundleWasCreated = (args) => console.log(styleText("white", args.outDir) +
-    styleText("greenBright", path.join(args.outDir, args.bundleNameWithHash).replace(args.outDir, "")) +
-    " ".repeat(Math.max(args.largestBundleLength - args.bundleNameWithHash.length, 0)) +
-    separator() +
-    " ".repeat(Math.max(args.largestFileSizeLength - args.fileSize.length, 0)) +
-    styleText("cyanBright", args.fileSize));
-export const printBundleWasTranspiled = (filePath) => console.log(styleText("greenBright", "  Transpiled: ") +
-    styleText("white", SCSS_BUNDLES_OUT_DIR) +
-    styleText("whiteBright", filePath.replace(SCSS_BUNDLES_INPUT_DIR, "")));
-export const printArgumentDoesNotExistsError = (arg) => console.log(styleText("red", "  error ") +
-    styleText("gray", "Argument does not exists: ") +
-    `'${arg}'`);
-export const printDuplicatedArgumentError = (arg) => console.log(styleText("red", "  error ") +
-    styleText("gray", "Duplicated argument type: ") +
-    `'${arg}'`);
-export const printInvalidArgumentError = (arg) => console.log(styleText("red", "  error ") +
-    styleText("gray", "Invalid argument: ") +
-    `'${arg}'`);
-export const printMissingFontPathArgumentWarning = () => console.log(styleText("yellow", "  [warning]: Missing --font-face-path argument. The path ") +
-    styleText("cyan", `'${DEFAULT_FONT_FACE_PATH}'`) +
-    styleText("yellow", " will be used as default."));
-export const printMissingIconsPathArgumentWarning = () => console.log(styleText("yellow", "  [warning]: Missing --icons-path argument. The path ") +
-    styleText("cyan", `'${DEFAULT_ICONS_PATH}'`) +
-    styleText("yellow", " will be used as default."));
-export const printMissingOutDirPathArgumentWarning = () => console.log(styleText("yellow", "  [warning]: Missing --outDir argument. The path ") +
-    styleText("cyan", `'${DEFAULT_OUT_DIR_PATH}'`) +
-    styleText("yellow", " will be used as default."));

package/dist/cli/internal/transpile-bundle-and-create-mappings.d.ts

@@ -1,2 +0,0 @@
-import type { CLIArguments, FileMetadata } from "./types";
-export declare const transpileCssBundleWithPlaceholder: (fileMetadata: FileMetadata, args?: CLIArguments) => Promise<void>;

package/dist/cli/internal/transpile-bundle-and-create-mappings.js

@@ -1,57 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import * as sass from "sass";
-import { BASE_BUNDLE, BASE_GLOBANT_BUNDLE, BASE_GLOBANT_CSS_FILE, CSS_BUNDLES_OUT_DIR, DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH, SCSS_BUNDLES_INPUT_DIR, SCSS_BUNDLES_OUT_DIR } from "./constants.js";
-import { replacePlaceholdersInBundle, sanitizeBundleName } from "./utils.js";
-const transpileBundle = (filePath, globant) => sass.compile(filePath, {
-    loadPaths: [globant ? "src/config/globant" : "src/config/default"],
-    style: "compressed"
-}).css;
-const BUNDLES = [];
-const transpileGlobantCssFile = async (fileMetadata, cssOutDir) => {
-    const { filePath } = fileMetadata;
-    BUNDLES.push({
-        fileDir: fileMetadata.dir
-            .replace(SCSS_BUNDLES_OUT_DIR, "")
-            .replace("\\", "/")
-    });
-    const transpiledBundle = transpileBundle(filePath, true);
-    // Store the CSS file with its default values
-    await fs.writeFile(path.join(cssOutDir, BASE_GLOBANT_CSS_FILE), replacePlaceholdersInBundle(transpiledBundle, DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH));
-};
-export const transpileCssBundleWithPlaceholder = async (fileMetadata, args) => {
-    const { fileName } = fileMetadata;
-    let actualFilePath = fileMetadata.filePath;
-    const hasGlobantVariant = args?.globant ?? false;
-    const cssOutDir = fileMetadata.dir.replace(SCSS_BUNDLES_INPUT_DIR, CSS_BUNDLES_OUT_DIR);
-    const fileNameCssExt = fileName.replace(".scss", ".css");
-    const bundleName = sanitizeBundleName(actualFilePath.replace(SCSS_BUNDLES_INPUT_DIR, "").replace(".scss", ""));
-    // There is no need to generate the base-globant.css file, since the base.css
-    // file already contains this file
-    if (hasGlobantVariant) {
-        if (bundleName === BASE_GLOBANT_BUNDLE) {
-            return;
-        }
-        // Replace the content of the base bundle with the Globant variant
-        if (bundleName === BASE_BUNDLE) {
-            actualFilePath = actualFilePath.replace(BASE_BUNDLE, BASE_GLOBANT_BUNDLE);
-        }
-    }
-    // The Globant variant is not forced, so we are creating both bundles, the
-    // base/base and base/base-globant bundles
-    else if (bundleName === BASE_BUNDLE) {
-        transpileGlobantCssFile({
-            dir: fileMetadata.dir,
-            fileName: fileName.replace(BASE_BUNDLE, BASE_GLOBANT_BUNDLE),
-            filePath: actualFilePath
-        }, cssOutDir);
-    }
-    BUNDLES.push({
-        fileDir: fileMetadata.dir
-            .replace(SCSS_BUNDLES_INPUT_DIR, "")
-            .replace("\\", "/")
-    });
-    const transpiledBundle = transpileBundle(actualFilePath, hasGlobantVariant);
-    // Store the CSS file with its default values
-    await fs.writeFile(path.join(cssOutDir, fileNameCssExt), replacePlaceholdersInBundle(transpiledBundle, DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH));
-};

package/dist/cli/internal/types.d.ts

@@ -1,20 +0,0 @@
-export type BundleMetadata = {
-    fileDir: string;
-};
-export type BundleAssociationMetadata = {
-    bundleName: string;
-    fileDir: string;
-    transpiledBundle: string;
-};
-export type FileMetadata = {
-    dir: string;
-    fileName: string;
-    filePath: string;
-};
-export type CLIArguments = {
-    avoidHash: Set<string>;
-    globant: boolean;
-    iconsPath: string;
-    fontFacePath: string;
-    outDirPath: string;
-};

package/dist/cli/internal/types.js

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

package/dist/cli/internal/utils.d.ts

@@ -1,14 +0,0 @@
-import type { FileMetadata } from "./types";
-export declare const getFileSize: (fileContent: string) => string;
-export declare const getHash: (fileContent: string) => string;
-export declare const getFileNameWithHash: <B extends string, H extends string>(bundleName: B, hash: H) => `${B}-${H}`;
-export declare const replacePlaceholdersInBundle: (transpiledBundle: string, fontFaceValue: string, iconsValue: string) => string;
-export declare const measureTime: (callback: (() => void) | (() => Promise<void>)) => Promise<void>;
-export declare const sanitizeBundleName: (bundleName: string) => string;
-export declare const getBundleFolder: (fileMetadata: FileMetadata) => string;
-export declare const getBundleFolderAndFileBaseDir: (fileMetadata: FileMetadata, outDir: string) => {
-    bundleFolder: string;
-    fileBaseDirToWrite: string;
-};
-export declare const getFileNameWithoutExt: (fileMetadata: FileMetadata) => string;
-export declare const getBundleName: (fileMetadata: FileMetadata) => string;

package/dist/cli/internal/utils.js

@@ -1,47 +0,0 @@
-import crypto from "node:crypto";
-import { styleText } from "node:util";
-import { CSS_BUNDLES_OUT_DIR, FONT_FACE_PATH_PLACEHOLDER, HASH_LENGTH, ICONS_PATH_PLACEHOLDER, KB
-// SPECIAL_CHARS_IN_BUNDLE_NAME_REGEX
- } from "./constants.js";
-import path from "node:path";
-export const getFileSize = (fileContent) => {
-    const fileLength = fileContent.length;
-    if (fileLength < KB) {
-        return fileLength + " bytes";
-    }
-    const fileLengthInKB = fileLength / KB;
-    if (fileLengthInKB < KB) {
-        return fileLengthInKB.toFixed(2) + " kB";
-    }
-    const fileLengthInMB = fileLengthInKB / KB;
-    if (fileLengthInMB < KB) {
-        return fileLengthInMB.toFixed(2) + " MB";
-    }
-    const fileLengthInGB = fileLengthInMB / KB;
-    return fileLengthInGB.toFixed(2) + " GB";
-};
-export const getHash = (fileContent) => crypto
-    .createHash("md5")
-    .update(fileContent)
-    .digest("hex")
-    .substring(HASH_LENGTH);
-export const getFileNameWithHash = (bundleName, hash) => `${bundleName}-${hash}`;
-export const replacePlaceholdersInBundle = (transpiledBundle, fontFaceValue, iconsValue) => transpiledBundle
-    .replaceAll(ICONS_PATH_PLACEHOLDER, iconsValue)
-    .replaceAll(FONT_FACE_PATH_PLACEHOLDER, fontFaceValue);
-export const measureTime = async (callback) => {
-    console.time(styleText("green", "Done in"));
-    await callback();
-    console.timeEnd(styleText("green", "Done in"));
-};
-export const sanitizeBundleName = (bundleName) => bundleName.replaceAll("\\", "/").replace(/^\//, "");
-export const getBundleFolder = (fileMetadata) => fileMetadata.dir.split(CSS_BUNDLES_OUT_DIR)[1];
-export const getBundleFolderAndFileBaseDir = (fileMetadata, outDir) => {
-    const bundleFolder = getBundleFolder(fileMetadata);
-    return {
-        bundleFolder,
-        fileBaseDirToWrite: path.join(outDir, bundleFolder)
-    };
-};
-export const getFileNameWithoutExt = (fileMetadata) => fileMetadata.fileName.replace(/.css$/, "");
-export const getBundleName = (fileMetadata) => sanitizeBundleName(`${getBundleFolder(fileMetadata)}/${getFileNameWithoutExt(fileMetadata)}`);

package/dist/cli/internal/validate-args.d.ts

@@ -1,2 +0,0 @@
-import type { CLIArguments } from "./types";
-export declare const getArguments: () => CLIArguments | undefined;