@genexus/mercury 0.12.8 → 0.13.0

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);
+};
+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,80 @@
+import fs from "node:fs";
+import path from "node:path";
+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, transpileBundle } from "./utils.js";
+import { printBundleWasTranspiled } from "./print-utils.js";
+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,12 @@
+export declare const getFileSize: (fileContent: string) => string;
+export declare const transpileBundle: (filePath: string, globant: boolean) => 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,47 @@
+import crypto from "node:crypto";
+import { styleText } from "node:util";
+import * as sass from "sass";
+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 transpileBundle = (filePath, globant) => sass.compile(filePath, {
+    loadPaths: [globant ? "src/config/globant" : "src/config/default"],
+    style: "compressed"
+}).css;
+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);
@@ -10611,7 +10613,7 @@
   }
 }
 
-%toggle-basic {
+%switch-basic {
   --ch-switch-track__unchecked-background-color: var(
     --mer-color__neutral-gray--650
   );
@@ -10621,7 +10623,8 @@
   --ch-switch-thumb__unchecked-background-color: var(--mer-icon__neutral);
   --ch-switch-thumb__checked-background-color: var(--mer-icon__neutral);
   --ch-switch-thumb__state-transition-duration: 150ms;
-  font-weight: 400; // TODO: USE THE RIGHT TOKEN AND LINE-HEIGHT
+  font-weight: var(--mer-font__weight--regular);
+  line-height: var(--mer-line-height--regular);
 
   &__track {
     border-radius: var(--ch-switch-track-block-size);
@@ -10643,12 +10646,12 @@
 
   &__caption {
     &--checked {
-      font-weight: 600;
+      // Font weight shouldn't change, since it causes a subtle inline-size shift, moving surrounding elements.
     }
   }
 }
 
-%toggle-small {
+%switch-small {
   --ch-switch-track-block-size: 16px;
   --ch-switch-track-inline-size: 31px;
   --ch-switch-thumb-size: 9px;
@@ -10664,7 +10667,7 @@
   }
 }
 
-%toggle-large {
+%switch-large {
   --ch-switch-track-block-size: 26px;
   --ch-switch-track-inline-size: 50px;
   --ch-switch-thumb-size: 16px;
@@ -10680,77 +10683,77 @@
   }
 }
 
-@mixin toggle-small(
-  $toggle-selector: ".toggle-small",
-  $track-selector: ".toggle-small::part(track)",
-  $track--disabled-selector: ".toggle-small::part(track disabled)",
-  $thumb--unchecked-selector: ".toggle-small::part(thumb unchecked)",
-  $thumb--checked-selector: ".toggle-small::part(thumb checked)",
-  $caption--checked-selector: ".toggle-small::part(caption checked)",
+@mixin switch-small(
+  $switch-selector: ".switch-small",
+  $track-selector: ".switch-small::part(track)",
+  $track--disabled-selector: ".switch-small::part(track disabled)",
+  $thumb--unchecked-selector: ".switch-small::part(thumb unchecked)",
+  $thumb--checked-selector: ".switch-small::part(thumb checked)",
+  $caption--checked-selector: ".switch-small::part(caption checked)",
   $add--disabled: true
 ) {
-  #{$toggle-selector} {
-    @extend %toggle-basic;
-    @extend %toggle-small;
+  #{$switch-selector} {
+    @extend %switch-basic;
+    @extend %switch-small;
   }
 
   #{$track-selector} {
-    @extend %toggle-basic__track;
+    @extend %switch-basic__track;
   }
 
   @if $add--disabled {
     #{$track--disabled-selector} {
-      @extend %toggle-basic__track--disabled;
+      @extend %switch-basic__track--disabled;
     }
   }
 
   #{$thumb--unchecked-selector} {
-    @extend %toggle-small__thumb--unchecked;
+    @extend %switch-small__thumb--unchecked;
   }
 
   #{$thumb--checked-selector} {
-    @extend %toggle-small__thumb--checked;
+    @extend %switch-small__thumb--checked;
   }
 
   #{$caption--checked-selector} {
-    @extend %toggle-basic__caption--checked;
+    @extend %switch-basic__caption--checked;
   }
 }
 
-@mixin toggle-large(
-  $toggle-selector: ".toggle-large",
-  $track-selector: ".toggle-large::part(track)",
-  $track--disabled-selector: ".toggle-large::part(track disabled)",
-  $thumb--unchecked-selector: ".toggle-large::part(thumb unchecked)",
-  $thumb--checked-selector: ".toggle-large::part(thumb checked)",
-  $caption--checked-selector: ".toggle-large::part(caption checked)",
+@mixin switch-large(
+  $switch-selector: ".switch-large",
+  $track-selector: ".switch-large::part(track)",
+  $track--disabled-selector: ".switch-large::part(track disabled)",
+  $thumb--unchecked-selector: ".switch-large::part(thumb unchecked)",
+  $thumb--checked-selector: ".switch-large::part(thumb checked)",
+  $caption--checked-selector: ".switch-large::part(caption checked)",
   $add--disabled: true
 ) {
-  #{$toggle-selector} {
-    @extend %toggle-basic;
-    @extend %toggle-large;
+  #{$switch-selector} {
+    @extend %switch-basic;
+    @extend %switch-large;
   }
 
   #{$track-selector} {
-    @extend %toggle-basic__track;
+    @extend %switch-basic__track;
   }
 
   @if $add--disabled {
     #{$track--disabled-selector} {
-      @extend %toggle-basic__track--disabled;
+      @extend %switch-basic__track--disabled;
     }
   }
 
   #{$thumb--unchecked-selector} {
-    @extend %toggle-large__thumb--unchecked;
+    @extend %switch-large__thumb--unchecked;
   }
 
   #{$thumb--checked-selector} {
-    @extend %toggle-large__thumb--checked;
+    @extend %switch-large__thumb--checked;
   }
 
   #{$caption--checked-selector} {
-    @extend %toggle-basic__caption--checked;
+    @extend %switch-basic__caption--checked;
   }
 }
 
@@ -11195,7 +11198,7 @@
   $tab: true,
   $tabular-grid: true,
   $ticket-list: true,
-  $toggle: true,
+  $switch: true,
   $tooltip: true,
   $tree-view: true,
   $widget: true
@@ -22974,9 +22977,9 @@
     @include ticket-list();
   }
 
-  @if $toggle {
-    @include toggle-small();
-    @include toggle-large();
+  @if $switch {
+    @include switch-small();
+    @include switch-large();
   }
 
   @if $tooltip {
@@ -23062,7 +23065,7 @@
   $tab: false,
   $tabular-grid: false,
   $ticket-list: false,
-  $toggle: false,
+  $switch: false,
   $tooltip: false,
   $tree-view: false,
   $widget: false
@@ -23137,7 +23140,7 @@
     $tab: $tab,
     $tabular-grid: $tabular-grid,
     $ticket-list: $ticket-list,
-    $toggle: $toggle,
+    $switch: $switch,
     $tooltip: $tooltip,
     $tree-view: $tree-view,
     $widget: $widget