@simple-reporting/base 0.1.112 → 1.0.0

package/scripts/components.js

@@ -1,28 +1,23 @@
 import { createRequire } from 'node:module';
-import { resolve, dirname } from 'node:path';
+import { join } from 'node:path/posix';
 import { glob } from 'glob';
-import { copy, ensureDir } from 'fs-extra';
+import { copy } from 'fs-extra';
 import { rm, statSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
 import { lddGroupNames } from './utils.js';
-import { map } from '@simple-reporting/base/scripts/build.js';
+import { map } from './build.js';
+import folders from './folders.js';
 
 const require = createRequire(import.meta.url);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 
-const packagePath = resolve(__dirname, '../');
-const CWD = process.cwd();
-
-const { MultiSelect, Confirm, AutoComplete, Input } = require('enquirer');
+const { MultiSelect, Confirm, AutoComplete } = require('enquirer');
 
 /**
  * Adds groups of livingdocs to a specified output directory.
  * @returns {boolean} - Returns true if groups were added successfully.
  */
 async function addGroups() {
-  const outputPath = resolve(CWD, './livingdocs');
-  const groupsPath = `${packagePath}/livingdocs`;
+  const outputPath = folders.ld;
+  const groupsPath = folders.packageLd;
   const groups = readdirSync(groupsPath);
   const groupsExists = [];
   for (let i = 0; i < groups.length; i++) {
@@ -60,17 +55,17 @@ async function addGroups() {
       const installed = [];
       for (const key in groups) {
         const group = groups[key];
-        const components = readdirSync(`${groupsPath}/${group}`);
+        const components = readdirSync(join(groupsPath, group));
         for (let i = 0; i < components.length; i++) {
           const component = components[i];
           try {
-            await statSync(`${outputPath}/${group}/${component}`);
+            await statSync(join(outputPath, group, component));
             console.log(`Component ${key} / ${component} allready exists!`);
           } catch (e) {
             action = true;
             await copy(
-              `${groupsPath}/${group}/${component}`,
-              `${outputPath}/${group}/${component}`,
+              join(groupsPath, group, component),
+              join(outputPath, group, component),
             );
             console.log(`Component ${key} / ${component} installed!`);
           }
@@ -98,19 +93,19 @@ async function addGroups() {
  * @returns {Promise<void>} - A promise that resolves when the components are added successfully.
  */
 async function addComponents() {
-  const filesToAdd = await glob(`${packagePath}/livingdocs/**/*`, {
+  const filesToAdd = await glob(join(folders.packageLd, '**', '*'), {
     maxDepth: 6,
   });
-  const filesExists = await glob(`${CWD}/livingdocs/**/*`, { maxDepth: 3 });
+  const filesExists = await glob(join(folders.ld, '**', '*'), { maxDepth: 3 });
   const livingdocsToAdd = [];
   const livingdocsExists = [];
 
   for (let x = 0; x < filesExists.length; x++) {
-    const c = filesExists[x].replace(`${CWD}/livingdocs/`, '');
+    const c = filesExists[x].replace(join(folders.ld, '/'), '');
     livingdocsExists.push(c);
   }
   for (let x = 0; x < filesToAdd.length; x++) {
-    const c = filesToAdd[x].replace(`${packagePath}/livingdocs/`, '');
+    const c = filesToAdd[x].replace(join(folders.packageLd, '/'), '');
     if (!livingdocsExists.includes(c) && c.indexOf('/') !== -1) {
       livingdocsToAdd.push({ name: lddGroupNames(c), value: c });
     }
@@ -148,8 +143,8 @@ async function addComponents() {
         const oKeys = Object.keys(livingdocs);
         for (let x = 0; x < oKeys.length; x++) {
           await copy(
-            `${packagePath}/livingdocs/${livingdocs[oKeys[x]]}`,
-            `${CWD}/livingdocs/${livingdocs[oKeys[x]]}`,
+            join(folders.packageLd, livingdocs[oKeys[x]]),
+            join(folders.ld, livingdocs[oKeys[x]]),
           );
         }
         await map();
@@ -165,7 +160,7 @@ async function addComponents() {
  * @returns {boolean} Returns true if the livingdocs groups were successfully removed, otherwise false.
  */
 async function removeGroups() {
-  const livingdocsPath = resolve(CWD, './livingdocs');
+  const livingdocsPath = folders.ld;
   const groupsExists = [];
   const groupsList = await readdirSync(livingdocsPath);
   for (let i = 0; i < groupsList.length; i++) {
@@ -210,7 +205,7 @@ async function removeGroups() {
           if (remove) {
             oKeys.forEach(async (k) => {
               await rm(
-                `${CWD}/livingdocs/${groups[k]}`,
+                join(folders.ld, groups[k]),
                 { recursive: true, force: true },
                 (err) => {
                   if (err) {
@@ -235,13 +230,13 @@ async function removeGroups() {
  * @returns {Promise<void>} A promise that resolves once the components are removed.
  */
 async function removeComponents() {
-  const filesExists = await glob(`${CWD}/livingdocs/**/*`, { maxDepth: 3 });
+  const filesExists = await glob(join(folders.ld, '**', '*'), { maxDepth: 3 });
   const livingdocsExists = [];
   for (let x = 0; x < filesExists.length; x++) {
-    const c = filesExists[x].replace(`${CWD}/livingdocs/`, '');
+    const c = filesExists[x].replace(join(folders.ld, '/'), '');
     if (c.indexOf('/') !== -1) {
       const p = c.split('/');
-      let group = p[0].replace('_and_', ' / ').replace('_', ' ');
+      let group = lddGroupNames(p[0]);
       livingdocsExists.push({
         name: lddGroupNames(`${group} / ${p[1]}`),
         value: c,
@@ -287,7 +282,7 @@ async function removeComponents() {
           if (remove) {
             oKeys.forEach(async (k) => {
               await rm(
-                `${CWD}/livingdocs/${livingdocs[k]}`,
+                join(folders.ld, livingdocs[k]),
                 { recursive: true, force: true },
                 (err) => {
                   if (err) {
@@ -317,7 +312,7 @@ function mapComponentName(name) {
     name: false,
   };
   if (name) {
-    const n = name.split('/');
+    const n = name.includes('\\') ? name.split('\\') : name.split('/');
     if (n.length > 1) {
       component.group = n[0];
       component.name = n[1];
@@ -345,29 +340,21 @@ async function writeComponent(group, name) {
   }
 
   try {
-    const stat = await statSync(`${CWD}/livingdocs/${group}/${name}`);
+    const stat = await statSync(join(folders.ld, group, name));
     console.error(`Component ${group}/${name} already exist!`);
   } catch (e) {
     try {
-      await statSync(`${CWD}/livingdocs/${group}`);
+      await statSync(join(folders.ld, group));
     } catch (e) {
-      await mkdirSync(`${CWD}/livingdocs/${group}`);
+      await mkdirSync(join(folders.ld, group));
+      await mkdirSync(join(folders.ld, group));
     }
 
-    await mkdirSync(`${CWD}/livingdocs/${group}/${name}`);
+    await mkdirSync(join(folders.ld, group, name));
+    await mkdirSync(join(folders.ld, group, name, 'scss'));
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/${name}.html`,
-      `<script type="ld-conf">
-{
-  "name": "${name}",
-  "label": "${name}",
-  "properties": [
-    "web-width",
-    "pdf-width"
-  ]
-}
-</script>
-<p class="srl-${name} srl-article__grid srl-article__grid--content">
+      join(folders.ld, group, name, `${name}.html`),
+      `<p class="srl-${name} srl-article__grid srl-article__grid--content">
   <span class="srl-article__grid--inner" doc-editable="text">
     Editable Text
   </span>
@@ -375,42 +362,49 @@ async function writeComponent(group, name) {
 `,
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/general.scss`,
-      `@use "nswow";
+      join(folders.ld, group, name, `ld-conf.json`),
+      `{
+  "name": "${name}",
+  "label": "${name.charAt(0).toUpperCase()}${name.slice(1)}"
+}`,
+    );
+    await writeFileSync(
+      join(folders.ld, group, name, 'scss', `general.scss`),
+      `@use "srl";
 
 .srl-${name} {
 
-}
-`,
+}`,
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/_web.scss`,
-      '@use "nswow";',
+      join(folders.ld, group, name, 'scss', `_web.scss`),
+      '@use "srl";',
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/_print.scss`,
-      '@use "nswow";',
+      join(folders.ld, group, name, 'scss', `_print.scss`),
+      '@use "srl";',
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/ldd.scss`,
+      join(folders.ld, group, name, 'scss', `ldd.scss`),
       '@use "_web";',
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/app.scss`,
+      join(folders.ld, group, name, 'scss', `app.scss`),
       '@use "_web";',
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/pdf.scss`,
+      join(folders.ld, group, name, 'scss', `pdf.scss`),
       '@use "_print";',
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/word.scss`,
+      join(folders.ld, group, name, 'scss', `word.scss`),
       '@use "_print";',
     );
     await writeFileSync(
-      `${CWD}/livingdocs/${group}/${name}/properties.json`,
-      '{}',
+      join(folders.ld, group, name, 'scss', `xbrl.scss`),
+      '@use "srl";',
     );
+    await writeFileSync(join(folders.ld, group, name, `properties.json`), '{}');
     await map();
     console.log(`Component ${group}/${name} created!`);
   }
@@ -440,10 +434,12 @@ async function createComponent(name) {
       .then(async (name) => {
         component = mapComponentName(name);
         if (!component.group) {
-          const groupFolders = await glob(`${CWD}/livingdocs/*`);
+          const groupFolders = await glob(join(folders.ld, '*'));
           const groups = [];
           for (let x = 0; x < groupFolders.length; x++) {
-            const f = groupFolders[x].split('/');
+            const f = groupFolders[x].includes('\\')
+              ? groupFolders[x].split('\\')
+              : groupFolders[x].split('/');
             groups.push(f.pop());
           }
           groups.sort((a, b) => {
@@ -474,10 +470,12 @@ async function createComponent(name) {
       })
       .catch(console.error);
   } else if (!component.group) {
-    const groupFolders = await glob(`${CWD}/livingdocs/*`);
+    const groupFolders = await glob(join(folders.ld, '*'));
     const groups = [];
     for (let x = 0; x < groupFolders.length; x++) {
-      const f = groupFolders[x].split('/');
+      const f = groupFolders[x].includes('\\')
+        ? groupFolders[x].split('\\')
+        : groupFolders[x].split('/');
       groups.push(f.pop());
     }
     groups.sort((a, b) => {
@@ -519,7 +517,7 @@ async function writeGroup(group) {
     console.error('No group name set!');
     return false;
   }
-  const path = resolve(CWD, `./livingdocs/${group}`);
+  const path = join(folders.ld, group);
   try {
     const stat = await statSync(path);
     console.error(`Group "${group}" allready exist!`);

package/scripts/config.d.ts

@@ -1 +1,9 @@
 export const packageName: "@simple-reporting/base";
+export const baseComponentsToInstall: string[];
+export const nsWowInternalLddUrl: "https://nswow-ld.nswow.ch/designs";
+declare namespace _default {
+    export { packageName };
+    export { baseComponentsToInstall };
+    export { nsWowInternalLddUrl };
+}
+export default _default;

package/scripts/config.js

@@ -1 +1,52 @@
-export const packageName = '@simple-reporting/base';
+export const packageName = '@simple-reporting/base';
+
+export const baseComponentsToInstall = [
+  '010.Titles/010.title-h1',
+  '010.Titles/020.title-h2',
+  '010.Titles/030.title-h3',
+  '010.Titles/040.title-h4',
+  '010.Titles/050.title-h5',
+  '010.Titles/060.title-h6',
+  '020.Text/010.lead',
+  '020.Text/020.paragraph',
+  '020.Text/040.link',
+  '020.Text/050.quote',
+  '020.Text/060.quote-with-portrait',
+  '020.Text/070.footnote-container',
+  '020.Text/080.footnote-item',
+  '030.Lists/010.unordered-list',
+  '030.Lists/020.ordered-list',
+  '030.Lists/030.alphanumeric-list',
+  '030.Lists/040.list-item',
+  '040.Media/010.table',
+  '040.Media/020.image',
+  '040.Media/030.video',
+  '040.Media/040.interactive-element',
+  '070.Container/010.aside-content-container',
+  '070.Container/020.columns-container',
+  '080.CV/010.cv',
+  '080.CV/020.cv-time-span',
+  '090.Signatures/010.signature-container',
+  '090.Signatures/020.signature-item',
+  '100.Misc/010.anchor',
+  '110.PDF/010.pdf-pagebreak',
+  '110.PDF/030.pdf-publication-title',
+  '110.PDF/040.pdf-chapter-title',
+  '110.PDF/070.pdf-cover',
+  '110.PDF/080.pdf-toc-page',
+  '110.PDF/090.pdf-toc-item-title',
+  '110.PDF/100.pdf-toc-item',
+  '110.PDF/110.pdf-toc-item-blank',
+  '999.Properties/alignment',
+  '999.Properties/hide-quote-characters',
+  '999.Properties/pdf-spacer',
+  '999.Properties/width'
+];
+
+export const nsWowInternalLddUrl = 'https://nswow-ld.nswow.ch/designs';
+
+export default {
+  packageName,
+  baseComponentsToInstall,
+  nsWowInternalLddUrl,
+};

package/scripts/doPublish.js

@@ -1,6 +1,7 @@
 import { execSync } from 'child_process';
 import { preparePublish } from './preparePublish.js';
 import { packageName } from './config.js';
+import { getPackageVersion } from './utils.js';
 
 export async function doPublish(version = null) {
   try {
@@ -10,6 +11,17 @@ export async function doPublish(version = null) {
 
     await execSync(`npm publish --tag ${tag}`, { stdio: 'inherit' });
 
+    const latest = await getPackageVersion(packageName);
+
+    if (publishVersion > latest) {
+      await execSync(
+        `npm dist-tag add ${packageName}@${publishVersion} latest`,
+        {
+          stdio: 'inherit',
+        },
+      );
+    }
+
     console.log(
       `Package ${packageName}@${publishVersion} published successfully!`,
     );

package/scripts/folders.d.ts

@@ -0,0 +1,43 @@
+export const root: string;
+export const packageName: string;
+export const packagePath: string;
+export const packageSrl: string;
+export const packageLd: string;
+export const srlRoot: string;
+export const srlSystem: string;
+export const srlComponents: string;
+export const srlComposables: string;
+export const srlUtils: string;
+export const srlPlugins: string;
+export const srlScss: string;
+export const srlImports: string;
+export const srlTypes: string;
+export const srlOutput: string;
+export const srlPublic: string;
+export const srlSrc: string;
+export const srlAssets: string;
+export const srlEntries: string;
+export const ld: string;
+declare namespace _default {
+    export { root };
+    export { packageName };
+    export { packagePath };
+    export { packageSrl };
+    export { packageLd };
+    export { srlRoot };
+    export { srlSystem };
+    export { srlComponents };
+    export { srlComposables };
+    export { srlUtils };
+    export { srlPlugins };
+    export { srlScss };
+    export { srlImports };
+    export { srlTypes };
+    export { srlOutput };
+    export { srlPublic };
+    export { srlSrc };
+    export { srlAssets };
+    export { srlEntries };
+    export { ld };
+}
+export default _default;

package/scripts/folders.js

@@ -0,0 +1,46 @@
+import { join } from 'path/posix';
+import { packageName as configPackageName } from './config.js';
+
+export const root = process.cwd();
+export const packageName = join(...configPackageName.split('/'));
+export const packagePath = join(root, 'node_modules', packageName);
+export const packageSrl = join(packagePath, 'srl');
+export const packageLd = join(packagePath, 'livingdocs');
+export const srlRoot = join(root, '.srl');
+export const srlSystem = join(srlRoot, 'srl');
+export const srlComponents = join(srlRoot, 'components');
+export const srlComposables = join(srlRoot, 'composables');
+export const srlUtils = join(srlRoot, 'utils');
+export const srlPlugins = join(srlRoot, 'plugins');
+export const srlScss = join(srlRoot, 'scss');
+export const srlImports = join(srlRoot, 'imports');
+export const srlTypes = join(srlRoot, 'types');
+export const srlOutput = join(root, '.output');
+export const srlPublic = join(root, 'public');
+export const srlSrc = join(root, 'src');
+export const srlAssets = join(srlSrc, 'assets');
+export const srlEntries = join(srlSrc, 'entries');
+export const ld = join(root, 'livingdocs');
+
+export default {
+  root,
+  packageName,
+  packagePath,
+  packageSrl,
+  packageLd,
+  srlRoot,
+  srlSystem,
+  srlComponents,
+  srlComposables,
+  srlUtils,
+  srlPlugins,
+  srlScss,
+  srlImports,
+  srlTypes,
+  srlOutput,
+  srlPublic,
+  srlSrc,
+  srlAssets,
+  srlEntries,
+  ld,
+};

package/scripts/init.js

@@ -1,14 +1,17 @@
-import { resolve, dirname } from 'node:path';
+import { dirname, join } from 'node:path';
 import fs from 'fs-extra';
-import { statSync, readFileSync, writeFileSync } from 'node:fs';
+import { statSync, readFileSync, writeFileSync, cpSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
-import writeJson from 'write-json';
+import { baseComponentsToInstall } from './config.js';
 
 const require = createRequire(import.meta.url);
 
+const { Input } = require('enquirer');
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+
 /**
  * Initializes a new project in the given folder with the provided options.
  *
@@ -18,22 +21,39 @@ const __dirname = dirname(__filename);
  * @return {Promise<void>} - A promise that resolves when the project initialization is complete.
  */
 async function init(folder, options) {
-  const projectPath = resolve(process.cwd(), folder);
+  const prompt = new Input({
+    message: 'Project name',
+    initial: folder,
+  });
+  let projectName = await prompt.run();
+  if (projectName === '') {
+    projectName = folder;
+  }
+
+  const projectPath = join(process.cwd(), folder);
 
   try {
     const stat = statSync(projectPath);
     console.error(`Folder ${projectPath} already exist!`);
   } catch (e) {
-    await fs.copy(resolve(__dirname, '../dev/'), projectPath).then(async () => {
-      const packageJsonFile = `${projectPath}/package.json`;
+    await fs.copy(join(__dirname, '..', 'dev'), projectPath).then(async () => {
+      const packageJsonFile = join(projectPath, 'package.json');
       const packageJson = JSON.parse(await readFileSync(packageJsonFile));
-      packageJson.name = folder;
+      packageJson.name = projectName;
       const writeJson = require('write-json');
       writeJson.sync(packageJsonFile, packageJson);
 
+      baseComponentsToInstall.forEach((component) => {
+        cpSync(
+          join(__dirname, '..', 'livingdocs', ...component.split('/')),
+          join(projectPath, 'livingdocs', ...component.split('/')),
+          { recursive: true, force: true },
+        );
+      });
+
       await writeFileSync(
         `${projectPath}/.gitignore`,
-        `/.output/\n/.nswow/\n/node_modules/\n/public/downloads/\n/public/html/\n/public/images/\n/public/json/\n/public/exclude/\n/dev-dist/`,
+        `/.output/\n/.srl/\n/node_modules/\n/public/downloads/\n/public/html/\n/public/images/\n/public/json/\n/public/exclude/\n/dev-dist/`,
       );
       console.log(`Project has created`);
       console.log(`cd ${folder}`);

package/scripts/ldd/LivingdocsDesignValidator.d.ts

@@ -0,0 +1,61 @@
+export default LivingdocsDesignValidator;
+export class LivingdocsDesignValidator {
+    /**
+     *
+     */
+    constructor(lddDesign: any);
+    lddDesign: any;
+    /**
+     *
+     * @returns {boolean} wether or not a design is valid
+     */
+    IsDesignValid(): boolean;
+    /**
+     * Test if all component properties are declared
+     * @returns {boolean}
+     */
+    usedPropertiesAreDeclared(): boolean;
+    /**
+     * Test if each components belong to at least one group
+     * @returns {boolean}
+     */
+    everyComponentHasAGroup(): boolean;
+    /**
+     * Test if there are any duplicate component names
+     * @returns {boolean}
+     */
+    hasNoDuplicateComponentNames(): boolean;
+    /**
+     * Test if there are any duplicate groups
+     * @returns {boolean}
+     */
+    hasNoDuplicateGroupLabels(): boolean;
+    /**
+     * Test if any component uses a declared property, log a warning if unused
+     * @returns {void}
+     */
+    allComponentPropertiesAreUsed(): void;
+    /**
+     * Test if every doc-directive and json declaration exist
+     * common user failures are:
+     * - duplicate directive value
+     * - diplicate usage of doc-link
+     * - declared but not used directive value
+     * - allowedChildren component/s do not exist
+     * - defaultContent component does not exist
+     * @returns {boolean}
+     */
+    everyDeclaredDirectiveExistsOnComponent(): boolean;
+    delcaredDirectivesExistsOnComponent(component: any): boolean;
+    /**
+     *
+     * @returns {boolean} true when parents exist
+     */
+    everyAllowedParentExistsInDesign(): boolean;
+    /**
+     * Test if referenced defaultContent and allowedChildren exist
+     * @param {object} directive
+     * @returns {boolean}
+     */
+    _checkContainerDirective(directive: object): boolean;
+}