npm - @simple-reporting/base - Versions diffs - 0.1.111 → 1.0.0 - Mend

@simple-reporting/base 0.1.111 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (773) hide show

package/scripts/build.js CHANGED Viewed

@@ -1,812 +1,837 @@
-import { resolve } from 'node:path';
-import {
-  statSync,
-  writeFileSync,
-  readFileSync,
-  mkdirSync,
-  readdirSync,
-  createWriteStream,
-  rmSync,
-  cpSync,
-} from 'node:fs';
-import { fileURLToPath, URL } from 'node:url';
-import { createRequire } from 'node:module';
-import { glob } from 'glob';
-import { beaver } from './beaver.js';
-import { build as viteBuild } from 'vite';
-import { build as finalizeLdd } from './migrate-livingdocs-build/bin/build.js';
-import {
-  readPackageJson,
-  writePackageJson,
-  readLivingDocsJson,
-  writeLivingDocsJson,
-} from './utils.js';
-import { camelCase } from 'cheerio/utils';
-const placeholderId = '6297EAFB-33A0-48B8-8D64-E61CDC3E9035';
-const CWD = process.cwd();
-const nswowPath = resolve(CWD, '.nswow');
-const outputPath = resolve(CWD, '.output');
-const require = createRequire(import.meta.url);
-const { Input } = require('enquirer');
-let foldersChecked = false;
-/**
- * Checks if the required folders exist and creates them if necessary.
- *
- * @async
- * @returns {Promise<boolean>} A promise that resolves to true once the folders are checked and created.
- */
-async function checkFolders() {
-  if (!foldersChecked) {
-    foldersChecked = true;
-    try {
-      await statSync(nswowPath);
-    } catch (e) {
-      await mkdirSync(nswowPath);
-    }
-    try {
-      await statSync(outputPath);
-    } catch (e) {
-      await mkdirSync(outputPath);
-    }
-  }
-  return true;
-}
-/**
- * Cleans the output directory by removing all files and folders.
- *
- * @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether the cleanup was successful.
- */
-async function cleanOutput() {
-  await checkFolders();
-  const output = readdirSync(outputPath);
-  for (let i = 0; i < output.length; i++) {
-    await rmSync(`${outputPath}/${output[i]}`, {
-      force: true,
-      recursive: true,
-    });
-  }
-  return true;
-}
-/**
- * Builds the application by performing the following steps:
- *
- * 1. Checks the folders.
- * 2. Executes the viteBuild function.
- *
- * @returns {Promise<void>} A Promise that resolves when the application is built.
- */
-async function buildApp() {
-  await checkFolders();
-  const build = await viteBuild({
-    build: {
-      copyPublicDir: false,
-    },
-  });
-  // Copy public folder exclude nswow folders
-  console.log(
-    '\n\nCopy public folder exclude nswow folders and exclude folder',
-  );
-  await cpSync(`${CWD}/public/`, `${outputPath}/app`, {
-    filter: (src) => {
-      if (
-        src.startsWith(`${CWD}/public/downloads`) ||
-        src.startsWith(`${CWD}/public/html`) ||
-        src.startsWith(`${CWD}/public/images`) ||
-        src.startsWith(`${CWD}/public/json`) ||
-        src.startsWith(`${CWD}/public/exclude`)
-      ) {
-        return false;
-      } else {
-        src === `${CWD}/public/` ||
-          console.log(`Copy ${src} to ${outputPath}/app`);
-        return true;
-      }
-    },
-    recursive: true,
-  });
-  console.log('\n');
-  let index = await readFileSync(`${outputPath}/app/index.html`, 'utf8');
-  console.log('Create file /template/article.html for nswow hybrid\n');
-  index = index.replace(
-    '<html>',
-    `<html lang="[[language-${placeholderId}]]">`,
-  );
-  index = index.replace(
-    /<base\s+href\s*=\s*(['"])(.*?)\1\s*\/?>/gi,
-    `<base href="[[base-${placeholderId}]]" />
-    [[meta-${placeholderId}]]`,
-  );
-  index = index.replace(
-    /(<div\s+[^>]*id\s*=\s*["']app["'][^>]*>)([\s\S]*?)(<\/div>)/i,
-    `$1
-      <template>
-        [[content-${placeholderId}]]
-      </template>
-    $3`,
-  );
-  await mkdirSync(`${outputPath}/app/template`, { recursive: true });
-  await writeFileSync(`${outputPath}/app/index.html`, index);
-  await writeFileSync(`${outputPath}/app/template/article.html`, index);
-  /**
-   await writeFileSync(`${outputPath}/app/web.config`, `<?xml version="1.0" encoding="UTF-8"?>
-   <configuration>
-   <system.webServer>
-   <rewrite>
-   <rules>
-   <rule name="Rewrite to index.html" stopProcessing="true">
-   <match url=".*" />
-   <conditions logicalGrouping="MatchAll">
-   <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
-   <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
-   </conditions>
-   <action type="Rewrite" url="index.html" />
-   </rule>
-   </rules>
-   </rewrite>
-   </system.webServer>
-   </configuration>`);
-   await writeFileSync(`${outputPath}/app/.htaccess`, `RewriteEngine On
-   RewriteCond %{REQUEST_FILENAME} !-f
-   RewriteCond %{REQUEST_FILENAME} !-l
-   RewriteCond %{REQUEST_FILENAME} !-d
-   RewriteRule ^(.*)$ index.html [L]`);
-   /**/
-  return build;
-}
-/**
- * Builds the application by performing the following steps:
- *
- * 1. Checks the folders.
- * 2. Executes the viteBuild function.
- *
- * @returns {Promise<void>} A Promise that resolves when the application is built.
- */
-async function buildDDev() {
-  await checkFolders();
-  const build = await viteBuild({
-    build: {
-      outDir: './.output/ddev',
-    },
-  });
-  return build;
-}
-/**
- * Compresses the 'app' folder into a zip file using archiver library.
- *
- * @async
- * @function zipApp
- * @returns {Promise<void>} - A Promise that resolves when the zip operation is complete, or rejects with an error.
- */
-async function zipApp() {
-  await checkFolders();
-  const archiver = require('archiver');
-  const output = createWriteStream(outputPath + '/app.zip');
-  const archive = archiver('zip', {
-    zlib: { level: 9 }, // Sets the compression level.
-  });
-  output.on('close', function () {
-    console.log('Create zip ' + outputPath + '/app.zip');
-    console.log(archive.pointer() + ' total bytes');
-  });
-  output.on('end', function () {
-    console.log('Data has been drained');
-  });
-  archive.on('warning', function (err) {
-    if (err.code === 'ENOENT') {
-      console.error(err);
-    } else {
-      // throw error
-      throw err;
-    }
-  });
-  archive.on('error', function (err) {
-    throw err;
-  });
-  archive.pipe(output);
-  archive.directory(outputPath + '/app/', false);
-  archive.finalize();
-}
-/**
- * Builds a PDF using the provided HTML template.
- *
- * @returns {Promise<boolean>} - Returns a Promise that resolves to true if the PDF was successfully built,
- *                              false otherwise.
- */
-async function buildPdf() {
-  await checkFolders();
-  try {
-    const input = resolve(CWD, 'pdf.html');
-    await statSync(input);
-    return await viteBuild({
-      build: {
-        outDir: resolve(CWD, '.output/pdf'),
-        rollupOptions: {
-          input: {
-            pdf: input,
-          },
-          output: {
-            entryFileNames: `[name].js`,
-            chunkFileNames: `[name].js`,
-            assetFileNames: `[name].[ext]`,
-          },
-        },
-        copyPublicDir: false,
-      },
-    });
-  } catch (e) {
-    let configFile = false;
-    try {
-      const file = resolve(CWD, 'vite.config.pdf.ts');
-      await statSync(file);
-      console.log('Use vite.config.pdf.ts file');
-      configFile = file;
-    } catch (e) {
-      console.log('No use of vite.config.pdf.ts file');
-    }
-    const entry = resolve(CWD, 'pdf.ts');
-    const config = {
-      configFile: configFile,
-      base: './',
-      build: {
-        outDir: resolve(CWD, '.output/pdf'),
-        lib: {
-          fileName: 'pdf',
-          entry: entry,
-          formats: ['es'],
-        },
-      },
-      resolve: {
-        alias: {
-          '@': fileURLToPath(new URL(resolve(CWD, 'src'), import.meta.url)),
-          nswow: fileURLToPath(new URL(resolve(CWD, 'nswow'), import.meta.url)),
-        },
-      },
-      publicDir: false,
-    };
-    try {
-      return await viteBuild(config);
-    } catch (e) {
-      console.error(e);
-      return false;
-    }
-  }
-}
-/**
- * Builds Living Documentation (LDD) for a project.
- *
- * @async
- * @param {string} version - The version number to update in the project's package.json file. (optional)
- * @returns {Promise<boolean>} - A Promise that resolves to true if the LDD build is successful, false otherwise.
- */
-async function buildLdd(version) {
-  let action = false;
-  await checkFolders();
-  const packageJson = await readPackageJson();
-  const lddJson = await readLivingDocsJson();
-  if (version) {
-    packageJson.version = version;
-    await writePackageJson(packageJson);
-    action = true;
-  }
-  lddJson.name = packageJson.name;
-  lddJson.version = packageJson.version;
-  const input = resolve(CWD, 'ldd.html');
-  try {
-    await statSync(input);
-  } catch (e) {
-    return true;
-  }
-  try {
-    await writeFileSync(`${outputPath}/v${lddJson.version}.txt`, '');
-    return await viteBuild({
-      build: {
-        outDir: './.output/ldd',
-        rollupOptions: {
-          input: {
-            ldd: input,
-          },
-          output: {
-            entryFileNames: `assets/[name].js`,
-            chunkFileNames: `assets/[name].js`,
-            assetFileNames: `assets/[name].[ext]`,
-          },
-        },
-        copyPublicDir: false,
-      },
-    })
-      .then(async () => {
-        const assetsPath = outputPath + '/ldd/assets';
-        const assetsFiles = await readdirSync(assetsPath);
-        for (let i = 0; i < assetsFiles.length; i++) {
-          const file = assetsFiles[i];
-          if (file.endsWith('.css')) {
-            const path = './assets/' + file;
-            if (!lddJson.assets.css.includes(path)) {
-              action = true;
-              lddJson.assets.css.push(path);
-            }
-          }
-          if (file.endsWith('.js')) {
-            const path = './assets/' + file;
-            if (!lddJson.assets.js.includes(path)) {
-              action = true;
-              lddJson.assets.js.push(path);
-            }
-          }
-        }
-        if (action) {
-          await writeLivingDocsJson(lddJson);
-        }
-        return true;
-      })
-      .then(async () => {
-        return await finalizeLdd();
-      });
-  } catch (e) {
-    console.error(e);
-    return false;
-  }
-}
-/**
- * Builds the word document by compiling the HTML file using Vite and
- * returns the result.
- *
- * @returns {Promise<boolean>} - A promise that resolves to true if the word document is successfully built,
- *                              or false if there was an error during the build process.
- */
-async function buildWord() {
-  await checkFolders();
-  try {
-    const input = resolve(CWD, 'word.html');
-    await statSync(input);
-    return await viteBuild({
-      build: {
-        outDir: resolve(CWD, '.output/word'),
-        rollupOptions: {
-          input: {
-            word: input,
-          },
-          output: {
-            entryFileNames: `[name].js`,
-            chunkFileNames: `[name].js`,
-            assetFileNames: `[name].[ext]`,
-          },
-        },
-        copyPublicDir: false,
-      },
-    });
-  } catch (e) {
-    let configFile = false;
-    try {
-      const file = resolve(CWD, 'vite.config.word.ts');
-      await statSync(file);
-      console.log('Use vite.config.word.ts file');
-      configFile = file;
-    } catch (e) {
-      console.log('No use of vite.config.word.ts file');
-    }
-    const entry = resolve(CWD, 'word.ts');
-    const config = {
-      configFile: configFile,
-      base: './',
-      build: {
-        outDir: resolve(CWD, '.output/word'),
-        lib: {
-          fileName: 'word',
-          entry: entry,
-          formats: ['es'],
-        },
-      },
-      resolve: {
-        alias: {
-          '@': fileURLToPath(new URL(resolve(CWD, 'src'), import.meta.url)),
-          nswow: fileURLToPath(new URL(resolve(CWD, 'nswow'), import.meta.url)),
-        },
-      },
-      publicDir: false,
-    };
-    try {
-      return await viteBuild(config);
-    } catch (e) {
-      console.error(e);
-      return false;
-    }
-  }
-}
-/**
- * Builds the project sequentially by executing a series of asynchronous tasks in a specific order.
- * This method is used to build the project in a predetermined sequence.
- *
- * @return {Promise<void>} A Promise that resolves when the build process is completed or rejects if an error occurs.
- */
-async function build() {
-  try {
-    await checkFolders();
-    const packageJson = await readPackageJson();
-    const prompt = new Input({
-      message: 'Livingdocs version',
-      initial: packageJson.version,
-    });
-    const version = await prompt.run();
-    await cleanOutput();
-    await beaver(1);
-    await mapScss();
-    await mapLdd();
-    await buildApp();
-    await buildPdf();
-    await buildWord();
-    await buildLdd(version);
-    await zipApp();
-  } catch (error) {
-    console.log(error);
-  }
-}
-/**
- * Builds the project sequentially by executing a series of asynchronous tasks in a specific order.
- * This method is used to build the project in a predetermined sequence.
- *
- * @return {Promise<void>} A Promise that resolves when the build process is completed or rejects if an error occurs.
- */
-async function ddev() {
-  try {
-    await checkFolders();
-    const packageJson = await readPackageJson();
-    await beaver(1);
-    await mapScss();
-    await mapLdd();
-    await buildDDev();
-  } catch (error) {
-    console.error(error);
-  }
-}
-/**
- * Cleans up the SCSS alias by removing any characters that are not alphanumeric.
- * @param string
- */
-function cleanupScssAlias(string) {
-  return string.replace(/[^a-zA-Z0-9]/g, '');
-}
-/**
- * Maps SCSS files and generates import statements for different output files.
- *
- * @returns {Promise<boolean>} Returns a promise that resolves to true if the SCSS mapping is successful, and false if there's an error.
- */
-async function mapScss() {
-  await checkFolders();
-  try {
-    const relativePathToRoot = '../';
-    const output = {
-      app: [],
-      ldd: [],
-      pdf: [],
-      word: [],
-    };
-    const mainFiles = await glob(
-      resolve(process.cwd(), './src/assets/scss/*.scss'),
-      {
-        withFileTypes: true,
-      },
-    );
-    let f = mainFiles.find((p) => {
-      return p.name === 'general.scss';
-    });
-    const alias = cleanupScssAlias(f.relative());
-    if (f) {
-      output.app.push(`"${relativePathToRoot}${f.relative()}" as ${alias}`);
-      output.ldd.push(`"${relativePathToRoot}${f.relative()}" as ${alias}`);
-      output.pdf.push(`"${relativePathToRoot}${f.relative()}" as ${alias}`);
-      output.word.push(`"${relativePathToRoot}${f.relative()}" as ${alias}`);
-    }
-    for (let x = 0; x < mainFiles.length; x++) {
-      const alias = cleanupScssAlias(mainFiles[x].relative());
-      if (mainFiles[x].name === 'app.scss') {
-        output.app.push(
-          `"${relativePathToRoot}${mainFiles[x].relative()}" as ${alias}`,
-        );
-      }
-      if (mainFiles[x].name === 'ldd.scss') {
-        output.ldd.push(
-          `"${relativePathToRoot}${mainFiles[x].relative()}" as ${alias}`,
-        );
-      }
-      if (mainFiles[x].name === 'pdf.scss') {
-        output.pdf.push(
-          `"${relativePathToRoot}${mainFiles[x].relative()}" as ${alias}`,
-        );
-      }
-      if (mainFiles[x].name === 'word.scss') {
-        output.word.push(
-          `"${relativePathToRoot}${mainFiles[x].relative()}" as ${alias}`,
-        );
-      }
-    }
-    const livingdocs = await glob(resolve(process.cwd(), './livingdocs/**/*'), {
-      maxDepth: 3,
-      withFileTypes: true,
-    });
-    livingdocs.sort((a, b) => {
-      const valueA = a.relative().toUpperCase();
-      const valueB = b.relative().toUpperCase();
-      if (valueA < valueB) {
-        return -1;
-      }
-      if (valueA > valueB) {
-        return 1;
-      }
-      return 0;
-    });
-    const components = livingdocs.filter((p) => {
-      return p.name !== 'Properties' && p.parent.name !== 'Properties';
-    });
-    const properties = livingdocs.filter((p) => {
-      return p.name === 'Properties' || p.parent.name === 'Properties';
-    });
-    const livingdocsList = [...components, ...properties];
-    for (let x = 0; x < livingdocsList.length; x++) {
-      const p = livingdocsList[x];
-      try {
-        const general = await statSync(p.fullpath() + '/general.scss');
-        const alias = cleanupScssAlias(`${p.relative()}/general.scss`);
-        output.app.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
-        );
-        output.ldd.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
-        );
-        output.pdf.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
-        );
-        output.word.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
-        );
-      } catch (e) {}
-      const types = ['app', 'ldd', 'pdf', 'word'];
-      for (let i = 0; i < types.length; i++) {
-        const type = types[i];
-        try {
-          const f = await statSync(p.fullpath() + '/' + type + '.scss');
-          const alias = cleanupScssAlias(`${p.relative()}/${type}.scss`);
-          output[type].push(
-            `"${relativePathToRoot}${p.relative()}/${type}.scss" as ${alias}`,
-          );
-        } catch (e) {}
-      }
-    }
-    await writeFileSync(
-      `${CWD}/.nswow/app.scss`,
-      `@use ` +
-        output.app.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
-    );
-    await writeFileSync(
-      `${CWD}/.nswow/ldd.scss`,
-      `@use ` +
-        output.ldd.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
-    );
-    await writeFileSync(
-      `${CWD}/.nswow/pdf.scss`,
-      `@use ` +
-        output.pdf.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
-    );
-    await writeFileSync(
-      `${CWD}/.nswow/word.scss`,
-      `@use ` +
-        output.word.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
-    );
-    return true;
-  } catch (e) {
-    console.log(e);
-    return false;
-  }
-}
-/**
- * This function asynchronously maps JavaScript files and imports them into specific files.
- * @returns {Promise<boolean>} - A promise that resolves to true if the mapping and importing is successful.
- */
-async function mapJs() {
-  const jsFiles = await glob(resolve(CWD, './livingdocs/' + '**/app.[t,j]s'), {
-    withFileTypes: true,
-  });
-  const imports = [];
-  const register = [];
-  for (let i = 0; i < jsFiles.length; i++) {
-    const file = jsFiles[i];
-    const className = camelCase(file.parent.name);
-    const path = [file.name];
-    let parent = file.parent;
-    while (parent) {
-      path.unshift(parent.name);
-      if (parent.name !== 'livingdocs') {
-        parent = parent.parent;
-      } else {
-        parent = false;
-      }
-    }
-    imports.push(`import ${className} from "../${path.join(file.sep)}"`);
-    register.push(`ClassAutoLoader.register(${className}, "${className}")`);
-  }
-  const content = `import ArticleAutoloader from 'nswow/ArticleAutoloader'
-${imports.join('\n')}
-const ClassAutoLoader = new ArticleAutoloader()
-${register.join('\n')}
-export default ClassAutoLoader
-export { ClassAutoLoader }`;
-  await writeFileSync(resolve(CWD, './src/Autoload.ts'), content);
-  return true;
-}
-/**
- * Maps the livingdocs properties to components and groups.
- *
- * @returns {Promise<boolean>} Returns a promise that resolves to a boolean indicating the success or failure of the mapping.
- */
-async function mapLdd() {
-  await checkFolders();
-  try {
-    const lddJson = await readLivingDocsJson();
-    const propertiesFiles = await glob(
-      resolve(CWD, './livingdocs/**/properties.{json,js,ts}'),
-    );
-    const mapProperties = {};
-    for (let i = 0; i < propertiesFiles.length; i++) {
-      const file = propertiesFiles[i];
-      if (file.endsWith('.js') || file.endsWith('.ts')) {
-        const properties = require(propertiesFiles[i]).default;
-        const oKeys = Object.keys(properties);
-        for (let j = 0; j < oKeys.length; j++) {
-          mapProperties[oKeys[j]] = properties[oKeys[j]];
-        }
-      } else if (file.endsWith('.json')) {
-        const properties = JSON.parse(readFileSync(propertiesFiles[i]));
-        const oKeys = Object.keys(properties);
-        for (let j = 0; j < oKeys.length; j++) {
-          mapProperties[oKeys[j]] = properties[oKeys[j]];
-        }
-      }
-    }
-    lddJson.componentProperties = mapProperties;
-    const groupsPath = resolve(CWD, './livingdocs');
-    const groups = readdirSync(groupsPath);
-    const keepGroups = [];
-    for (let x = 0; x < groups.length; x++) {
-      const group = groups[x];
-      const groupName = group.replace('_and_', ' / ').replace('_', ' ');
-      try {
-        const stat = statSync(`${groupsPath}/${group}`);
-        if (stat.isDirectory()) {
-          const components = [];
-          const c = readdirSync(`${groupsPath}/${group}`);
-          for (let j = 0; j < c.length; j++) {
-            const component = c[j];
-            try {
-              const stat = statSync(
-                `${groupsPath}/${group}/${component}/${component}.html`,
-              );
-              components.push(component);
-            } catch (e) {}
-          }
-          if (components.length) {
-            keepGroups.push(groupName);
-            const i = lddJson.groups.find((g) => {
-              return g.label === groupName;
-            });
-            if (i) {
-              const newComponents = [];
-              for (let j = 0; j < i.components.length; j++) {
-                const index = components.indexOf(i.components[j]);
-                if (index !== -1) {
-                  newComponents.push(components[index]);
-                  components.splice(index, 1);
-                }
-              }
-              for (let j = 0; j < components.length; j++) {
-                newComponents.push(components[j]);
-              }
-              i.components = newComponents;
-            } else {
-              lddJson.groups.push({
-                label: groupName,
-                components: components,
-              });
-            }
-          }
-        } else {
-          rmSync(`${groupsPath}/${group}`);
-        }
-      } catch (e) {
-        console.log(e);
-        return false;
-      }
-    }
-    const newMap = [];
-    for (let i = 0; i < lddJson.groups.length; i++) {
-      const c = lddJson.groups[i];
-      if (keepGroups.includes(c.label)) {
-        newMap.push(c);
-      }
-    }
-    lddJson.groups = newMap;
-    await writeLivingDocsJson(lddJson);
-    return true;
-  } catch (e) {
-    console.error(e);
-    return false;
-  }
-}
-/**
- * Maps the SCSS files and the LDD files in the project.
- *
- * @async
- * @function map
- * @returns {Promise<boolean>} A promise that resolves after successfully mapping the files.
- * @throws {Error} If there is an error during the mapping process.
- */
-async function map() {
-  await checkFolders();
-  await mapScss();
-  await mapLdd();
-  return true;
-}
-export { build, ddev, map, mapScss, mapLdd, mapJs };
+import { join } from 'node:path/posix';
+import {
+  statSync,
+  writeFileSync,
+  readFileSync,
+  mkdirSync,
+  readdirSync,
+  createWriteStream,
+  rmSync,
+  cpSync,
+  copyFileSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { glob } from 'glob';
+import { build as viteBuild } from 'vite';
+import {
+  readPackageJson,
+  writePackageJson,
+  readLivingDocsJson,
+  writeLivingDocsJson,
+} from './utils.js';
+import { nsWowInternalLddUrl } from './config.js';
+import folders from './folders.js';
+import { mapLdd } from './ldd/mapLdd.js';
+import { LivingdocsDesignValidator } from './ldd/LivingdocsDesignValidator.js';
+import { camelCase } from './utils.js';
+const placeholderId = '6297EAFB-33A0-48B8-8D64-E61CDC3E9035';
+const nswowPath = folders.srlImports;
+const outputPath = folders.srlOutput;
+const require = createRequire(import.meta.url);
+const { Input } = require('enquirer');
+let foldersChecked = false;
+/**
+ * Checks if the required folders exist and creates them if necessary.
+ *
+ * @async
+ * @returns {Promise<boolean>} A promise that resolves to true once the folders are checked and created.
+ */
+async function checkFolders() {
+  if (!foldersChecked) {
+    foldersChecked = true;
+    try {
+      await statSync(nswowPath);
+    } catch (e) {
+      await mkdirSync(nswowPath);
+    }
+    try {
+      await statSync(outputPath);
+    } catch (e) {
+      await mkdirSync(outputPath);
+    }
+  }
+  return true;
+}
+/**
+ * Cleans the output directory by removing all files and folders.
+ *
+ * @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether the cleanup was successful.
+ */
+async function cleanOutput() {
+  await checkFolders();
+  const output = readdirSync(outputPath);
+  for (let i = 0; i < output.length; i++) {
+    await rmSync(join(outputPath, output[i]), {
+      force: true,
+      recursive: true,
+    });
+  }
+  return true;
+}
+/**
+ * Builds the application by performing the following steps:
+ *
+ * 1. Checks the folders.
+ * 2. Executes the viteBuild function.
+ *
+ * @returns {Promise<void>} A Promise that resolves when the application is built.
+ */
+async function buildApp() {
+  console.log("\n\nBuild application");
+  await checkFolders();
+  const build = await viteBuild({
+    build: {
+      copyPublicDir: false,
+    },
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
+        },
+      },
+    },
+    publicDir: false,
+  });
+  // Copy public folder exclude nswow folders
+  console.log(
+    '\n\nCopy public folder exclude nswow folders and exclude folder',
+  );
+  await cpSync(join(folders.srlPublic, '/'), join(outputPath, 'app'), {
+    filter: (src) => {
+      if (
+        src.startsWith(join(folders.srlPublic, 'downloads')) ||
+        src.startsWith(join(folders.srlPublic, 'html')) ||
+        src.startsWith(join(folders.srlPublic, 'images')) ||
+        src.startsWith(join(folders.srlPublic, 'json')) ||
+        src.startsWith(join(folders.srlPublic, 'exclude'))
+      ) {
+        return false;
+      } else {
+        src === join(folders.srlPublic, '/') ||
+          console.log(`Copy ${src} to ${outputPath}/app`);
+        return true;
+      }
+    },
+    recursive: true,
+  });
+  console.log('\n');
+  let index = await readFileSync(
+    join(folders.srlOutput, 'app', 'index.html'),
+    'utf8',
+  );
+  console.log('Create file /template/article.html for nswow hybrid\n');
+  index = index.replace(
+    '<html>',
+    `<html lang="[[language-${placeholderId}]]">`,
+  );
+  index = index.replace(
+    /<base\s+href\s*=\s*(['"])(.*?)\1\s*\/?>/gi,
+    `<base href="[[base-${placeholderId}]]" />
+    [[meta-${placeholderId}]]`,
+  );
+  await writeFileSync(join(outputPath, 'app', 'index.html'), index);
+  index = index.replace(
+    /(<div\s+[^>]*id\s*=\s*["']app["'][^>]*>)([\s\S]*?)(<\/div>)/i,
+    `$1
+      <template>
+        [[content-${placeholderId}]]
+      </template>
+    $3`,
+  );
+  await mkdirSync(join(outputPath, 'app', 'template'), { recursive: true });
+  await writeFileSync(
+    join(outputPath, 'app', 'template', 'article.html'),
+    index,
+  );
+  /**
+   await writeFileSync(`${outputPath}/app/web.config`, `<?xml version="1.0" encoding="UTF-8"?>
+   <configuration>
+   <system.webServer>
+   <rewrite>
+   <rules>
+   <rule name="Rewrite to index.html" stopProcessing="true">
+   <match url=".*" />
+   <conditions logicalGrouping="MatchAll">
+   <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
+   <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
+   </conditions>
+   <action type="Rewrite" url="index.html" />
+   </rule>
+   </rules>
+   </rewrite>
+   </system.webServer>
+   </configuration>`);
+   await writeFileSync(`${outputPath}/app/.htaccess`, `RewriteEngine On
+   RewriteCond %{REQUEST_FILENAME} !-f
+   RewriteCond %{REQUEST_FILENAME} !-l
+   RewriteCond %{REQUEST_FILENAME} !-d
+   RewriteRule ^(.*)$ index.html [L]`);
+   /**/
+  return build;
+}
+/**
+ * Builds the application by performing the following steps:
+ *
+ * 1. Checks the folders.
+ * 2. Executes the viteBuild function.
+ *
+ * @returns {Promise<void>} A Promise that resolves when the application is built.
+ */
+async function buildDDev() {
+  console.log("\n\nBuild application for DDEV");
+  await checkFolders();
+  const build = await viteBuild({
+    build: {
+      outDir: './.output/ddev',
+    },
+    publicDir: true,
+  });
+  return build;
+}
+/**
+ * Compresses the 'app' folder into a zip file using archiver library.
+ *
+ * @async
+ * @function zipApp
+ * @returns {Promise<void>} - A Promise that resolves when the zip operation is complete, or rejects with an error.
+ */
+async function zipApp() {
+  console.log("\n\nCreate zip file for app");
+  await checkFolders();
+  const archiver = require('archiver');
+  const output = createWriteStream(join(outputPath, 'app.zip'));
+  const archive = archiver('zip', {
+    zlib: { level: 9 }, // Sets the compression level.
+  });
+  output.on('close', function () {
+    console.log('Create zip ' + outputPath + '/app.zip');
+    console.log(archive.pointer() + ' total bytes');
+  });
+  output.on('end', function () {
+    console.log('Data has been drained');
+  });
+  archive.on('warning', function (err) {
+    if (err.code === 'ENOENT') {
+      console.error(err);
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+  archive.on('error', function (err) {
+    throw err;
+  });
+  archive.pipe(output);
+  archive.directory(join(outputPath, 'app', '/'), false);
+  archive.finalize();
+}
+async function zipLdd() {
+  console.log("\n\nCreate zip file for LDD");
+  await checkFolders();
+  const archiver = require('archiver');
+  const output = createWriteStream(join(outputPath, 'design.zip'));
+  const archive = archiver('zip', {
+    zlib: { level: 9 }, // Sets the compression level.
+  });
+  output.on('close', function () {
+    console.log('Create zip ' + outputPath + '/design.zip');
+    console.log(archive.pointer() + ' total bytes');
+  });
+  output.on('end', function () {
+    console.log('Data has been drained');
+  });
+  archive.on('warning', function (err) {
+    if (err.code === 'ENOENT') {
+      console.error(err);
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+  archive.on('error', function (err) {
+    throw err;
+  });
+  archive.pipe(output);
+  archive.directory(join(outputPath, 'ldd', '/'), false);
+  archive.finalize();
+}
+/**
+ * Builds a PDF using the provided HTML template.
+ *
+ * @returns {Promise<boolean>} - Returns a Promise that resolves to true if the PDF was successfully built,
+ *                              false otherwise.
+ */
+async function buildPdf() {
+  console.log("\n\nBuild PDF");
+  await checkFolders();
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
+        },
+      },
+    },
+    base: './',
+    build: {
+      outDir: join(folders.srlOutput, 'pdf'),
+      lib: {
+        fileName: 'pdf',
+        entry: join(folders.srlEntries, 'pdf.ts'),
+        formats: ['es'],
+      },
+    },
+    publicDir: false,
+  };
+  try {
+    return await viteBuild(config);
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+}
+async function buildXbrl() {
+  console.log("\n\nBuild XBRL");
+  await checkFolders();
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
+        },
+      },
+    },
+    base: './',
+    build: {
+      outDir: join(folders.srlOutput, 'xbrl'),
+      lib: {
+        fileName: 'xbrl',
+        entry: join(folders.srlImports, 'xbrl.scss'),
+        formats: ['es'],
+      },
+    },
+    publicDir: false,
+  };
+  try {
+    return await viteBuild(config);
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+}
+/**
+ * Builds Living Documentation (LDD) for a project.
+ *
+ * @async
+ * @param {string} version - The version number to update in the project's package.json file. (optional)
+ * @returns {Promise<boolean>} - A Promise that resolves to true if the LDD build is successful, false otherwise.
+ */
+async function buildLdd(version) {
+  console.log("\n\nBuild Livingdocs");
+  await checkFolders();
+  await mapLdd();
+  const packageJson = await readPackageJson();
+  const lddJson = await readLivingDocsJson();
+  if (version) {
+    packageJson.version = version;
+    await writePackageJson();
+  }
+  lddJson.name = packageJson.name;
+  lddJson.version = packageJson.version;
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
+        },
+      },
+    },
+    base: './',
+    build: {
+      outDir: join(folders.srlOutput, 'ldd', 'assets'),
+      lib: {
+        fileName: 'ldd',
+        entry: join(folders.srlImports, 'ldd.scss'),
+        formats: ['es'],
+      },
+    },
+    publicDir: false,
+  };
+  await writeFileSync(join(outputPath, `v${lddJson.version}.txt`), '');
+  try {
+    return await viteBuild(config)
+      .then(async () => {
+        const assetsPath = join(outputPath, 'ldd', 'assets');
+        const assetsFiles = await readdirSync(assetsPath);
+        lddJson.assets.css = [];
+        lddJson.assets.js = [];
+        for (let i = 0; i < assetsFiles.length; i++) {
+          const file = assetsFiles[i];
+          if (file.endsWith('.css')) {
+            const path = join('./assets/' + file);
+            if (!lddJson.assets.css.includes(path)) {
+              lddJson.assets.css.push(path);
+            }
+          }
+          if (file.endsWith('.js')) {
+            const path = join('./assets/' + file);
+            if (!lddJson.assets.js.includes(path)) {
+              lddJson.assets.js.push(path);
+            }
+          }
+        }
+        const fontFiles = await glob(join(folders.srlAssets, 'fonts', '**', '*.scss'), {
+          withFileTypes: true,
+        });
+        if (fontFiles.length) {
+          console.log("\n\nBuild Livingdocs fonts");
+          const importPath = join(folders.srlImports, 'fonts');
+          try {
+            await statSync(importPath);
+          } catch (e) {
+            await mkdirSync(importPath, { recursive: true });
+          }
+          const importFile = join(importPath, 'style.scss');
+          const importFonts = [];
+          fontFiles.forEach( f => {
+            importFonts.push(`../../../${f.relativePosix()}`);
+          })
+          await writeFileSync(importFile, `@use "` + importFonts.join('" as *;\n@use "') + `" as *;\n`)
+          await viteBuild({
+            css: {
+              preprocessorOptions: {
+                scss: {
+                  api: 'modern-compiler',
+                },
+              },
+            },
+            base: './',
+            build: {
+              outDir: join(folders.srlOutput, 'ldd', 'fonts'),
+              assetsInlineLimit: 0,
+              assetsDir: '',
+              rollupOptions: {
+                input: importFile,
+                output: {
+                  assetFileNames: (assetInfo) => {
+                    if (/woff|woff2|ttf|otf|svg|jpe?g|png|gif|webp|avif|bmp|ico|apng/.test(assetInfo.name)) {
+                      return '[name]-[hash][extname]';
+                    }
+                    return '[name][extname]';
+                  }
+                }
+              }
+            },
+            resolve: {
+              alias: {
+                '~': folders.root,
+                '@': folders.srlSrc,
+                '#components': folders.srlComponents,
+                '#composables': folders.srlComposables,
+                '#plugins': folders.srlPlugins,
+                '#types': folders.srlTypes,
+                '#utils': folders.srlUtils,
+                '#imports': folders.srlImports,
+                '#ldd': folders.packageLd,
+                'assets': folders.srlAssets,
+                'srl': folders.srlSystem,
+              },
+            },
+            publicDir: false,
+          })
+        }
+        console.log("\n\nBuild Livingdocs design.json");
+        await writeLivingDocsJson();
+        return true;
+      })
+      .then(async () => {
+        copyFileSync(
+          join(folders.root, 'livingdocs.config.json'),
+          join(folders.srlOutput, 'ldd', 'design.json'),
+        );
+      });
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+}
+/**
+ * Builds the word document by compiling the HTML file using Vite and
+ * returns the result.
+ *
+ * @returns {Promise<boolean>} - A promise that resolves to true if the word document is successfully built,
+ *                              or false if there was an error during the build process.
+ */
+async function buildWord() {
+  console.log("\n\nBuild Word");
+  await checkFolders();
+  let configFile = false;
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
+        },
+      },
+    },
+    base: './',
+    build: {
+      outDir: join(folders.srlOutput, 'word'),
+      lib: {
+        fileName: 'word',
+        entry: join(folders.srlImports, 'word.scss'),
+        formats: ['es'],
+      },
+    },
+    publicDir: false,
+  };
+  try {
+    return await viteBuild(config);
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+}
+/**
+ * Builds the project sequentially by executing a series of asynchronous tasks in a specific order.
+ * This method is used to build the project in a predetermined sequence.
+ *
+ * @param {string} version
+ * @return {Promise<void>} A Promise that resolves when the build process is completed or rejects if an error occurs.
+ */
+async function build(version) {
+  try {
+    await checkFolders();
+    const packageJson = await readPackageJson();
+    if (!version) {
+      const prompt = new Input({
+        message: 'Livingdocs version',
+        initial: packageJson.version,
+      });
+      version = await prompt.run();
+    }
+    packageJson.version = version;
+    await writePackageJson();
+    await cleanOutput();
+    await buildApp();
+    await buildPdf();
+    await buildWord();
+    await buildXbrl();
+    await buildLdd();
+    new LivingdocsDesignValidator(await readLivingDocsJson()).IsDesignValid();
+    await zipApp();
+    await zipLdd();
+  } catch (error) {
+    console.log(error);
+  }
+}
+/**
+ * Builds the project sequentially by executing a series of asynchronous tasks in a specific order.
+ * This method is used to build the project in a predetermined sequence.
+ *
+ * @return {Promise<void>} A Promise that resolves when the build process is completed or rejects if an error occurs.
+ */
+async function ddev() {
+  try {
+    await checkFolders();
+    await buildDDev();
+  } catch (error) {
+    console.error(error);
+  }
+}
+/**
+ * Cleans up the SCSS alias by removing any characters that are not alphanumeric.
+ * @param string
+ */
+function cleanupScssAlias(string) {
+  return string.replace(/[^a-zA-Z0-9]/g, '');
+}
+/**
+ * Maps SCSS files and generates import statements for different output files.
+ *
+ * @returns {Promise<boolean>} Returns a promise that resolves to true if the SCSS mapping is successful, and false if there's an error.
+ */
+async function mapScss() {
+  await checkFolders();
+  try {
+    const packageJson = await readPackageJson();
+    const relativePathToRoot = join('..', '..', '/');
+    const output = {
+      app: [],
+      ldd: [],
+      pdf: [],
+      word: [],
+      xbrl: [],
+    };
+    const fontFiles = await glob(join(folders.srlAssets, 'fonts', '**', '*.scss'), {
+      withFileTypes: true,
+    });
+    const fontsOutput = []
+    if (fontFiles.length) {
+      fontsOutput.push(`@import "${nsWowInternalLddUrl}/${packageJson.name}/${packageJson.version}/fonts/style.css";`);
+      fontFiles.forEach(f => {
+        output.app.push(`"${relativePathToRoot}${f.relativePosix()}" as *`);
+        output.xbrl.push(`"${relativePathToRoot}${f.relativePosix()}" as *`);
+      })
+      output.ldd.push(`"./fonts.scss" as *`);
+      output.pdf.push(`"./fonts.scss" as *`);
+      output.word.push(`"./fonts.scss" as *`);
+    }
+    await writeFileSync(join(folders.srlImports, 'fonts.scss'), fontsOutput.join('\n'));
+    const mainFiles = await glob(join(folders.srlAssets, 'scss', '*.scss'), {
+      withFileTypes: true,
+    });
+    let f = mainFiles.find((p) => {
+      return p.name === 'general.scss';
+    });
+    if (f) {
+      output.app.push(`"${relativePathToRoot}${f.relativePosix()}" as *`);
+      output.ldd.push(`"${relativePathToRoot}${f.relativePosix()}" as *`);
+      output.pdf.push(`"${relativePathToRoot}${f.relativePosix()}" as *`);
+      output.word.push(`"${relativePathToRoot}${f.relativePosix()}" as *`);
+    }
+    for (let x = 0; x < mainFiles.length; x++) {
+      const alias = cleanupScssAlias(mainFiles[x].relativePosix());
+      if (mainFiles[x].name === 'app.scss') {
+        output.app.push(
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
+        );
+      }
+      if (mainFiles[x].name === 'ldd.scss') {
+        output.ldd.push(
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
+        );
+      }
+      if (mainFiles[x].name === 'editor.scss') {
+        output.ldd.push(
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
+        );
+      }
+      if (mainFiles[x].name === 'pdf.scss') {
+        output.pdf.push(
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
+        );
+      }
+      if (mainFiles[x].name === 'word.scss') {
+        output.word.push(
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
+        );
+      }
+      if (mainFiles[x].name === 'xbrl.scss') {
+        output.xbrl.push(
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
+        );
+      }
+    }
+    const livingdocs = await glob(join(folders.ld, '**', '*'), {
+      maxDepth: 3,
+      withFileTypes: true,
+    });
+    livingdocs.sort((a, b) => {
+      const valueA = a.relativePosix().toUpperCase();
+      const valueB = b.relativePosix().toUpperCase();
+      if (valueA < valueB) {
+        return -1;
+      }
+      if (valueA > valueB) {
+        return 1;
+      }
+      return 0;
+    });
+    const components = livingdocs.filter((p) => {
+      return p.name !== 'Properties' && p.parent.name !== 'Properties';
+    });
+    const properties = livingdocs.filter((p) => {
+      return p.name === 'Properties' || p.parent.name === 'Properties';
+    });
+    const livingdocsList = [...components, ...properties];
+    for (let x = 0; x < livingdocsList.length; x++) {
+      const p = livingdocsList[x];
+      try {
+        const general = await statSync(
+          join(p.fullpath(), 'scss', 'general.scss'),
+        );
+        output.app.push(
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
+        );
+        output.ldd.push(
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
+        );
+        output.pdf.push(
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
+        );
+        output.word.push(
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
+        );
+      } catch (e) {}
+      const types = ['app', 'ldd', 'editor', 'pdf', 'word', 'xbrl'];
+      for (let i = 0; i < types.length; i++) {
+        const type = types[i];
+        try {
+          const f = await statSync(join(p.fullpath(), 'scss', `${type}.scss`));
+          const alias = cleanupScssAlias(`${p.relativePosix()}/${type}.scss`);
+          const fileName = type === 'editor' ? 'ldd' : type;
+          output[fileName].push(
+            `"${relativePathToRoot}${p.relativePosix()}/scss/${type}.scss" as *`,
+          );
+        } catch (e) {}
+      }
+    }
+    await writeFileSync(
+      join(folders.srlImports, 'app.scss'),
+      `@use ` +
+        output.app.join(';\n@use ') +
+        `;\n@use "../scss/core-styles.scss" as *;\n`,
+    );
+    await writeFileSync(
+      join(folders.srlImports, 'ldd.scss'),
+      `@use ` +
+        output.ldd.join(';\n@use ') +
+        `;\n@use "../scss/core-styles.scss" as *;\n`,
+    );
+    await writeFileSync(
+      join(folders.srlImports, 'pdf.scss'),
+      `@use ` +
+        output.pdf.join(';\n@use ') +
+        `;\n@use "../scss/core-styles.scss" as *;\n`,
+    );
+    await writeFileSync(
+      join(folders.srlImports, 'word.scss'),
+      `@use ` +
+        output.word.join(';\n@use ') +
+        `;\n@use "../scss/core-styles.scss" as *;\n`,
+    );
+    await writeFileSync(
+      join(folders.srlImports, 'xbrl.scss'),
+      output.xbrl.length
+        ? `@use ` + output.xbrl.join(';\n@use ')
+        : '' + `;\n@use "../scss/xbrl-core-styles.scss" as *;\n`,
+    );
+    return true;
+  } catch (e) {
+    console.log(e);
+    return false;
+  }
+}
+/**
+ * This function asynchronously maps JavaScript files and imports them into specific files.
+ * @returns {Promise<boolean>} - A promise that resolves to true if the mapping and importing is successful.
+ */
+async function mapJs() {
+  const jsFiles = await glob(join(folders.ld, '**', 'app.[t,j]s'), {
+    withFileTypes: true,
+  });
+  const imports = [];
+  const register = [];
+  for (let i = 0; i < jsFiles.length; i++) {
+    const file = jsFiles[i];
+    const className = camelCase(file.parent.name);
+    const path = [file.name];
+    let parent = file.parent;
+    while (parent) {
+      path.unshift(parent.name);
+      if (parent.name !== 'livingdocs') {
+        parent = parent.parent;
+      } else {
+        parent = false;
+      }
+    }
+    imports.push(`import ${className} from "../${path.join(file.sep)}"`);
+    register.push(`ClassAutoLoader.register(${className}, "${className}")`);
+  }
+  const content = `import ArticleAutoloader from 'srl/ArticleAutoloader'
+${imports.join('\n')}
+const ClassAutoLoader = new ArticleAutoloader()
+${register.join('\n')}
+export default ClassAutoLoader
+export { ClassAutoLoader }`;
+  await writeFileSync(join(folders.srlSrc, 'Autoload.ts'), content);
+  return true;
+}
+/**
+ * Maps the SCSS files and the LDD files in the project.
+ *
+ * @async
+ * @function map
+ * @returns {Promise<boolean>} A promise that resolves after successfully mapping the files.
+ * @throws {Error} If there is an error during the mapping process.
+ */
+async function map() {
+  await checkFolders();
+  await mapScss();
+  await mapLdd();
+  return true;
+}
+export { build, ddev, map, mapScss, mapLdd, mapJs };