@genexus/mercury 0.12.9 → 0.13.1

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

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+// @ts-expect-error: This file does exists after the bundle transpilation process
+import { bundleMappings } from "../../bundles/js/bundle-mappings.js";
+import { BASE_BUNDLE, BASE_GLOBANT_BUNDLE, BUNDLE_MAPPING_TO_HASH_FILE } from "./constants.js";
+import { getBundleNameWithHash, getHash, replacePlaceholdersInBundle } from "./utils.js";
+import { printBundleToHashMappingsWasCreated, printBundleWasCreated } from "./print-utils.js";
+const findLargestPath = () => {
+    let largestBundleLength = 0;
+    bundleMappings.forEach(entry => {
+        largestBundleLength = Math.max(largestBundleLength, entry.bundleName.length);
+    });
+    return largestBundleLength;
+};
+const getActualBundleName = (bundleName) => bundleName === BASE_BUNDLE || bundleName === BASE_GLOBANT_BUNDLE
+    ? BASE_BUNDLE
+    : bundleName;
+const shouldSkipBundleCreation = (bundleName, globant) => (bundleName === BASE_BUNDLE && globant) ||
+    (bundleName === BASE_GLOBANT_BUNDLE && !globant);
+export const createBundlesWithCustomPaths = (args) => {
+    const { avoidHash, fontFacePath, iconsPath, globant } = args;
+    const outDir = path.join(args.outDirPath);
+    const CREATED_DIRS = new Set();
+    const largestBundleLength = findLargestPath();
+    let bundleMappingToHashObjectEntries = "";
+    bundleMappings.forEach(entry => {
+        const { bundleName, fileDir, transpiledBundle } = entry;
+        if (shouldSkipBundleCreation(bundleName, globant)) {
+            return;
+        }
+        const actualBundleName = getActualBundleName(bundleName);
+        const compiledBundleWithoutPlaceholders = replacePlaceholdersInBundle(transpiledBundle, fontFacePath, iconsPath);
+        const hash = getHash(compiledBundleWithoutPlaceholders);
+        if (fileDir && !CREATED_DIRS.has(fileDir)) {
+            fs.mkdirSync(path.join(outDir, fileDir), { recursive: true });
+            CREATED_DIRS.add(fileDir);
+        }
+        const bundleNameWithHash = avoidHash.has(actualBundleName)
+            ? actualBundleName
+            : getBundleNameWithHash(actualBundleName, hash);
+        const filePathToCreateBundle = path.join(outDir, `${bundleNameWithHash}.css`);
+        fs.writeFileSync(filePathToCreateBundle, compiledBundleWithoutPlaceholders);
+        printBundleWasCreated({
+            outDir,
+            bundleName: actualBundleName,
+            compiledBundleWithoutPlaceholders,
+            filePathToCreateBundle,
+            // WA to improve style
+            largestBundleLength: largestBundleLength + (avoidHash.has(actualBundleName) ? 17 : 0)
+        });
+        // Store the bundle mapping.
+        // For example: "components/button" --> "components/button-9f82641938b85445"
+        const bundleToHashEntry = `  "${actualBundleName}": "${bundleNameWithHash}"`;
+        // Concat entries in the object
+        bundleMappingToHashObjectEntries +=
+            bundleMappingToHashObjectEntries === ""
+                ? bundleToHashEntry
+                : ",\n" + bundleToHashEntry;
+    });
+    bundleMappingToHashObjectEntries = `export const bundleToHashMappings = {\n${bundleMappingToHashObjectEntries}\n} as const;\n`;
+    const bundleMappingFilePath = path.join(outDir, BUNDLE_MAPPING_TO_HASH_FILE);
+    fs.writeFileSync(bundleMappingFilePath, bundleMappingToHashObjectEntries);
+    printBundleToHashMappingsWasCreated({
+        outDir,
+        filePath: bundleMappingFilePath
+    });
+};

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

@@ -0,0 +1,4 @@
+import type { FileMetadata } from "./types";
+export declare const ensureDirectoryExistsAndItsClear: (dirPath: string) => void;
+export declare function walkSync(dir: string): Generator<FileMetadata>;
+export declare const copyDirectories: (srcDir: string, outDir: string) => void;

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

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import path from "node:path";
+export const ensureDirectoryExistsAndItsClear = (dirPath) => {
+    if (fs.existsSync(dirPath)) {
+        fs.rmSync(dirPath, { recursive: true });
+    }
+    fs.mkdirSync(dirPath, { recursive: true });
+};
+export function* walkSync(dir) {
+    const files = fs.readdirSync(dir, { withFileTypes: true });
+    for (const file of files) {
+        if (file.isDirectory()) {
+            yield* walkSync(path.join(dir, file.name));
+        }
+        else {
+            yield { dir, fileName: file.name, filePath: path.join(dir, file.name) };
+        }
+    }
+}
+export const copyDirectories = (srcDir, outDir) => fs.cpSync(srcDir, outDir, { recursive: true });

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

@@ -0,0 +1,18 @@
+export declare const printBundleWasCreated: (args: {
+    outDir: string;
+    bundleName: string;
+    largestBundleLength: number;
+    filePathToCreateBundle: string;
+    compiledBundleWithoutPlaceholders: string;
+}) => void;
+export declare const printBundleToHashMappingsWasCreated: (args: {
+    outDir: string;
+    filePath: 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

@@ -0,0 +1,33 @@
+import { styleText } from "node:util";
+import { getFileSize } from "./utils.js";
+import { DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH, DEFAULT_OUT_DIR_PATH, SCSS_BUNDLES_OUT_DIR } from "./constants.js";
+export const printBundleWasCreated = (args) => console.log(styleText("greenBright", "  Created: ") +
+    styleText("white", args.outDir) +
+    styleText("whiteBright", args.filePathToCreateBundle.replace(args.outDir, "")) +
+    styleText("cyan", " ".repeat(1 + args.largestBundleLength - args.bundleName.length) +
+        getFileSize(args.compiledBundleWithoutPlaceholders)));
+export const printBundleToHashMappingsWasCreated = (args) => console.log("\n" +
+    styleText("greenBright", "  Created: ") +
+    styleText("white", args.outDir) +
+    styleText("whiteBright", args.filePath.replace(args.outDir, "")));
+export const printBundleWasTranspiled = (filePath) => console.log(styleText("greenBright", "  Transpiled: ") +
+    styleText("white", SCSS_BUNDLES_OUT_DIR) +
+    styleText("whiteBright", filePath.replace(SCSS_BUNDLES_OUT_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

@@ -0,0 +1,3 @@
+import { FileMetadata } from "./types.js";
+export declare const transpileCssBundleWithPlaceholder: (fileMetadata: FileMetadata) => void;
+export declare const createBundleMappingsFile: () => void;

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

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as sass from "sass";
+import { BASE_BUNDLE_WITH_BACK_SLASH, BASE_GLOBANT_CSS_FILE, BASE_GLOBANT_FILE, BASE_GLOBANT_JS_FILE, BASE_GLOBANT_SCSS_FILE, BASE_SCSS_FILE, BUNDLE_MAPPING_ENTRIES, BUNDLE_MAPPING_FILE, CSS_BUNDLES_OUT_DIR, DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH, JS_BUNDLES_OUT_DIR, SCSS_BUNDLES_OUT_DIR } from "./constants.js";
+import { getBundleNameWithoutSpecialChars, replacePlaceholdersInBundle } from "./utils.js";
+import { printBundleWasTranspiled } from "./print-utils.js";
+const transpileBundle = (filePath, globant) => sass.compile(filePath, {
+    loadPaths: [globant ? "src/config/globant" : "src/config/default"],
+    style: "compressed"
+}).css;
+const CSS_CREATED_DIRS = new Set();
+const JS_CREATED_DIRS = new Set();
+const BUNDLES = [];
+const addBaseGlobantFile = (fileMetadata, cssOutDir, jsOutDir) => {
+    const { filePath } = fileMetadata;
+    BUNDLES.push({
+        fileDir: fileMetadata.dir
+            .replace(SCSS_BUNDLES_OUT_DIR, "")
+            .replace("\\", "/"),
+        bundleNameWithBackSlash: filePath
+            .replace(SCSS_BUNDLES_OUT_DIR, "")
+            .replace(BASE_SCSS_FILE, BASE_GLOBANT_FILE)
+    });
+    const transpiledBundle = transpileBundle(filePath, true);
+    // Store the CSS file with its default values
+    fs.writeFileSync(path.join(cssOutDir, BASE_GLOBANT_CSS_FILE), replacePlaceholdersInBundle(transpiledBundle, DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH));
+    // Store the CSS file in a JS file with placeholders for the values
+    fs.writeFileSync(path.join(jsOutDir, BASE_GLOBANT_JS_FILE), `export const bundle = \`${transpiledBundle}\`;`);
+    printBundleWasTranspiled(filePath.replace(BASE_SCSS_FILE, BASE_GLOBANT_SCSS_FILE));
+};
+export const transpileCssBundleWithPlaceholder = (fileMetadata) => {
+    const { fileName, filePath } = fileMetadata;
+    const cssOutDir = fileMetadata.dir.replace(SCSS_BUNDLES_OUT_DIR, CSS_BUNDLES_OUT_DIR);
+    const jsOutDir = fileMetadata.dir.replace(SCSS_BUNDLES_OUT_DIR, JS_BUNDLES_OUT_DIR);
+    const fileNameCssExt = fileName.replace(".scss", ".css");
+    const fileNameJsExt = fileName.replace(".scss", ".js");
+    const bundleNameWithBackSlash = filePath
+        .replace(SCSS_BUNDLES_OUT_DIR, "")
+        .replace(".scss", "");
+    BUNDLES.push({
+        fileDir: fileMetadata.dir
+            .replace(SCSS_BUNDLES_OUT_DIR, "")
+            .replace("\\", "/"),
+        bundleNameWithBackSlash
+    });
+    // Create the file directory if it does not exists
+    if (!CSS_CREATED_DIRS.has(cssOutDir)) {
+        fs.mkdirSync(cssOutDir, { recursive: true });
+        fs.mkdirSync(jsOutDir, { recursive: true });
+        CSS_CREATED_DIRS.add(cssOutDir);
+        JS_CREATED_DIRS.add(jsOutDir);
+    }
+    const transpiledBundle = transpileBundle(filePath, false);
+    // Store the CSS file with its default values
+    fs.writeFileSync(path.join(cssOutDir, fileNameCssExt), replacePlaceholdersInBundle(transpiledBundle, DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH));
+    // Store the CSS file in a JS file with placeholders for the values
+    fs.writeFileSync(path.join(jsOutDir, fileNameJsExt), `export const bundle = \`${transpiledBundle}\`;`);
+    printBundleWasTranspiled(filePath);
+    if (bundleNameWithBackSlash === BASE_BUNDLE_WITH_BACK_SLASH) {
+        addBaseGlobantFile(fileMetadata, cssOutDir, jsOutDir);
+    }
+};
+const createBundleEntryInMappingFile = (bundleName, fileDir, transpiledBundleRef) => `  {
+    ${BUNDLE_MAPPING_ENTRIES.BUNDLE_NAME}: "${bundleName}",
+    ${BUNDLE_MAPPING_ENTRIES.FILE_DIR}: "${fileDir}",
+    ${BUNDLE_MAPPING_ENTRIES.TRANSPILED_BUNDLE}: ${transpiledBundleRef}
+  }`;
+export const createBundleMappingsFile = () => {
+    let bundleAssociationImports = "";
+    let bundleMappingObjectEntries = "";
+    BUNDLES.forEach(bundleMetadata => {
+        const bundleName = bundleMetadata.bundleNameWithBackSlash
+            .replaceAll("\\", "/")
+            .substring(1);
+        const transpiledBundleRef = getBundleNameWithoutSpecialChars(bundleName);
+        const bundleEntry = createBundleEntryInMappingFile(bundleName, bundleMetadata.fileDir, transpiledBundleRef);
+        bundleAssociationImports += `import { bundle as ${transpiledBundleRef} } from "./${bundleName}.js";\n`;
+        // Concat entries in the object
+        bundleMappingObjectEntries +=
+            bundleMappingObjectEntries === "" ? bundleEntry : ",\n" + bundleEntry;
+    });
+    bundleMappingObjectEntries = `\nexport const bundleMappings = [\n${bundleMappingObjectEntries}\n];`;
+    // Create the JS file that contains all mappings for the bundle
+    fs.writeFileSync(path.join(JS_BUNDLES_OUT_DIR, BUNDLE_MAPPING_FILE), bundleAssociationImports + bundleMappingObjectEntries);
+};

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

@@ -0,0 +1,21 @@
+export type BundleMetadata = {
+    fileDir: string;
+    bundleNameWithBackSlash: 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

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

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

@@ -0,0 +1,11 @@
+export declare const getFileSize: (fileContent: string) => string;
+export declare const getHash: (fileContent: string) => string;
+export declare const getBundleNameWithHash: <B extends string, H extends string>(bundleName: B, hash: H) => `${B}-${H}`;
+export declare const replacePlaceholdersInBundle: (transpiledBundle: string, fontFaceValue: string, iconsValue: string) => string;
+/**
+ * @example
+ * "base/icons" --> "baseIcons"
+ * "utils/form--full" --> "utilsFormFull"
+ */
+export declare const getBundleNameWithoutSpecialChars: (bundleName: string) => string;
+export declare const measureTime: (callback: () => void) => void;

package/dist/cli/internal/utils.js

@@ -0,0 +1,42 @@
+import crypto from "node:crypto";
+import { styleText } from "node:util";
+import { FONT_FACE_PATH_PLACEHOLDER, ICONS_PATH_PLACEHOLDER, KB, SPECIAL_CHARS_IN_BUNDLE_NAME_REGEX } from "./constants.js";
+export const getFileSize = (fileContent) => {
+    const fileLength = fileContent.length;
+    if (fileLength < KB) {
+        return fileLength + "B";
+    }
+    const fileLengthInKB = fileLength / KB;
+    if (fileLengthInKB < KB) {
+        return fileLengthInKB + "KB";
+    }
+    const fileLengthInMB = fileLengthInKB / KB;
+    if (fileLengthInMB < KB) {
+        return fileLengthInMB.toFixed(3) + "MB";
+    }
+    const fileLengthInGB = fileLengthInMB / KB;
+    return fileLengthInGB.toFixed(3) + "GB";
+};
+export const getHash = (fileContent) => crypto.createHash("md5").update(fileContent).digest("hex").substring(16);
+export const getBundleNameWithHash = (bundleName, hash) => `${bundleName}-${hash}`;
+export const replacePlaceholdersInBundle = (transpiledBundle, fontFaceValue, iconsValue) => transpiledBundle
+    .replaceAll(ICONS_PATH_PLACEHOLDER, iconsValue)
+    .replaceAll(FONT_FACE_PATH_PLACEHOLDER, fontFaceValue);
+/**
+ * @example
+ * "base/icons" --> "baseIcons"
+ * "utils/form--full" --> "utilsFormFull"
+ */
+export const getBundleNameWithoutSpecialChars = (bundleName) => {
+    const bundleNameNoSpecialChars = bundleName
+        .split(SPECIAL_CHARS_IN_BUNDLE_NAME_REGEX)
+        .map(subPath => subPath.charAt(0).toUpperCase() + subPath.slice(1))
+        .join("");
+    return (bundleNameNoSpecialChars.charAt(0).toLowerCase() +
+        bundleNameNoSpecialChars.slice(1));
+};
+export const measureTime = (callback) => {
+    console.time(styleText("green", "Done in"));
+    callback();
+    console.timeEnd(styleText("green", "Done in"));
+};

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

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

package/dist/cli/internal/validate-args.js

@@ -0,0 +1,119 @@
+import { DEFAULT_FONT_FACE_PATH, DEFAULT_ICONS_PATH, DEFAULT_OUT_DIR_PATH, SEPARATE_BY_COMMA_REGEX } from "./constants.js";
+import { printArgumentDoesNotExistsError, printDuplicatedArgumentError, printInvalidArgumentError, printMissingFontPathArgumentWarning, printMissingIconsPathArgumentWarning, printMissingOutDirPathArgumentWarning } from "./print-utils.js";
+const ARGUMENT_VALUE_AND_NAME_SEPARATOR_REGEX = /\s*=\s*/g;
+const ERROR_IN_CHECK = false;
+const SUCCESS_CHECK = true;
+const [, , ...args] = process.argv;
+const AVOID_HASH_ARGUMENTS = new Set(["--avoid-hash", "--ah", "-ah"]);
+const ICONS_PATH_ARGUMENTS = new Set(["--icons-path", "--icons", "--i", "-i"]);
+const FONT_FACE_PATH_ARGUMENTS = new Set([
+    "--font-face-path",
+    "--font-face",
+    "--f",
+    "-f"
+]);
+const OUT_DIR_ARGUMENTS = new Set(["--outdir", "--o", "-o"]);
+const GLOBANT_ARGUMENTS = new Set(["--globant", "--gl", "-gl"]);
+const isAvoidHashArgument = (arg) => AVOID_HASH_ARGUMENTS.has(arg.toLowerCase());
+const isFontFaceArgument = (arg) => FONT_FACE_PATH_ARGUMENTS.has(arg.toLowerCase());
+const isGlobantArgument = (arg) => GLOBANT_ARGUMENTS.has(arg.toLowerCase());
+const isIconsArgument = (arg) => ICONS_PATH_ARGUMENTS.has(arg.toLowerCase());
+const isOutDirArgument = (arg) => OUT_DIR_ARGUMENTS.has(arg.toLowerCase());
+let hasAvoidHash = false;
+let hasGlobant = false;
+let hasFontFacePath = false;
+let hasIconsPath = false;
+let hasOutDirPath = false;
+let anyWarning = false;
+let avoidHash = [];
+let fontFacePath = "";
+let iconsPath = "";
+let outDirPath = "";
+const checkArgument = (argument) => {
+    if (isGlobantArgument(argument)) {
+        if (hasGlobant) {
+            printDuplicatedArgumentError(argument);
+            return ERROR_IN_CHECK;
+        }
+        hasGlobant = true;
+        return SUCCESS_CHECK;
+    }
+    const argNameWithValue = argument.split(ARGUMENT_VALUE_AND_NAME_SEPARATOR_REGEX);
+    if (argNameWithValue.length !== 2) {
+        printInvalidArgumentError(argument);
+        return ERROR_IN_CHECK;
+    }
+    const argName = argNameWithValue[0];
+    const argValue = argNameWithValue[1];
+    if (isAvoidHashArgument(argName)) {
+        if (hasAvoidHash) {
+            printDuplicatedArgumentError(argument);
+            return ERROR_IN_CHECK;
+        }
+        avoidHash = argValue.split(SEPARATE_BY_COMMA_REGEX);
+        hasAvoidHash = true;
+        return SUCCESS_CHECK;
+    }
+    if (isFontFaceArgument(argName)) {
+        if (hasFontFacePath) {
+            printDuplicatedArgumentError(argument);
+            return ERROR_IN_CHECK;
+        }
+        fontFacePath = argValue;
+        hasFontFacePath = true;
+        return SUCCESS_CHECK;
+    }
+    if (isIconsArgument(argName)) {
+        if (hasIconsPath) {
+            printDuplicatedArgumentError(argument);
+            return ERROR_IN_CHECK;
+        }
+        iconsPath = argValue;
+        hasIconsPath = true;
+        return SUCCESS_CHECK;
+    }
+    if (isOutDirArgument(argName)) {
+        if (hasOutDirPath) {
+            printDuplicatedArgumentError(argument);
+            return ERROR_IN_CHECK;
+        }
+        outDirPath = argValue;
+        hasOutDirPath = true;
+        return SUCCESS_CHECK;
+    }
+    printArgumentDoesNotExistsError(argument);
+    return ERROR_IN_CHECK;
+};
+export const getArguments = () => {
+    for (let index = 0; index < args.length; index++) {
+        if (checkArgument(args[index]) === ERROR_IN_CHECK) {
+            return undefined;
+        }
+    }
+    if (!fontFacePath) {
+        printMissingFontPathArgumentWarning();
+        fontFacePath = DEFAULT_FONT_FACE_PATH;
+        anyWarning = true;
+    }
+    if (!iconsPath) {
+        printMissingIconsPathArgumentWarning();
+        iconsPath = DEFAULT_ICONS_PATH;
+        anyWarning = true;
+    }
+    if (!outDirPath) {
+        printMissingOutDirPathArgumentWarning();
+        outDirPath = DEFAULT_OUT_DIR_PATH;
+        anyWarning = true;
+    }
+    // Print a line break to better visualize warnings
+    if (anyWarning) {
+        console.log("");
+    }
+    return {
+        avoidHash: new Set(avoidHash),
+        globant: hasGlobant,
+        fontFacePath,
+        iconsPath,
+        outDirPath
+    };
+};

package/dist/cli/mercury.d.ts

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

package/dist/cli/mercury.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { createBundlesWithCustomPaths } from "./internal/create-bundles-with-custom-paths.js";
+import { ensureDirectoryExistsAndItsClear } from "./internal/file-management.js";
+import { getArguments } from "./internal/validate-args.js";
+import { measureTime } from "./internal/utils.js";
+measureTime(() => {
+    // Improve process visualization
+    console.log("");
+    const args = getArguments();
+    if (args) {
+        ensureDirectoryExistsAndItsClear(args.outDirPath);
+        createBundlesWithCustomPaths(args);
+    }
+});

package/dist/mercury.scss

@@ -4309,6 +4309,8 @@
   --code__border: var(--mer-border__width--sm) solid
     var(--mer-surface__elevation--03);
   --code__border-radius: var(--mer-border__radius--sm);
+
+  // TODO: Fix this. It MUST be two separated properties (padding-block and padding-inline)
   --code__padding: var(--mer-spacing--xs) var(--mer-spacing--sm);
 
   --ch-code__doctag: var(--code__color-blue);

package/dist/types.d.ts

@@ -7,6 +7,9 @@ export type MercuryBundleComponentForm = "components/button" | "components/check
 export type MercuryBundleReset = "resets/box-sizing";
 export type MercuryBundleUtil = "utils/elevation" | "utils/form" | "utils/layout" | "utils/spacing" | "utils/typography" | "chameleon/scrollbar";
 export type MercuryBundleUtilFormFull = "utils/form--full";
+export type MercuryBundleMapping = {
+    [key in MercuryBundleComponent | MercuryBundleComponentForm | MercuryBundleReset | MercuryBundleUtil | MercuryBundleUtilFormFull]: `${key}-${string}` | key;
+};
 export type AssetsMetadata = {
     category: string;
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genexus/mercury",
-  "version": "0.12.9",
+  "version": "0.13.1",
   "description": "Mercury is the design system designed for GeneXus IDE Web and GeneXus Next",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -9,6 +9,9 @@
     "dist/"
   ],
   "type": "module",
+  "bin": {
+    "mercury": "./dist/cli/mercury.js"
+  },
   "exports": {
     ".": {
       "import": {
@@ -16,6 +19,12 @@
         "default": "./dist/index.js"
       }
     },
+    "./MERCURY_ASSETS.js": {
+      "import": {
+        "types": "./dist/assets/MERCURY_ASSETS.d.ts",
+        "default": "./dist/assets/MERCURY_ASSETS.js"
+      }
+    },
     "./assets-manager.js": {
       "import": {
         "types": "./dist/assets-manager.d.ts",
@@ -40,8 +49,8 @@
     "build": "npm run build.js && npm run icons-svg && npm run icons-sass && npm run build.scss && npm run copy-tasks && npm run showcase.scss",
     "build.js": "tsc && esbuild dist/*.js --allow-overwrite --minify --outdir=dist && esbuild dist/assets/*.js --allow-overwrite --minify --outdir=dist/assets",
     "build-no-svg": "npm run build.js && npm run build.scss && npm run copy-tasks",
-    "build.scss": "scss-bundle -e ./src/mercury.scss -o dist/mercury.scss && npm run build.bundles && npm run copy-all.css",
-    "build.bundles": "fse copy --all --keepExisting --errorOnExist --dereference --preserveTimestamps --quiet src/bundles/scss dist/bundles/scss && sass --load-path=src --no-source-map --style compressed dist/bundles/scss:dist/bundles/css",
+    "build.scss": "scss-bundle -e ./src/mercury.scss -o dist/mercury.scss && npm run build.bundles",
+    "build.bundles": "node dist/cli/bundle.js",
     "start": "vite --port 5200 --open showcase/button.html",
     "validate.ci": "npm run build-no-svg",
     "icons-svg": "ssg-svg --srcDir=src/icons/svg-source --outDir=src/assets/icons/_generated/ --configFilePath=src/icons/svg-source/.config/color-states.json --showcaseDir=showcase/icons/ --showcaseBaseHref=../assets/icons/ --logDir=./log --objectFilePath=src/assets/MERCURY_ASSETS.ts --defaultColorType=on-surface",
@@ -57,6 +66,7 @@
     "@atao60/fse-cli": "^0.1.9",
     "@genexus/chameleon-controls-library": "6.0.0-next.55",
     "@genexus/svg-sass-generator": "1.1.24",
+    "@types/node": "~22.10.5",
     "chokidar": "^3.6.0",
     "chokidar-cli": "^3.0.0",
     "esbuild": "0.24.0",