@simple-reporting/base 0.0.1

package/scripts/migrate-livingdocs-build/dev/lib.js

@@ -0,0 +1,251 @@
+import fs from 'fs';
+import { globbySync } from 'globby';
+import logger from './logger.js';
+
+const bFileExists = (path) => {
+  return fs.existsSync(path);
+};
+
+function getAllComponentPaths(componentPath) {
+  const files = globbySync(componentPath);
+  return files;
+}
+
+function removeFolder(path) {
+  if (bFileExists(path)) {
+    fs.rmSync(path, { recursive: true });
+  }
+}
+
+function removeFile(path) {
+  if (bFileExists(path)) {
+    fs.rmSync(path);
+  }
+}
+
+function minifyHtml(s) {
+  return s
+    ? s
+        .replace(/\>[\r\n ]+\</g, '><') // Removes new lines and irrelevant spaces which might affect layout, and are better gone
+        .replace(/(<.*?>)|\s+/g, (m, $1) => ($1 ? $1 : ' '))
+        .trim()
+    : '';
+}
+
+function testComponentExistV1(designData, components) {
+  const componentNames = components.map(
+    (component) => component.configurationData.name,
+  );
+  designData.groups.forEach((componentGroup) => {
+    componentGroup.components.forEach((c) => {
+      if (!componentNames.includes(c)) {
+        throw {
+          message: `component "${c}" in componentGroup "${componentGroup.label}" does not exist`,
+        };
+      }
+    });
+  });
+}
+
+function testComponentExistV2(designData, components) {
+  designData.designSettings.componentGroups.forEach((componentGroup) => {
+    componentGroup.components.forEach((componentName) => {
+      if (
+        !components.find((component) => {
+          return component.configurationData.name === componentName;
+        })
+      ) {
+        throw {
+          message: `component "${componentName}" in componentGroup "${componentGroup.label}" does not exist`,
+        };
+      }
+    });
+  });
+
+  return true;
+}
+
+function testPropertyExistV1(designData, components) {
+  const allProperties = Object.keys(designData.componentProperties);
+
+  for (let index = 0; index < components.length; index++) {
+    const component = components[index];
+
+    if (
+      component.configurationData.properties &&
+      component.configurationData.properties.length > 0
+    ) {
+      component.configurationData.properties.forEach((cProperty) => {
+        if (!allProperties.includes(cProperty)) {
+          throw {
+            message: `property "${cProperty}" in component "${component.configurationData.name}" is not present in design`,
+          };
+        }
+      });
+    }
+  }
+}
+
+function testPropertyExistV2(designData, components) {
+  const allProperties = designData.designSettings.componentProperties.map(
+    (p) => p.name,
+  );
+  for (let index = 0; index < components.length; index++) {
+    const component = components[index];
+
+    if (
+      component.configurationData.properties &&
+      component.configurationData.properties.length > 0
+    ) {
+      component.configurationData.properties.forEach((cProperty) => {
+        if (!allProperties.includes(cProperty)) {
+          throw {
+            message: `property "${cProperty}" in component "${component.configurationData.name}" is not present in design`,
+          };
+        }
+      });
+    }
+  }
+}
+
+function testComponentsAllUsedV1(designData, components) {
+  const componentGroupComponents = [
+    ...designData.groups.map((componentGroup) => componentGroup.components),
+  ].flat(1);
+
+  components.forEach((component) => {
+    if (
+      !componentGroupComponents.find(
+        (c) => c === component.configurationData.name,
+      )
+    ) {
+      logger.warn(
+        `component ${component.path} is unused in config.json, will not be packed into zip`,
+      );
+    }
+  });
+}
+
+function testComponentsAllUsedV2(designData, components) {
+  const componentGroupComponents = [
+    ...designData.designSettings.componentGroups.map(
+      (componentGroup) => componentGroup.components,
+    ),
+  ].flat(1);
+
+  components.forEach((component) => {
+    if (
+      !componentGroupComponents.find(
+        (c) => c === component.configurationData.name,
+      )
+    ) {
+      logger.warn(
+        `component ${component.path} is unused in config.json, will not be packed into zip`,
+      );
+    }
+  });
+}
+
+function testDesignPropertiesV1(designData, components) {
+  Object.keys(designData.componentProperties).forEach((componentProperty) => {
+    if (!propertyExistInComponentsV1(componentProperty, components)) {
+      logger.info(`property "${componentProperty}" is never used`);
+    }
+  });
+}
+
+function testDesignPropertiesV2(designData, components) {
+  designData.designSettings.componentProperties.forEach((componentProperty) => {
+    if (!propertyExistInComponentsV2(componentProperty.name, components)) {
+      logger.info(`property "${componentProperty.name}" is never used`);
+    }
+  });
+}
+
+function propertyExistInComponentsV1(property, components) {
+  for (let index = 0; index < components.length; index++) {
+    const component = components[index];
+    if (
+      component.configurationData.properties &&
+      component.configurationData.properties.includes(property)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function propertyExistInComponentsV2(property, components) {
+  for (let index = 0; index < components.length; index++) {
+    const component = components[index];
+    if (
+      component.configurationData.properties &&
+      component.configurationData.properties.includes(property)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function mergeDesignV1(designData, components) {
+  const newDesignData = JSON.parse(JSON.stringify(designData));
+  const designComponents = designData.groups
+    .map((componentGroup) => componentGroup.components)
+    .flat(1);
+
+  newDesignData.components = components
+    .filter((component) => {
+      return designComponents.includes(component.configurationData.name);
+    })
+    .map((component) => {
+      return {
+        ...component.configurationData,
+        html: minifyHtml(component.html),
+      };
+    });
+
+  return newDesignData;
+}
+
+function mergeDesignV2(designData, components) {
+  const newDesignData = JSON.parse(JSON.stringify(designData));
+  const designComponents = designData.designSettings.componentGroups
+    .map((componentGroup) => componentGroup.components)
+    .flat(1);
+
+  newDesignData.components = components
+    .filter((component) => {
+      return designComponents.includes(component.configurationData.name);
+    })
+    .map((component) => {
+      return {
+        ...component.configurationData,
+        html: minifyHtml(component.html),
+      };
+    });
+
+  return newDesignData;
+}
+
+const lib = {
+  bFileExists,
+  removeFolder,
+  removeFile,
+  getAllComponentPaths,
+  minifyHtml,
+  mergeDesignV1,
+  mergeDesignV2,
+  testComponentExistV1,
+  testComponentExistV2,
+  testPropertyExistV1,
+  testPropertyExistV2,
+  testComponentsAllUsedV1,
+  testComponentsAllUsedV2,
+  testDesignPropertiesV1,
+  testDesignPropertiesV2,
+};
+
+export default lib;

package/scripts/migrate-livingdocs-build/dev/livingdocs-design.d.ts

@@ -0,0 +1,9 @@
+export default LivingdocsDesign;
+declare class LivingdocsDesign {
+    static loadDesign(configuration: any): any;
+    static loadComponents(configuration: any): {
+        path: string;
+        configurationData: any;
+        html: string;
+    }[];
+}

package/scripts/migrate-livingdocs-build/dev/livingdocs-design.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import lib from './lib.js';
+import logger from './logger.js';
+import * as cheerio from 'cheerio';
+
+class LivingdocsDesign {
+  static loadDesign(configuration) {
+    logger.debug('loading design ' + configuration.build.design);
+    if (!lib.bFileExists(configuration.build.design)) {
+      throw {
+        message: 'design not found at ' + configuration.build.design,
+      };
+    }
+
+    try {
+      const designJSON = JSON.parse(
+        fs.readFileSync(configuration.build.design, {
+          encoding: 'utf8',
+          flag: 'r',
+        }),
+      );
+
+      return designJSON;
+    } catch (error) {
+      throw {
+        message: 'design could not be loaded at ' + configuration.build.design,
+        error: error,
+      };
+    }
+  }
+
+  static loadComponents(configuration) {
+    logger.debug('loading components ' + configuration.build.components);
+    const componentPaths = lib.getAllComponentPaths(
+      configuration.build.components,
+    );
+    const components = [];
+
+    for (let index = 0; index < componentPaths.length; index++) {
+      const path = componentPaths[index];
+
+      const raw = fs.readFileSync(path);
+
+      const htmlObj = cheerio.load(raw.toString());
+      let configurationData = null;
+
+      // check component configuration for syntax errors
+      try {
+        configurationData = JSON.parse(
+          htmlObj(configuration.configurationSelector).html(),
+        );
+      } catch (error) {
+        throw {
+          message: `JSON error in component ${path}`,
+        };
+      }
+
+      htmlObj(configuration.configurationSelector).remove();
+
+      const children = htmlObj('body > *:not(script)');
+
+      // check html for children count
+      if (children.length === 1) {
+        components.push({
+          path: path,
+          configurationData: configurationData,
+          html: htmlObj.html(children[0]),
+        });
+      } else {
+        throw {
+          message: `template ${path} contains ${children.length} root elements. Components only work with one root element.`,
+        };
+      }
+    }
+
+    return components;
+  }
+}
+
+export default LivingdocsDesign;

package/scripts/migrate-livingdocs-build/dev/logger.d.ts

@@ -0,0 +1,2 @@
+export default logger;
+declare const logger: any;

package/scripts/migrate-livingdocs-build/dev/logger.js

@@ -0,0 +1,16 @@
+import winston from 'winston';
+
+const logger = winston.createLogger({
+  level: 'debug',
+  format: winston.format.json(),
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple(),
+      ),
+    }),
+  ],
+});
+
+export default logger;

package/scripts/migrate-livingdocs-build/dev/migrate.d.ts

@@ -0,0 +1,22 @@
+export default Migrate;
+declare class Migrate {
+    static migrateDesign(oldDesignData: any): {
+        v: number;
+        name: string;
+        version: string;
+        designSettings: {
+            componentProperties: any[];
+            defaultComponents: {};
+            prefilledComponents: {};
+            componentGroups: any[];
+            fieldExtractor: {};
+        };
+    };
+    static migrateComponentProperties(oldProperties: any): any[];
+    static migrateComponents(components: any): any;
+    static getDirectiveType(directive: any, componentPath: any, directiveKey: any): "include" | "" | "image" | "editable" | "container";
+    static writeDesign(newDesign: any): void;
+    static writeComponents(newComponents: any): void;
+    static makeComponentFileString(component: any): string;
+    static writeManualReviews(): void;
+}

package/scripts/migrate-livingdocs-build/dev/migrate.js

@@ -0,0 +1,241 @@
+import configuration from './configuration.js';
+import lib from './lib.js';
+import logger from './logger.js';
+import fs from 'fs';
+
+const migrationManualReviews = [];
+
+class Migrate {
+  static migrateDesign(oldDesignData) {
+    let newDesignData = {
+      v: 2,
+      name: '',
+      version: '',
+      designSettings: {
+        componentProperties: [],
+        defaultComponents: {},
+        prefilledComponents: {},
+        componentGroups: [],
+        fieldExtractor: {},
+      },
+    };
+
+    // mapping
+    newDesignData.name = oldDesignData.name;
+    newDesignData.version = oldDesignData.version;
+
+    newDesignData.designSettings.assets = oldDesignData.assets;
+    newDesignData.designSettings.componentProperties =
+      this.migrateComponentProperties(oldDesignData.componentProperties);
+    newDesignData.designSettings.defaultComponents =
+      oldDesignData.defaultComponents;
+    newDesignData.designSettings.prefilledComponents =
+      oldDesignData.prefilledComponents;
+    newDesignData.designSettings.componentGroups = oldDesignData.groups;
+    newDesignData.designSettings.fieldExtractor = oldDesignData.metadata;
+    newDesignData.designSettings.defaultComponents =
+      oldDesignData.defaultComponents;
+
+    // delete removed properties
+    delete oldDesignData.label;
+    delete oldDesignData.license;
+    delete oldDesignData.description;
+    delete oldDesignData.author;
+    delete oldDesignData.imageRatios;
+    delete oldDesignData.defaultLayout;
+
+    // delete already moved properties
+    delete oldDesignData.name;
+    delete oldDesignData.version;
+    delete oldDesignData.assets;
+    delete oldDesignData.componentProperties;
+    delete oldDesignData.defaultComponents;
+    delete oldDesignData.prefilledComponents;
+    delete oldDesignData.groups;
+    delete oldDesignData.metadata;
+    delete oldDesignData.defaultComponents;
+    delete oldDesignData.defaultContent;
+
+    return newDesignData;
+  }
+
+  static migrateComponentProperties(oldProperties) {
+    const newProperties = [];
+
+    Object.keys(oldProperties).forEach((key) => {
+      newProperties.push({
+        name: key,
+        ...oldProperties[key],
+      });
+    });
+
+    return newProperties;
+  }
+
+  static migrateComponents(components) {
+    components.map((component) => {
+      const oldData = component.configurationData;
+      // clean copy the old Data
+      const newData = JSON.parse(JSON.stringify(oldData));
+
+      if (!!newData.directives) {
+        const directiveKeys = Object.keys(newData.directives);
+
+        let newDirectives = [];
+        if (directiveKeys) {
+          // remap directive object
+          directiveKeys.forEach((directiveKey) => {
+            const oldDirective = oldData.directives[directiveKey];
+
+            let newDirective = {
+              name: directiveKey,
+              ...oldDirective,
+            };
+
+            if (!newDirective.type) {
+              newDirective.type = this.getDirectiveType(
+                oldDirective,
+                component.path,
+                directiveKey,
+              );
+            }
+
+            if (newDirective.imageRatios) {
+              newDirective.imageRatios.forEach((imageRatio) => {
+                const regex = new RegExp(/[\d]{1,}\:[\d]{1,}/gm);
+                const regexResult = regex.test(imageRatio.trim());
+                if (!regexResult) {
+                  migrationManualReviews.push({
+                    path: component.path,
+                    directive: 'imageRatio:  ' + imageRatio + '  ',
+                  });
+                }
+              });
+
+              if (newDirective.allowOriginalRatio) {
+                newDirective.recommendedRatios = newDirective.imageRatios;
+                delete newDirective.imageRatios;
+              }
+
+              delete newDirective.allowOriginalRatio;
+            }
+
+            newDirectives.push(newDirective);
+          });
+        }
+
+        newData.directives = newDirectives;
+      }
+
+      component.configurationData = newData;
+
+      return component;
+    });
+
+    return components;
+  }
+
+  static getDirectiveType(directive, componentPath, directiveKey) {
+    if (
+      directive.allowedChildren ||
+      directive.defaultComponents ||
+      directive.defaultContent
+    ) {
+      return 'container';
+    } else if (
+      directive.plainText ||
+      directive.excludeFromTextCount ||
+      directive.maxLength ||
+      directive.recommendedMaxLength
+    ) {
+      return 'editable';
+    } else if (directive.imageRatios || directive.allowOriginalRatio) {
+      return 'image';
+    } else if (directive.service || directive.services) {
+      return 'include';
+    }
+
+    migrationManualReviews.push({
+      path: componentPath,
+      directive: directiveKey,
+    });
+
+    return '';
+  }
+
+  static writeDesign(newDesign) {
+    if (lib.bFileExists(configuration.migration.dest + '/config.json')) {
+      fs.rmSync(configuration.migration.dest + '/config.json');
+    }
+
+    fs.mkdirSync(configuration.migration.dest, { recursive: true });
+
+    fs.writeFileSync(
+      configuration.migration.dest + '/config.json',
+      JSON.stringify(newDesign, null, '\t'),
+      {
+        encoding: 'utf8',
+        flag: 'a+',
+        mode: 0o666,
+      },
+    );
+  }
+
+  static writeComponents(newComponents) {
+    newComponents.forEach((component) => {
+      const pathEndIndex = configuration.migration.components.indexOf('*');
+      const toReplace = configuration.migration.components.substring(
+        0,
+        pathEndIndex,
+      );
+      const newFullPath = component.path.replace(
+        toReplace,
+        configuration.migration.dest + '/components/',
+      );
+      const newPath = newFullPath.split('/');
+
+      newPath.splice(-1);
+
+      fs.mkdirSync(newPath.join('/'), { recursive: true });
+
+      fs.writeFileSync(newFullPath, this.makeComponentFileString(component));
+    });
+  }
+
+  static makeComponentFileString(component) {
+    let data = `<script type="ld-conf">\n${JSON.stringify(component.configurationData, null, '\t')}\n</script>\n`;
+    data += component.html;
+
+    return data;
+  }
+
+  static writeManualReviews() {
+    if (migrationManualReviews.length == 0) {
+      console.info('probably no manual reviews required');
+      return;
+    }
+
+    migrationManualReviews.forEach((review) => {
+      logger.warn(
+        `component ${review.path} directive ${review.directive} requires manual review`,
+      );
+    });
+
+    const textOutput = migrationManualReviews
+      .map(
+        (review) =>
+          `component ${review.path} directive ${review.directive} requires manual review`,
+      )
+      .join('\n');
+    fs.writeFileSync('./manual-review.txt', textOutput, {
+      encoding: 'utf8',
+      flag: 'a+',
+      mode: 0o666,
+    });
+    logger.warn(
+      `found [${migrationManualReviews.length}] issues, building a design without manual review will fail. ./manual-review.txt`,
+    );
+  }
+}
+
+export default Migrate;

package/scripts/migrate-livingdocs-build/readme.md

@@ -0,0 +1,62 @@
+# Installation
+
+    sudo npm i --location=global git@github.com:mmssolutionsio/migrate-livingdocs-build.git
+
+## Update
+
+    sudo npm update migrate-livingdocs-build --location=global
+
+# Usage
+
+## Node Version
+
+    at least "16.15.1"
+
+## Custom configuration
+
+default values which can be overwritten in package.json of the current ld project
+
+      {
+      "nhs-design-builder": {
+        "configurationSelector": "[type=\"ld-conf\"]",
+        "build": {
+          "design": "./src/config.json",
+          "components": "./src/components/**/*.html",
+          "requiredFolders": [
+            "./src/css",
+            "./src/fonts",
+            "./src/svg",
+            "./src/images"
+          ],
+          "dist": "./dist",
+          "dest": "./",
+          "archiveName": "design.zip"
+        },
+        "migration": {
+          "design": "./src/config.json",
+          "components": "./src/components/**/*.html",
+          "dest": "./design-v2",
+        }
+      }
+    }
+
+| prop                  | desc                                                  |
+| --------------------- | ----------------------------------------------------- |
+| configurationSelector | querySelector string for script tag in html component |
+| build.design          | location of base ld-design.json file                  |
+| build.components      | location of html templates                            |
+| build.requiredFolders | array of folders which are copied into the dist       |
+| build.dist            | dist folder, will be created and deleted              |
+| build.dest            | destination for the archive                           |
+| build.archiveName     | zipped design file name                               |
+| migration.design      | location of base ld-design.json file                  |
+| migration.components  | location of html templates                            |
+| dest                  | folder in which all migrated files will be written    |
+
+## Build
+
+cli command `nhs-ld-build` in ld project folder to make dist, build design and zip dist.
+
+## Migrate
+
+cli command `nhs-ld-migrate` in ld project folder to migrate html components and config.json, and write into a new location.

package/scripts/preparePublish.d.ts

@@ -0,0 +1 @@
+export function preparePublish(version: any): Promise<any>;