@simple-reporting/base 0.1.112 → 1.0.0

package/scripts/build.js

@@ -1,4 +1,4 @@
-import { resolve } from 'node:path';
+import { join } from 'node:path/posix';
 import {
   statSync,
   writeFileSync,
@@ -8,25 +8,26 @@ import {
   createWriteStream,
   rmSync,
   cpSync,
+  copyFileSync,
 } 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';
+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 CWD = process.cwd();
-const nswowPath = resolve(CWD, '.nswow');
-const outputPath = resolve(CWD, '.output');
+const nswowPath = folders.srlImports;
+const outputPath = folders.srlOutput;
 const require = createRequire(import.meta.url);
 
 const { Input } = require('enquirer');
@@ -65,7 +66,7 @@ async function cleanOutput() {
   await checkFolders();
   const output = readdirSync(outputPath);
   for (let i = 0; i < output.length; i++) {
-    await rmSync(`${outputPath}/${output[i]}`, {
+    await rmSync(join(outputPath, output[i]), {
       force: true,
       recursive: true,
     });
@@ -82,29 +83,38 @@ async function cleanOutput() {
  * @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(`${CWD}/public/`, `${outputPath}/app`, {
+  await cpSync(join(folders.srlPublic, '/'), join(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`)
+        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 === `${CWD}/public/` ||
+        src === join(folders.srlPublic, '/') ||
           console.log(`Copy ${src} to ${outputPath}/app`);
         return true;
       }
@@ -113,7 +123,10 @@ async function buildApp() {
   });
   console.log('\n');
 
-  let index = await readFileSync(`${outputPath}/app/index.html`, 'utf8');
+  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(
@@ -126,6 +139,8 @@ async function buildApp() {
     [[meta-${placeholderId}]]`,
   );
 
+  await writeFileSync(join(outputPath, 'app', 'index.html'), index);
+
   index = index.replace(
     /(<div\s+[^>]*id\s*=\s*["']app["'][^>]*>)([\s\S]*?)(<\/div>)/i,
     `$1
@@ -135,9 +150,11 @@ async function buildApp() {
     $3`,
   );
 
-  await mkdirSync(`${outputPath}/app/template`, { recursive: true });
-  await writeFileSync(`${outputPath}/app/index.html`, index);
-  await writeFileSync(`${outputPath}/app/template/article.html`, index);
+  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>
@@ -174,11 +191,13 @@ async function buildApp() {
  * @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;
 }
@@ -191,9 +210,10 @@ async function buildDDev() {
  * @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(outputPath + '/app.zip');
+  const output = createWriteStream(join(outputPath, 'app.zip'));
   const archive = archiver('zip', {
     zlib: { level: 9 }, // Sets the compression level.
   });
@@ -216,7 +236,38 @@ async function zipApp() {
     throw err;
   });
   archive.pipe(output);
-  archive.directory(outputPath + '/app/', false);
+  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();
 }
 
@@ -227,66 +278,66 @@ async function zipApp() {
  *                              false otherwise.
  */
 async function buildPdf() {
+  console.log("\n\nBuild PDF");
   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]`,
-          },
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
         },
-        copyPublicDir: false,
       },
-    });
+    },
+    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) {
-    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');
-    }
+    console.error(e);
+    return false;
+  }
+}
+
+async function buildXbrl() {
+  console.log("\n\nBuild XBRL");
+  await checkFolders();
 
-    const entry = resolve(CWD, 'pdf.ts');
-
-    const config = {
-      configFile: configFile,
-      base: './',
-      build: {
-        outDir: resolve(CWD, '.output/pdf'),
-        lib: {
-          fileName: 'pdf',
-          entry: entry,
-          formats: ['es'],
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
         },
       },
-      resolve: {
-        alias: {
-          '@': fileURLToPath(new URL(resolve(CWD, 'src'), import.meta.url)),
-          nswow: fileURLToPath(new URL(resolve(CWD, 'nswow'), import.meta.url)),
-        },
+    },
+    base: './',
+    build: {
+      outDir: join(folders.srlOutput, 'xbrl'),
+      lib: {
+        fileName: 'xbrl',
+        entry: join(folders.srlImports, 'xbrl.scss'),
+        formats: ['es'],
       },
-      publicDir: false,
-    };
+    },
+    publicDir: false,
+  };
 
-    try {
-      return await viteBuild(config);
-    } catch (e) {
-      console.error(e);
-      return false;
-    }
+  try {
+    return await viteBuild(config);
+  } catch (e) {
+    console.error(e);
+    return false;
   }
 }
 
@@ -298,72 +349,141 @@ async function buildPdf() {
  * @returns {Promise<boolean>} - A Promise that resolves to true if the LDD build is successful, false otherwise.
  */
 async function buildLdd(version) {
-  let action = false;
+  console.log("\n\nBuild Livingdocs");
   await checkFolders();
+  await mapLdd();
 
   const packageJson = await readPackageJson();
   const lddJson = await readLivingDocsJson();
 
   if (version) {
     packageJson.version = version;
-    await writePackageJson(packageJson);
-    action = true;
+    await writePackageJson();
   }
 
   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]`,
-          },
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
         },
-        copyPublicDir: false,
       },
-    })
+    },
+    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 = outputPath + '/ldd/assets';
+        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 = './assets/' + file;
+            const path = join('./assets/' + file);
             if (!lddJson.assets.css.includes(path)) {
-              action = true;
               lddJson.assets.css.push(path);
             }
           }
           if (file.endsWith('.js')) {
-            const path = './assets/' + file;
+            const path = join('./assets/' + file);
             if (!lddJson.assets.js.includes(path)) {
-              action = true;
               lddJson.assets.js.push(path);
             }
           }
         }
-        if (action) {
-          await writeLivingDocsJson(lddJson);
+
+        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 () => {
-        return await finalizeLdd();
+        copyFileSync(
+          join(folders.root, 'livingdocs.config.json'),
+          join(folders.srlOutput, 'ldd', 'design.json'),
+        );
       });
   } catch (e) {
     console.error(e);
@@ -379,66 +499,35 @@ async function buildLdd(version) {
  *                              or false if there was an error during the build process.
  */
 async function buildWord() {
+  console.log("\n\nBuild Word");
   await checkFolders();
+  let configFile = false;
 
-  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]`,
-          },
+  const config = {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: 'modern-compiler',
         },
-        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)),
-        },
+    },
+    base: './',
+    build: {
+      outDir: join(folders.srlOutput, 'word'),
+      lib: {
+        fileName: 'word',
+        entry: join(folders.srlImports, 'word.scss'),
+        formats: ['es'],
       },
-      publicDir: false,
-    };
+    },
+    publicDir: false,
+  };
 
-    try {
-      return await viteBuild(config);
-    } catch (e) {
-      console.error(e);
-      return false;
-    }
+  try {
+    return await viteBuild(config);
+  } catch (e) {
+    console.error(e);
+    return false;
   }
 }
 
@@ -446,26 +535,34 @@ async function buildWord() {
  * 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() {
+async function build(version) {
   try {
     await checkFolders();
     const packageJson = await readPackageJson();
-    const prompt = new Input({
-      message: 'Livingdocs version',
-      initial: packageJson.version,
-    });
-    const version = await prompt.run();
+
+    if (!version) {
+      const prompt = new Input({
+        message: 'Livingdocs version',
+        initial: packageJson.version,
+      });
+      version = await prompt.run();
+    }
+
+    packageJson.version = version;
+    await writePackageJson();
+
     await cleanOutput();
-    await beaver(1);
-    await mapScss();
-    await mapLdd();
     await buildApp();
     await buildPdf();
     await buildWord();
-    await buildLdd(version);
+    await buildXbrl();
+    await buildLdd();
+    new LivingdocsDesignValidator(await readLivingDocsJson()).IsDesignValid();
     await zipApp();
+    await zipLdd();
   } catch (error) {
     console.log(error);
   }
@@ -480,10 +577,6 @@ async function build() {
 async function ddev() {
   try {
     await checkFolders();
-    const packageJson = await readPackageJson();
-    await beaver(1);
-    await mapScss();
-    await mapLdd();
     await buildDDev();
   } catch (error) {
     console.error(error);
@@ -506,66 +599,93 @@ function cleanupScssAlias(string) {
 async function mapScss() {
   await checkFolders();
   try {
-    const relativePathToRoot = '../';
+    const packageJson = await readPackageJson();
+
+    const relativePathToRoot = join('..', '..', '/');
 
     const output = {
       app: [],
       ldd: [],
       pdf: [],
       word: [],
+      xbrl: [],
     };
 
-    const mainFiles = await glob(
-      resolve(process.cwd(), './src/assets/scss/*.scss'),
-      {
-        withFileTypes: true,
-      },
-    );
+    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';
     });
 
-    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}`);
+      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].relative());
+      const alias = cleanupScssAlias(mainFiles[x].relativePosix());
       if (mainFiles[x].name === 'app.scss') {
         output.app.push(
-          `"${relativePathToRoot}${mainFiles[x].relative()}" as ${alias}`,
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
         );
       }
       if (mainFiles[x].name === 'ldd.scss') {
         output.ldd.push(
-          `"${relativePathToRoot}${mainFiles[x].relative()}" as ${alias}`,
+          `"${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].relative()}" as ${alias}`,
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
         );
       }
       if (mainFiles[x].name === 'word.scss') {
         output.word.push(
-          `"${relativePathToRoot}${mainFiles[x].relative()}" as ${alias}`,
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
+        );
+      }
+      if (mainFiles[x].name === 'xbrl.scss') {
+        output.xbrl.push(
+          `"${relativePathToRoot}${mainFiles[x].relativePosix()}" as *`,
         );
       }
     }
 
-    const livingdocs = await glob(resolve(process.cwd(), './livingdocs/**/*'), {
+    const livingdocs = await glob(join(folders.ld, '**', '*'), {
       maxDepth: 3,
       withFileTypes: true,
     });
     livingdocs.sort((a, b) => {
-      const valueA = a.relative().toUpperCase();
-      const valueB = b.relative().toUpperCase();
+      const valueA = a.relativePosix().toUpperCase();
+      const valueB = b.relativePosix().toUpperCase();
       if (valueA < valueB) {
         return -1;
       }
@@ -588,59 +708,68 @@ async function mapScss() {
     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`);
+        const general = await statSync(
+          join(p.fullpath(), 'scss', 'general.scss'),
+        );
         output.app.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
         );
         output.ldd.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
         );
         output.pdf.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
         );
         output.word.push(
-          `"${relativePathToRoot}${p.relative()}/general.scss" as ${alias}`,
+          `"${relativePathToRoot}${p.relativePosix()}/scss/general.scss" as *`,
         );
       } catch (e) {}
 
-      const types = ['app', 'ldd', 'pdf', 'word'];
+      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(p.fullpath() + '/' + type + '.scss');
-          const alias = cleanupScssAlias(`${p.relative()}/${type}.scss`);
-          output[type].push(
-            `"${relativePathToRoot}${p.relative()}/${type}.scss" as ${alias}`,
+          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(
-      `${CWD}/.nswow/app.scss`,
+      join(folders.srlImports, 'app.scss'),
       `@use ` +
         output.app.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
+        `;\n@use "../scss/core-styles.scss" as *;\n`,
     );
     await writeFileSync(
-      `${CWD}/.nswow/ldd.scss`,
+      join(folders.srlImports, 'ldd.scss'),
       `@use ` +
         output.ldd.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
+        `;\n@use "../scss/core-styles.scss" as *;\n`,
     );
     await writeFileSync(
-      `${CWD}/.nswow/pdf.scss`,
+      join(folders.srlImports, 'pdf.scss'),
       `@use ` +
         output.pdf.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
+        `;\n@use "../scss/core-styles.scss" as *;\n`,
     );
     await writeFileSync(
-      `${CWD}/.nswow/word.scss`,
+      join(folders.srlImports, 'word.scss'),
       `@use ` +
         output.word.join(';\n@use ') +
-        `;\n@use "nswow/core-styles" as nswowcorestyles;\n`,
+        `;\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;
@@ -655,7 +784,7 @@ async function mapScss() {
  * @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'), {
+  const jsFiles = await glob(join(folders.ld, '**', 'app.[t,j]s'), {
     withFileTypes: true,
   });
 
@@ -679,121 +808,17 @@ async function mapJs() {
     register.push(`ClassAutoLoader.register(${className}, "${className}")`);
   }
 
-  const content = `import ArticleAutoloader from 'nswow/ArticleAutoloader'
+  const content = `import ArticleAutoloader from 'srl/ArticleAutoloader'
 ${imports.join('\n')}
 const ClassAutoLoader = new ArticleAutoloader()
 ${register.join('\n')}
 export default ClassAutoLoader
 export { ClassAutoLoader }`;
 
-  await writeFileSync(resolve(CWD, './src/Autoload.ts'), content);
+  await writeFileSync(join(folders.srlSrc, '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.
  *