@betty-blocks/cli 26.0.0-beta.14 → 26.0.0-beta.16

package/build/bb-components-build.js

@@ -1,85 +1,27 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = __importDefault(require("chalk"));
-const commander_1 = require("commander");
-const fs_1 = __importDefault(require("fs"));
-const fs_extra_1 = require("fs-extra");
-const ora_1 = __importDefault(require("ora"));
-const path_1 = __importDefault(require("path"));
-const typescript_1 = __importStar(require("typescript"));
-const compatibility_1 = __importDefault(require("./components/compatibility"));
-const transformers_1 = require("./components/transformers");
-const components_build_1 = require("./components-build");
-const compatibility_2 = __importDefault(require("./interactions/compatibility"));
-const diagnostics_1 = __importDefault(require("./interactions/diagnostics"));
-const arguments_1 = require("./utils/arguments");
-const checkPackageVersion_1 = require("./utils/checkPackageVersion");
-const checkUpdateAvailable_1 = require("./utils/checkUpdateAvailable");
-const hash_1 = __importDefault(require("./utils/hash"));
-const readFilesByType_1 = __importDefault(require("./utils/readFilesByType"));
-const transpile_1 = __importDefault(require("./utils/transpile"));
-const validation_1 = require("./utils/validation");
-const component_1 = __importDefault(require("./validations/component"));
-const interaction_1 = __importDefault(require("./validations/interaction"));
-const prefab_1 = __importDefault(require("./validations/prefab"));
-const styles_1 = __importDefault(require("./validations/styles"));
-const program = new commander_1.Command();
+import chalk from 'chalk';
+import { Command } from 'commander';
+import fs from 'fs';
+import { ensureDir, outputJson, pathExists, readFile, readFileSync, remove, } from 'fs-extra';
+import ora from 'ora';
+import path from 'path';
+import ts, { JsxEmit, ModuleKind, ScriptTarget } from 'typescript';
+import extractComponentCompatibility from './components/compatibility';
+import { doTranspile } from './components/transformers';
+import { buildReferenceStyle, buildStyle, readStyles, reportDiagnostics, } from './components-build';
+import extractInteractionCompatibility from './interactions/compatibility';
+import getDiagnostics from './interactions/diagnostics';
+import { parseDir } from './utils/arguments';
+import { checkPackageVersion } from './utils/checkPackageVersion';
+import { checkUpdateAvailableCLI } from './utils/checkUpdateAvailable';
+import hash from './utils/hash';
+import readFilesByType from './utils/readFilesByType';
+import transpile from './utils/transpile';
+import { checkNameReferences, checkOptionCategoryReferences, } from './utils/validation';
+import validateComponents from './validations/component';
+import validateInteractions from './validations/interaction';
+import validatePrefabs from './validations/prefab';
+import validateStyles from './validations/styles';
+const program = new Command();
 program
     .usage('[path]')
     .name('bb components build')
@@ -89,7 +31,7 @@ program
     .parse(process.argv);
 const { args } = program;
 const options = program.opts();
-const rootDir = (0, arguments_1.parseDir)(args);
+const rootDir = parseDir(args);
 const distDir = `${rootDir}/dist`;
 const enableNewTranspile = !!options.transpile;
 const arg = process.argv.slice(2);
@@ -97,104 +39,107 @@ const startTime = Date.now();
 const buildAll = !arg.includes('--fast');
 const hasOfflineFlag = arg.includes('--offline');
 /* execute command */
-const readComponents = () => __awaiter(void 0, void 0, void 0, function* () {
+const readComponents = async () => {
     const srcDir = `${rootDir}/src/components`;
-    const exists = yield (0, fs_extra_1.pathExists)(srcDir);
+    const exists = await pathExists(srcDir);
     if (!exists) {
-        throw new Error(chalk_1.default.red('\nComponents folder not found\n'));
+        throw new Error(chalk.red('\nComponents folder not found\n'));
     }
-    const componentFiles = yield (0, readFilesByType_1.default)(srcDir, 'js', buildAll);
-    const components = componentFiles.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+    const componentFiles = await readFilesByType(srcDir, 'js', buildAll);
+    const components = componentFiles.map(async (file) => {
         try {
-            const code = yield (0, fs_extra_1.readFile)(`${srcDir}/${file}`, 'utf-8');
-            const compatibility = (0, compatibility_1.default)(code);
-            const transpiledFunction = Function(`return ${(0, transpile_1.default)(code, ['jsx', 'styles'])}`)();
+            const code = await readFile(`${srcDir}/${file}`, 'utf-8');
+            const compatibility = extractComponentCompatibility(code);
+            const transpiledFunction = Function(`return ${transpile(code, ['jsx', 'styles'])}`)();
             if (!transpiledFunction) {
                 throw new Error("Component doesn't return anything");
             }
             if (enableNewTranspile) {
-                transpiledFunction.transpiledJsx = (0, transformers_1.doTranspile)(transpiledFunction.jsx);
-                transpiledFunction.transpiledStyles = (0, transformers_1.doTranspile)(transpiledFunction.styles);
+                transpiledFunction.transpiledJsx = doTranspile(transpiledFunction.jsx);
+                transpiledFunction.transpiledStyles = doTranspile(transpiledFunction.styles);
             }
             if (transpiledFunction.dependencies && !hasOfflineFlag) {
                 const usedPackages = transpiledFunction.dependencies.map((usedDependency) => usedDependency.package);
-                const dependencyPromises = usedPackages.map((usedPackage) => __awaiter(void 0, void 0, void 0, function* () {
-                    yield (0, checkPackageVersion_1.checkPackageVersion)(usedPackage.replace(/^npm:/g, ''));
-                }));
-                yield Promise.all(dependencyPromises);
+                const dependencyPromises = usedPackages.map(async (usedPackage) => {
+                    await checkPackageVersion(usedPackage.replace(/^npm:/g, ''));
+                });
+                await Promise.all(dependencyPromises);
             }
-            return Object.assign(Object.assign({}, compatibility), transpiledFunction);
+            return {
+                ...compatibility,
+                ...transpiledFunction,
+            };
         }
         catch (error) {
             throw new Error(`in ${file}: ${error}`);
         }
-    }));
+    });
     return Promise.all(components);
-});
-const readtsPrefabs = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (isPartial = false) {
-    var _a;
-    const absoluteRootDir = path_1.default.resolve(process.cwd(), rootDir);
+};
+const readtsPrefabs = async (isPartial = false) => {
+    const absoluteRootDir = path.resolve(process.cwd(), rootDir);
     const srcDir = `${absoluteRootDir}/src/prefabs`;
     const outDir = `${absoluteRootDir}/tmp/${Math.floor(Date.now() / 1000)}`;
-    const exists = yield (0, fs_extra_1.pathExists)(srcDir);
+    const exists = await pathExists(srcDir);
     if (!exists) {
-        throw new Error(chalk_1.default.red('\nPrefabs folder not found\n'));
+        throw new Error(chalk.red('\nPrefabs folder not found\n'));
     }
     let prefabTsFiles = [];
     let prefabTsxFiles = [];
     let partialTsxFiles = [];
     if (isPartial) {
-        partialTsxFiles = yield (0, readFilesByType_1.default)(`${srcDir}/partials`, 'tsx', buildAll);
+        partialTsxFiles = await readFilesByType(`${srcDir}/partials`, 'tsx', buildAll);
     }
     else {
-        prefabTsFiles = yield (0, readFilesByType_1.default)(srcDir, 'ts', buildAll);
-        prefabTsxFiles = yield (0, readFilesByType_1.default)(srcDir, 'tsx', buildAll);
+        prefabTsFiles = await readFilesByType(srcDir, 'ts', buildAll);
+        prefabTsxFiles = await readFilesByType(srcDir, 'tsx', buildAll);
     }
     const prefabFiles = [...prefabTsFiles, ...prefabTsxFiles];
     const files = isPartial ? partialTsxFiles : prefabFiles;
     const basePath = isPartial ? `${srcDir}/partials/` : `${srcDir}/`;
-    const prefabProgram = typescript_1.default.createProgram(files.map((file) => `${basePath}/${file}`), {
+    const prefabProgram = ts.createProgram(files.map((file) => `${basePath}/${file}`), {
         allowSyntheticDefaultImports: false,
         esModuleInterop: true,
-        jsx: typescript_1.JsxEmit.React,
+        jsx: JsxEmit.React,
         listEmittedFiles: true,
-        module: typescript_1.ModuleKind.CommonJS,
+        module: ModuleKind.CommonJS,
         outDir,
-        target: typescript_1.ScriptTarget.ESNext,
+        target: ScriptTarget.ESNext,
     });
-    const diagnostics = [...typescript_1.default.getPreEmitDiagnostics(prefabProgram)];
+    const diagnostics = [...ts.getPreEmitDiagnostics(prefabProgram)];
     if (diagnostics.length > 0) {
-        (0, components_build_1.reportDiagnostics)(diagnostics);
+        reportDiagnostics(diagnostics);
         process.exit(1);
     }
     const results = prefabProgram.emit();
     if (results.diagnostics.length > 0) {
-        (0, components_build_1.reportDiagnostics)([...results.diagnostics]);
+        reportDiagnostics([...results.diagnostics]);
         process.exit(1);
     }
     const globalDiagnostics = [...prefabProgram.getGlobalDiagnostics()];
     if (globalDiagnostics.length > 0) {
-        (0, components_build_1.reportDiagnostics)(globalDiagnostics);
+        reportDiagnostics(globalDiagnostics);
         process.exit(1);
     }
     const declarationDiagnostics = [...prefabProgram.getDeclarationDiagnostics()];
     if (declarationDiagnostics.length > 0) {
-        (0, components_build_1.reportDiagnostics)(declarationDiagnostics);
+        reportDiagnostics(declarationDiagnostics);
         process.exit(1);
     }
     const configDiagnostics = [
         ...prefabProgram.getConfigFileParsingDiagnostics(),
     ];
     if (configDiagnostics.length > 0) {
-        (0, components_build_1.reportDiagnostics)(configDiagnostics);
+        reportDiagnostics(configDiagnostics);
         process.exit(1);
     }
-    const prefabs = ((_a = results.emittedFiles) !== null && _a !== void 0 ? _a : [])
+    const prefabs = (results.emittedFiles ?? [])
         .filter((filename) => isPartial
         ? /prefabs\/partials\/\w+\.js$/.test(filename)
         : /prefabs\/\w+\.js$/.test(filename))
         .map((filename) => new Promise((resolve) => {
-        Promise.resolve(`${filename}`).then(s => __importStar(require(s))).then((prefab) => {
+        import(filename)
+            .then((prefab) => {
             // JSON schema validation
             resolve(prefab.default);
         })
@@ -203,18 +148,18 @@ const readtsPrefabs = (...args_1) => __awaiter(void 0, [...args_1], void 0, func
         });
     }));
     return Promise.all(prefabs);
-});
-const readPrefabs = () => __awaiter(void 0, void 0, void 0, function* () {
+};
+const readPrefabs = async () => {
     const srcDir = `${rootDir}/src/prefabs`;
-    const exists = yield (0, fs_extra_1.pathExists)(srcDir);
+    const exists = await pathExists(srcDir);
     if (!exists) {
-        throw new Error(chalk_1.default.red('\nPrefabs folder not found\n'));
+        throw new Error(chalk.red('\nPrefabs folder not found\n'));
     }
-    const prefabFiles = yield (0, readFilesByType_1.default)(srcDir, 'js', buildAll);
-    const prefabs = prefabFiles.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+    const prefabFiles = await readFilesByType(srcDir, 'js', buildAll);
+    const prefabs = prefabFiles.map(async (file) => {
         try {
-            const code = yield (0, fs_extra_1.readFile)(`${srcDir}/${file}`, 'utf-8');
-            const transpiledFunction = Function(`return ${(0, transpile_1.default)(code, ['beforeCreate'])}`)();
+            const code = await readFile(`${srcDir}/${file}`, 'utf-8');
+            const transpiledFunction = Function(`return ${transpile(code, ['beforeCreate'])}`)();
             if (!transpiledFunction) {
                 throw new Error("Prefab doesn't return anything");
             }
@@ -223,20 +168,20 @@ const readPrefabs = () => __awaiter(void 0, void 0, void 0, function* () {
         catch (error) {
             throw new Error(`in ${file}: ${error}`);
         }
-    }));
+    });
     return Promise.all(prefabs);
-});
-const readPartialPrefabs = () => __awaiter(void 0, void 0, void 0, function* () {
+};
+const readPartialPrefabs = async () => {
     const srcDir = `${rootDir}/src/prefabs/partials`;
-    const exists = yield (0, fs_extra_1.pathExists)(srcDir);
+    const exists = await pathExists(srcDir);
     if (!exists) {
-        yield (0, fs_extra_1.ensureDir)(srcDir);
+        await ensureDir(srcDir);
     }
-    const partialPrefabFiles = yield (0, readFilesByType_1.default)(srcDir, 'js', buildAll);
-    const partialPrefabs = partialPrefabFiles.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+    const partialPrefabFiles = await readFilesByType(srcDir, 'js', buildAll);
+    const partialPrefabs = partialPrefabFiles.map(async (file) => {
         try {
-            const code = yield (0, fs_extra_1.readFile)(`${srcDir}/${file}`, 'utf-8');
-            const transpiledFunction = Function(`return ${(0, transpile_1.default)(code, ['beforeCreate'])}`)();
+            const code = await readFile(`${srcDir}/${file}`, 'utf-8');
+            const transpiledFunction = Function(`return ${transpile(code, ['beforeCreate'])}`)();
             if (!transpiledFunction) {
                 throw new Error("Prefab doesn't return anything");
             }
@@ -245,36 +190,38 @@ const readPartialPrefabs = () => __awaiter(void 0, void 0, void 0, function* ()
         catch (error) {
             throw new Error(`in ${file}: ${error}`);
         }
-    }));
+    });
     return Promise.all(partialPrefabs);
-});
-const readInteractions = () => __awaiter(void 0, void 0, void 0, function* () {
+};
+const readInteractions = async () => {
     const srcDir = `${rootDir}/src/interactions`;
-    const exists = yield (0, fs_extra_1.pathExists)(srcDir);
+    const exists = await pathExists(srcDir);
     if (!exists) {
         return new Promise((resolve) => {
             resolve([]);
         });
     }
-    const interactionFiles = yield (0, readFilesByType_1.default)(srcDir, 'ts', buildAll);
-    return Promise.all(interactionFiles.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+    const interactionFiles = await readFilesByType(srcDir, 'ts', buildAll);
+    return Promise.all(interactionFiles.map(async (file) => {
         try {
-            (0, diagnostics_1.default)(`${srcDir}/${file}`);
-            return Object.assign({}, (0, compatibility_2.default)(`${srcDir}/${file}`));
+            getDiagnostics(`${srcDir}/${file}`);
+            return {
+                ...extractInteractionCompatibility(`${srcDir}/${file}`),
+            };
         }
         catch (error) {
             throw new Error(`in ${file}: ${error}`);
         }
-    })));
-});
-void (() => __awaiter(void 0, void 0, void 0, function* () {
+    }));
+};
+void (async () => {
     if (!hasOfflineFlag) {
-        yield (0, checkUpdateAvailable_1.checkUpdateAvailableCLI)();
+        await checkUpdateAvailableCLI();
     }
-    const buildStart = (0, ora_1.default)(`Building component set...`).start();
+    const buildStart = ora(`Building component set...`).start();
     try {
-        const [styles, tsxPrefabs, jsPrefabs, components, interactions, tsxPartialPrefabs, partialprefabs,] = yield Promise.all([
-            (0, components_build_1.readStyles)(rootDir),
+        const [styles, tsxPrefabs, jsPrefabs, components, interactions, tsxPartialPrefabs, partialprefabs,] = await Promise.all([
+            readStyles(rootDir),
             readtsPrefabs(),
             readPrefabs(),
             readComponents(),
@@ -282,10 +229,10 @@ void (() => __awaiter(void 0, void 0, void 0, function* () {
             readPartialPrefabs(),
             readtsPrefabs(true),
         ]);
-        const templatesPath = path_1.default.join(distDir, 'templates.json');
+        const templatesPath = path.join(distDir, 'templates.json');
         let existingComponents = [];
-        if (fs_1.default.existsSync(templatesPath)) {
-            const templatesData = fs_1.default.readFileSync(templatesPath, 'utf8');
+        if (fs.existsSync(templatesPath)) {
+            const templatesData = fs.readFileSync(templatesPath, 'utf8');
             existingComponents = JSON.parse(templatesData);
         }
         else {
@@ -302,11 +249,17 @@ void (() => __awaiter(void 0, void 0, void 0, function* () {
         const stylesGroupedByTypeAndName = styles.reduce((object, e) => {
             const { name, type } = e;
             const byType = object[type] || {};
-            return Object.assign(Object.assign({}, object), { [type]: Object.assign(Object.assign({}, byType), { [name]: e }) });
+            return {
+                ...object,
+                [type]: {
+                    ...byType,
+                    [name]: e,
+                },
+            };
         }, {});
         let finalComponents;
-        if (fs_1.default.existsSync(templatesPath)) {
-            const templatesData = fs_1.default.readFileSync(templatesPath, 'utf8');
+        if (fs.existsSync(templatesPath)) {
+            const templatesData = fs.readFileSync(templatesPath, 'utf8');
             finalComponents = JSON.parse(templatesData);
         }
         else {
@@ -314,7 +267,7 @@ void (() => __awaiter(void 0, void 0, void 0, function* () {
             finalComponents = components;
         }
         const componentNames = finalComponents.map(({ name }) => name);
-        (0, validation_1.checkNameReferences)(prefabs, finalComponents);
+        checkNameReferences(prefabs, finalComponents);
         const { availableNames: availableComponentNames, styleMap: componentStyleMap, } = components.reduce(({ availableNames, styleMap }, component) => {
             const newNames = availableNames.includes(component.name)
                 ? availableNames
@@ -326,71 +279,85 @@ void (() => __awaiter(void 0, void 0, void 0, function* () {
                 : styleMap;
             return { availableNames: newNames, styleMap: newStyleMap };
         }, { availableNames: [], styleMap: {} });
-        yield Promise.all([
-            (0, styles_1.default)(styles, componentNames),
-            (0, component_1.default)(components, validStyleTypes),
-            (0, prefab_1.default)({
+        await Promise.all([
+            validateStyles(styles, componentNames),
+            validateComponents(components, validStyleTypes),
+            validatePrefabs({
                 availableComponentNames,
                 componentStyleMap,
                 prefabs,
                 styles: stylesGroupedByTypeAndName,
             }),
-            (0, prefab_1.default)({
+            validatePrefabs({
                 availableComponentNames,
                 componentStyleMap,
                 prefabType: 'partial',
                 prefabs: allPartialPrefabs,
                 styles: stylesGroupedByTypeAndName,
             }),
-            interactions && (0, interaction_1.default)(interactions),
+            interactions && validateInteractions(interactions),
         ]);
-        (0, validation_1.checkOptionCategoryReferences)(prefabs);
-        const componentsWithHash = components.map((component) => (Object.assign(Object.assign({}, component), { componentHash: (0, hash_1.default)(component) })));
+        checkOptionCategoryReferences(prefabs);
+        const componentsWithHash = components.map((component) => ({
+            ...component,
+            componentHash: hash(component),
+        }));
         const buildPrefab = (prefab) => {
             const buildStructure = (structure) => {
                 if (structure.type === 'PARTIAL') {
                     return structure;
                 }
                 if (structure.type === 'WRAPPER') {
-                    const { descendants = [] } = structure, rest = __rest(structure, ["descendants"]);
-                    const wrapperStructure = Object.assign(Object.assign({}, rest), { descendants: descendants.map(buildStructure) });
+                    const { descendants = [], ...rest } = structure;
+                    const wrapperStructure = {
+                        ...rest,
+                        descendants: descendants.map(buildStructure),
+                    };
                     return wrapperStructure;
                 }
-                const { style, descendants } = structure, rest = __rest(structure, ["style", "descendants"]);
-                const styleReference = (0, components_build_1.buildReferenceStyle)(style);
-                const newStructure = Object.assign(Object.assign(Object.assign({}, rest), (styleReference ? { style: styleReference } : {})), { descendants: descendants.map(buildStructure), hash: (0, hash_1.default)(structure.options) });
+                const { style, descendants, ...rest } = structure;
+                const styleReference = buildReferenceStyle(style);
+                const newStructure = {
+                    ...rest,
+                    ...(styleReference ? { style: styleReference } : {}),
+                    descendants: descendants.map(buildStructure),
+                    hash: hash(structure.options),
+                };
                 return newStructure;
             };
-            return Object.assign(Object.assign({}, prefab), { structure: prefab.structure.map(buildStructure) });
+            return {
+                ...prefab,
+                structure: prefab.structure.map(buildStructure),
+            };
         };
-        const buildStyles = styles.map(components_build_1.buildStyle);
+        const buildStyles = styles.map(buildStyle);
         const buildPrefabs = prefabs.map(buildPrefab);
         const buildPartialprefabs = allPartialPrefabs.map(buildPrefab);
-        yield (0, fs_extra_1.ensureDir)(distDir);
+        await ensureDir(distDir);
         const defaultPrefabs = buildPrefabs.filter((prefab) => prefab.type !== 'page');
         const pagePrefabs = prefabs.filter((prefab) => prefab.type === 'page');
-        const existingPath = yield (0, fs_extra_1.pathExists)(`${distDir}/pagePrefabs.json`);
-        const existingPartialPath = yield (0, fs_extra_1.pathExists)(`${distDir}/partials.json`);
+        const existingPath = await pathExists(`${distDir}/pagePrefabs.json`);
+        const existingPartialPath = await pathExists(`${distDir}/partials.json`);
         if (buildAll) {
             const outputPromises = [
-                (0, fs_extra_1.outputJson)(`${distDir}/prefabs.json`, defaultPrefabs),
-                (0, fs_extra_1.outputJson)(`${distDir}/templates.json`, componentsWithHash),
+                outputJson(`${distDir}/prefabs.json`, defaultPrefabs),
+                outputJson(`${distDir}/templates.json`, componentsWithHash),
                 interactions &&
-                    (0, fs_extra_1.outputJson)(`${distDir}/interactions.json`, interactions),
+                    outputJson(`${distDir}/interactions.json`, interactions),
             ];
             if (buildStyles.length > 0) {
-                outputPromises.push((0, fs_extra_1.outputJson)(`${distDir}/styles.json`, buildStyles));
+                outputPromises.push(outputJson(`${distDir}/styles.json`, buildStyles));
             }
             if (pagePrefabs.length > 0) {
-                outputPromises.push((0, fs_extra_1.outputJson)(`${distDir}/pagePrefabs.json`, pagePrefabs));
+                outputPromises.push(outputJson(`${distDir}/pagePrefabs.json`, pagePrefabs));
             }
             if (buildPartialprefabs.length > 0) {
-                outputPromises.push((0, fs_extra_1.outputJson)(`${distDir}/partials.json`, buildPartialprefabs));
+                outputPromises.push(outputJson(`${distDir}/partials.json`, buildPartialprefabs));
             }
-            yield Promise.all(outputPromises);
+            await Promise.all(outputPromises);
         }
         else {
-            const existingPrefabs = JSON.parse((0, fs_extra_1.readFileSync)(`${distDir}/prefabs.json`, 'utf8'));
+            const existingPrefabs = JSON.parse(readFileSync(`${distDir}/prefabs.json`, 'utf8'));
             const replaceInSet = (existingElements, newElements) => existingElements.map((existingElement) => {
                 if (newElements.length > 0 &&
                     existingElement.name === newElements[0].name) {
@@ -400,34 +367,34 @@ void (() => __awaiter(void 0, void 0, void 0, function* () {
             });
             const updatedPrefabs = replaceInSet(existingPrefabs, prefabs);
             const updatedComponents = replaceInSet(existingComponents, componentsWithHash);
-            const existingInteractions = JSON.parse((0, fs_extra_1.readFileSync)(`${distDir}/interactions.json`, 'utf8'));
+            const existingInteractions = JSON.parse(readFileSync(`${distDir}/interactions.json`, 'utf8'));
             const updatedInteractions = replaceInSet(existingInteractions, interactions);
             const newOutputPromises = [
-                (0, fs_extra_1.outputJson)(`${distDir}/prefabs.json`, updatedPrefabs),
-                (0, fs_extra_1.outputJson)(`${distDir}/templates.json`, updatedComponents),
+                outputJson(`${distDir}/prefabs.json`, updatedPrefabs),
+                outputJson(`${distDir}/templates.json`, updatedComponents),
                 interactions &&
-                    (0, fs_extra_1.outputJson)(`${distDir}/interactions.json`, updatedInteractions),
+                    outputJson(`${distDir}/interactions.json`, updatedInteractions),
             ];
-            const existingPagePrefabs = JSON.parse((0, fs_extra_1.readFileSync)(`${distDir}/pagePrefabs.json`, 'utf8'));
+            const existingPagePrefabs = JSON.parse(readFileSync(`${distDir}/pagePrefabs.json`, 'utf8'));
             const updatedPagePrefabs = replaceInSet(existingPagePrefabs, pagePrefabs);
             if (existingPath && pagePrefabs.length > 0) {
-                newOutputPromises.push((0, fs_extra_1.outputJson)(`${distDir}/pagePrefabs.json`, updatedPagePrefabs));
+                newOutputPromises.push(outputJson(`${distDir}/pagePrefabs.json`, updatedPagePrefabs));
             }
-            const existingPartials = JSON.parse((0, fs_extra_1.readFileSync)(`${distDir}/partials.json`, 'utf8'));
+            const existingPartials = JSON.parse(readFileSync(`${distDir}/partials.json`, 'utf8'));
             const updatedPartials = replaceInSet(existingPartials, buildPartialprefabs);
             if (existingPartialPath && buildPartialprefabs.length > 0) {
-                newOutputPromises.push((0, fs_extra_1.outputJson)(`${distDir}/partials.json`, updatedPartials));
+                newOutputPromises.push(outputJson(`${distDir}/partials.json`, updatedPartials));
             }
-            yield Promise.all(newOutputPromises);
+            await Promise.all(newOutputPromises);
         }
         if (buildPartialprefabs.length === 0 && existingPartialPath && buildAll) {
-            yield (0, fs_extra_1.remove)(`${distDir}/partials.json`);
+            await remove(`${distDir}/partials.json`);
         }
         if (pagePrefabs.length === 0 && existingPath && buildAll) {
-            yield (0, fs_extra_1.remove)(`${distDir}/pagePrefabs.json`);
+            await remove(`${distDir}/pagePrefabs.json`);
         }
         buildStart.succeed();
-        console.info(chalk_1.default.green('Success, the component set has been built'));
+        console.info(chalk.green('Success, the component set has been built'));
     }
     catch (error) {
         // Handle both Error objects and custom error objects
@@ -445,5 +412,5 @@ void (() => __awaiter(void 0, void 0, void 0, function* () {
         throw new Error(`An unknown error occurred: ${error}`);
     }
     console.info(`Total time: ${(Date.now() - startTime) / 1000} seconds`);
-}))();
+})();
 //# sourceMappingURL=bb-components-build.js.map