@simple-reporting/base 0.1.111 → 1.0.0

package/scripts/ldd/mapLdd.js

@@ -0,0 +1,204 @@
+import { join } from 'node:path/posix';
+import { glob, globSync } from 'glob';
+import { createRequire } from 'node:module';
+import folders from '../folders.js';
+import {
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import {
+  lddGroupNames,
+  readLivingDocsJson,
+  writeLivingDocsJson,
+} from '../utils.js';
+import { createLogger } from 'vite';
+
+const logger = createLogger();
+const require = createRequire(import.meta.url);
+
+export async function mapLdd() {
+  const lddJson = await readLivingDocsJson();
+
+  await mapGroups(lddJson);
+  await mapComponents(lddJson);
+  await mapProperties(lddJson);
+
+  await writeLivingDocsJson();
+}
+
+/**
+ * map all properties.{json,js,ts} declarations
+ * @returns {Promise<void>}
+ */
+async function mapProperties(lddJson) {
+  const propertiesFiles = await glob(
+    join(folders.ld, '**', '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;
+}
+
+/**
+ * map group / component folder structure to design configuration
+ * @param {*} lddJson
+ * @returns
+ */
+async function mapGroups(lddJson) {
+  const groupsPath = folders.ld;
+  const groups = readdirSync(groupsPath);
+
+  lddJson.groups = [];
+
+  for (let x = 0; x < groups.length; x++) {
+    const group = groups[x];
+    const groupName = lddGroupNames(group);
+
+    try {
+      const groupFolderPath = join(groupsPath, group);
+      const stat = statSync(groupFolderPath);
+
+      if (stat.isDirectory()) {
+        const components = getGroupComponents(groupFolderPath);
+          lddJson.groups.push({
+            label: groupName,
+            components: components,
+          });
+      } else {
+        rmSync(groupFolderPath);
+      }
+    } catch (error) {
+      logger.error(e);
+      return false;
+    }
+  }
+}
+
+/**
+ * load and map all ld-conf.json + component.html to component configuration
+ * @param {path} groupFolderPath
+ * @returns {string[]}
+ */
+function getGroupComponents(groupFolderPath) {
+  const componentFolders = readdirSync(groupFolderPath);
+  const components = [];
+
+  for (let j = 0; j < componentFolders.length; j++) {
+    const component = componentFolders[j];
+
+    try {
+      const htmlPath = globSync(join(groupFolderPath, component, `*.html`));
+      const ldConfPath = join(groupFolderPath, component, `ld-conf.json`);
+
+      const htmlStat = statSync(htmlPath[0]);
+      const ldConfStat = statSync(ldConfPath);
+
+      const arrComponent = component.split('.');
+      if (arrComponent.length > 1) {
+        arrComponent.shift()
+      }
+      components.push(arrComponent.join('.'));
+    } catch (e) {}
+  }
+
+  return components;
+}
+
+async function mapComponents(lddJson) {
+  const groupsPath = folders.ld;
+  const groups = readdirSync(groupsPath);
+
+  const lddComponents = [];
+  const vueComponents = [];
+
+  for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+    const group = groups[groupIndex];
+
+    const groupPath = join(groupsPath, group);
+    const components = readdirSync(groupPath);
+
+    components.forEach((component) => {
+      // ldd static component
+      try {
+        const htmlFile =  globSync(join(groupPath, component, '*.html'));
+        if (htmlFile.length) {
+          const htmlPath = htmlFile[0];
+          const ldConfPath = join(groupPath, component, `ld-conf.json`);
+          const ldConfStat = statSync(ldConfPath);
+
+          const componentDeclaration = JSON.parse(
+            readFileSync(ldConfPath, { encoding: 'utf-8' }),
+          );
+          const componentHtml = readFileSync(htmlPath, { encoding: 'utf-8' });
+
+          lddComponents.push({ ...componentDeclaration, html: componentHtml });
+        }
+      } catch (error) {}
+
+      //   vue async component
+      try {
+        const vueFiles = globSync(join(groupPath, component, '*.vue'));
+        if (vueFiles.length) {
+          vueFiles.forEach( c => {
+            const vueName = c.split('/').pop().substring(0, -4);
+            vueComponents.push({
+              name: `SrlLd${toUpperCamelCase(vueName)}`,
+              path: join('#ld', group, component, `${vueName}.vue`),
+            });
+          })
+        }
+      } catch (error) {}
+    });
+  }
+
+  // write ldd components
+  lddJson.components = lddComponents;
+
+  // write async components
+  const asyncComponents = [
+    `import { defineAsyncComponent } from 'vue'`,
+    `export default function asyncLdComponent(app) {`,
+  ];
+
+  for (let i = 0; i < vueComponents.length; i++) {
+    const component = vueComponents[i];
+    asyncComponents.push(
+      ` app.component('${component.name}', defineAsyncComponent(() => import('${component.path}')))`,
+    );
+  }
+
+  asyncComponents.push('}');
+
+  writeFileSync(
+    join(folders.srlPlugins, 'asyncLdComponent.ts'),
+    asyncComponents.join('\n'),
+  );
+}
+
+function toUpperCamelCase(input) {
+  return input
+    .split('-')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}

package/scripts/prepare.d.ts

@@ -0,0 +1,2 @@
+export default prepare;
+declare function prepare(): void;

package/scripts/prepare.js

@@ -0,0 +1,66 @@
+import folders from './folders.js';
+import fs from 'fs';
+import path from 'path/posix';
+
+const tsConfigIncludes = [
+  '.srl/**/*',
+  '.srl/**/*.d.ts',
+  '.srl/**/*.vue',
+  'livingdocs/**/*',
+  'livingdocs/**/*.vue',
+];
+
+const tsConfigPaths = {
+  '@/*': ['./src/*'],
+  '~/*': ['./*'],
+  '#srl': ['./.srl'],
+  '#srl/*': ['./.srl/*'],
+  '#components': ['./.srl/components'],
+  '#components/*': ['./.srl/components/*'],
+  '#composables': ['./.srl/composables'],
+  '#composables/*': ['./.srl/composables/*'],
+  '#utils': ['./.srl/utils'],
+  '#utils/*': ['./.srl/utils/*'],
+  '#plugins': ['./.srl/plugins'],
+  '#plugins/*': ['./.srl/plugins/*'],
+  '#types': ['./.srl/types'],
+  '#types/*': ['./.srl/types/*'],
+  '#imports': ['./.srl/imports'],
+  '#imports/*': ['./.srl/imports/*'],
+  '#ld': ['./livingdocs'],
+  '#ld/*': ['./livingdocs/*'],
+  assets: ['./src/assets'],
+  'assets/*': ['./src/assets/*'],
+  srl: ['./.srl/srl'],
+  'srl/*': ['./.srl/srl/*'],
+};
+
+function prepare() {
+  if (fs.existsSync(folders.srlRoot)) {
+    fs.rmSync(folders.srlRoot, { recursive: true, force: true });
+  }
+  fs.cpSync(folders.packageSrl, folders.srlRoot, { recursive: true });
+
+  const tsConfigPath = path.join(folders.root, 'tsconfig.app.json');
+  if (fs.existsSync(tsConfigPath)) {
+    const tsConfig = JSON.parse(fs.readFileSync(tsConfigPath, 'utf-8'));
+
+    const mergedIncludes = [
+      ...(tsConfig.include || []),
+      ...tsConfigIncludes.filter((i) => !(tsConfig.include || []).includes(i)),
+    ];
+    tsConfig.include = tsConfig.include || [];
+    tsConfig.include = mergedIncludes;
+
+    const mergedPaths = {
+      ...(tsConfig.compilerOptions?.paths || {}),
+      ...tsConfigPaths,
+    };
+    tsConfig.compilerOptions = tsConfig.compilerOptions || {};
+    tsConfig.compilerOptions.paths = mergedPaths;
+
+    fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2));
+  }
+}
+
+export default prepare;

package/scripts/preparePublish.d.ts

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

package/scripts/preparePublish.js

@@ -1,88 +1,121 @@
-import { join } from 'node:path/posix';
-import { readFileSync, writeFileSync, rmSync } from 'node:fs';
-import { globSync } from 'glob';
-import writeJson from 'write-json';
-import ts from 'typescript';
-import Enquirer from 'enquirer';
-import { packageName } from './config.js';
-
-const { Input } = Enquirer;
-
-async function compile(fileNames, options) {
-  // Create a Program with an in-memory emit
-  const createdFiles = {};
-  const host = ts.createCompilerHost(options);
-  host.writeFile = (fileName, contents) => (createdFiles[fileName] = contents);
-
-  // Prepare and emit the d.ts files
-  const program = ts.createProgram(fileNames, options, host);
-  program.emit();
-
-  for (const file in createdFiles) {
-    const content = createdFiles[file];
-    await writeFileSync(file, content);
-  }
-}
-
-export async function preparePublish(version) {
-
-  if (version) {
-    const packageJson = JSON.parse(
-      await readFileSync(join(process.cwd(), 'package.json')),
-    );
-    packageJson.version = version;
-    await writeJson(join(process.cwd(), 'package.json'), packageJson);
-
-    const devJson = JSON.parse(
-      await readFileSync(join(process.cwd(), 'dev', 'package.json')),
-    );
-    devJson.dependencies[packageName] = `^${version}`;
-    await writeJson(join(process.cwd(), 'dev', 'package.json'), devJson);
-  }
-
-  const typescriptFiles = await globSync(
-    join(process.cwd(), 'scripts', '**', '*.d.ts'),
-  );
-  for (let i = 0; i < typescriptFiles.length; i++) {
-    await rmSync(typescriptFiles[i]);
-  }
-
-  const jsFiles = await globSync(join(process.cwd(), 'scripts', '**', '*.js'));
-
-  await compile(jsFiles, {
-    allowJs: true,
-    declaration: true,
-    emitDeclarationOnly: true,
-  });
-
-  const vueComponents = await globSync(
-    join(process.cwd(), 'src', '**', '*.vue'),
-  );
-  await compile(vueComponents, {
-    allowJs: true,
-    declaration: true,
-    emitDeclarationOnly: true,
-  });
-
-  return version;
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  try {
-    let version = null;
-    const indexVersion = process.argv.indexOf('-v');
-    if (indexVersion !== -1 && process.argv[indexVersion + 1]) {
-      const newVersion = process.argv[indexVersion + 1];
-      if (/^\d+\.\d+\.\d+$/.test(newVersion)) {
-        version = newVersion;
-      } else {
-        throw new Error(
-          `Invalid version format ${newVersion}. Use $number.$number.$number`,
-        );
-      }
-    }
-    preparePublish(version);
-  } catch (error) {
-    console.error(error);
-  }
-}
+import { join } from 'node:path/posix';
+import { readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { globSync } from 'glob';
+import writeJson from 'write-json';
+import ts from 'typescript';
+import Enquirer from 'enquirer';
+import { packageName } from './config.js';
+import { getPackageVersion } from './utils.js';
+
+const { Input } = Enquirer;
+
+async function compile(fileNames, options) {
+  // Create a Program with an in-memory emit
+  const createdFiles = {};
+  const host = ts.createCompilerHost(options);
+  host.writeFile = (fileName, contents) => (createdFiles[fileName] = contents);
+
+  // Prepare and emit the d.ts files
+  const program = ts.createProgram(fileNames, options, host);
+  program.emit();
+
+  for (const file in createdFiles) {
+    const content = createdFiles[file];
+    await writeFileSync(file, content);
+  }
+}
+
+export async function preparePublish(version = null) {
+  try {
+    if (version === null) {
+      const packageVersion = await getPackageVersion(packageName);
+
+      const currentVersion = packageVersion.split('.');
+      let major = parseInt(currentVersion[0]);
+      let minor = parseInt(currentVersion[1]);
+      let patch = parseInt(currentVersion[2]);
+
+      if (process.argv.includes('major')) {
+        major++;
+        minor = 0;
+        patch = 0;
+      } else if (process.argv.includes('minor')) {
+        minor++;
+        patch = 0;
+      } else {
+        patch++;
+      }
+
+      version = `${major}.${minor}.${patch}`;
+
+      const prompt = new Input({
+        message: 'Package version',
+        initial: version,
+      });
+      version = await prompt.run();
+    }
+  } catch (error) {
+    console.error('Error during preparePublish:', error);
+    return;
+  }
+
+  if (version) {
+    const packageJson = JSON.parse(
+      await readFileSync(join(process.cwd(), 'package.json')),
+    );
+    packageJson.version = version;
+    await writeJson(join(process.cwd(), 'package.json'), packageJson);
+
+    const devJson = JSON.parse(
+      await readFileSync(join(process.cwd(), 'dev', 'package.json')),
+    );
+    devJson.dependencies[packageName] = `^${version}`;
+    await writeJson(join(process.cwd(), 'dev', 'package.json'), devJson);
+  }
+
+  const typescriptFiles = await globSync(
+    join(process.cwd(), 'scripts', '**', '*.d.ts'),
+  );
+  for (let i = 0; i < typescriptFiles.length; i++) {
+    await rmSync(typescriptFiles[i]);
+  }
+
+  const jsFiles = await globSync(join(process.cwd(), 'scripts', '**', '*.js'));
+
+  await compile(jsFiles, {
+    allowJs: true,
+    declaration: true,
+    emitDeclarationOnly: true,
+  });
+
+  const vueComponents = await globSync(
+    join(process.cwd(), 'src', '**', '*.vue'),
+  );
+  await compile(vueComponents, {
+    allowJs: true,
+    declaration: true,
+    emitDeclarationOnly: true,
+  });
+
+  return version;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  try {
+    let version = null;
+    const indexVersion = process.argv.indexOf('-v');
+    if (indexVersion !== -1 && process.argv[indexVersion + 1]) {
+      const newVersion = process.argv[indexVersion + 1];
+      if (/^\d+\.\d+\.\d+$/.test(newVersion)) {
+        version = newVersion;
+      } else {
+        throw new Error(
+          `Invalid version format ${newVersion}. Use $number.$number.$number`,
+        );
+      }
+    }
+    preparePublish(version);
+  } catch (error) {
+    console.error(error);
+  }
+}

package/scripts/renamePackage.js

@@ -1,48 +1,48 @@
-import fs from 'fs';
-import path from 'path';
-
-const search = '@multivisio/nswow';
-const replace = '@simple-reporting/base';
-const CWD = process.cwd();
-const excludes = [
-  'scripts/renamePackage.js',
-  'scripts/renamePackage.d.ts',
-  '.git',
-  'node_modules',
-  'test-data',
-];
-
-const excludePaths = [...excludes.map((f) => path.join(CWD, ...f.split('/')))];
-
-function replaceInFile(filePath) {
-  const content = fs.readFileSync(filePath, 'utf8');
-  if (content.includes(search)) {
-    const newContent = content.split(search).join(replace);
-    fs.writeFileSync(filePath, newContent, 'utf8');
-    console.log(`Replaced in: ${filePath}`);
-  }
-}
-
-function walkDir(dir) {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path.join(dir, entry.name);
-    if (excludePaths.includes(fullPath)) continue;
-    if (entry.isDirectory()) {
-      console.log(fullPath);
-      walkDir(fullPath);
-    } else if (entry.isFile()) {
-      console.log(fullPath);
-      replaceInFile(fullPath);
-    }
-  }
-}
-
-export function renamePackages(startDir = process.cwd()) {
-  console.log(`Starting to rename packages from "${search}" to "${replace}"`);
-  walkDir(startDir);
-  console.log('Done!');
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  renamePackages();
-}
+import fs from 'fs';
+import path from 'path';
+
+const search = '@multivisio/nswow';
+const replace = '@simple-reporting/base';
+const CWD = process.cwd();
+const excludes = [
+  'scripts/renamePackage.js',
+  'scripts/renamePackage.d.ts',
+  '.git',
+  'node_modules',
+  'test-data',
+];
+
+const excludePaths = [...excludes.map((f) => path.join(CWD, ...f.split('/')))];
+
+function replaceInFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  if (content.includes(search)) {
+    const newContent = content.split(search).join(replace);
+    fs.writeFileSync(filePath, newContent, 'utf8');
+    console.log(`Replaced in: ${filePath}`);
+  }
+}
+
+function walkDir(dir) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (excludePaths.includes(fullPath)) continue;
+    if (entry.isDirectory()) {
+      console.log(fullPath);
+      walkDir(fullPath);
+    } else if (entry.isFile()) {
+      console.log(fullPath);
+      replaceInFile(fullPath);
+    }
+  }
+}
+
+export function renamePackages(startDir = process.cwd()) {
+  console.log(`Starting to rename packages from "${search}" to "${replace}"`);
+  walkDir(startDir);
+  console.log('Done!');
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  renamePackages();
+}