@skillswaveca/nova-shared-libraries 1.12.2

package/scripts/aggregate-docs.js

@@ -0,0 +1,81 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+
+// We have 2 docs locations, the base that stores the generic code, and the DOCS dir which stores the generated docs code.
+const DOCS_DIR = 'docs';
+const DOCS_BASE_DIR = 'docs-base';
+
+// This function copies files from source to target directory
+async function copyFiles(source, target) {
+  const filesToCopy = await fs.readdir(source);
+  await fs.mkdir(target, { recursive: true });
+  const promises = [];
+  for (const file of filesToCopy) {
+    const srcFile = path.join(source, file);
+    const destFile = path.join(target, file);
+    promises.push(fs.stat(srcFile).then(stat => {
+      if (stat.isDirectory()) {
+        return copyFiles(srcFile, destFile);
+      } else {
+        return fs.copyFile(srcFile, destFile);
+      }
+
+    }));
+  }
+  await Promise.all(promises);
+}
+
+/**
+ * This function generates package-info.js file in the docs folder by reading package.json files from the package folders
+ * @param {string[]} docsFolders - array of paths to the docs folders
+ * @returns {Promise<void>}
+ * */
+async function generatePackageInfo(docsFolders) {
+  const packageInfos = [];
+
+  for (const folder of docsFolders) {
+    const packageJsonPath = path.join(path.dirname(folder), 'package.json');
+    // eslint-disable-next-line no-await-in-loop
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    packageInfos.push({
+      name: packageJson.name,
+      version: packageJson.version,
+      description: packageJson.description,
+      docsPath: `./${path.basename(path.dirname(folder))}/index.html`,
+    });
+  }
+
+  const aggregatedDocsPath = path.resolve(process.cwd(), DOCS_BASE_DIR);
+  await fs.writeFile(path.join(aggregatedDocsPath, 'package-info.js'), `export const packageInfo = ${JSON.stringify(packageInfos, null, 2)};`);
+}
+
+/**
+ * This function copies all the docs folders to a single folder
+ * @param {string[]} docsFolders - array of paths to the docs folders
+ * @returns {Promise<void>}
+ * */
+async function copyDocsFolders(docsFolders) {
+  const aggregatedDir = path.resolve(process.cwd(), DOCS_DIR);
+  await fs.mkdir(aggregatedDir, { recursive: true });
+  console.log('Found docs folders:', docsFolders);
+  for (const folder of docsFolders) {
+    const packageName = path.basename(path.dirname(folder));
+    const targetDir = path.join(aggregatedDir, packageName);
+    copyFiles(folder, targetDir);
+    console.log(`Aggregated docs for ${packageName}`);
+  }
+}
+
+async function aggregateDocs() {
+  try {
+    const docsFolders = await glob('packages/*/docs/', { realpath: true });
+    await generatePackageInfo(docsFolders);
+    await copyDocsFolders(docsFolders);
+    console.log('All docs aggregated successfully.');
+  } catch (error) {
+    console.error('Error during docs aggregation:', error);
+  }
+}
+
+aggregateDocs();

package/scripts/bump-version.js

@@ -0,0 +1,26 @@
+import { readFile, writeFile } from 'fs/promises';
+
+// Path to the package.json file
+const packageJsonPath = 'package.json';
+
+// Read package.json file
+const data = await readFile(packageJsonPath, 'utf8');
+
+// Parse package.json content
+const packageJson = JSON.parse(data);
+
+// Check if the current version is an integer
+const currentVersion = parseInt(packageJson.version, 10);
+if (isNaN(currentVersion)) {
+  throw new Error('Version number in package.json is not a simple integer.');
+}
+
+// Increment the version number
+const newVersion = currentVersion + 1;
+
+// Update the version number in the package.json object
+packageJson.version = newVersion.toString();
+
+// Write the updated package.json back to file
+await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2) }\n`, 'utf8');
+console.log(newVersion);

package/scripts/create-index.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import path from 'path';
+import { glob } from 'glob';
+
+// This time we're looking for 'src' directories anywhere in the project
+const baseDir = './'; // Adjust this if your starting point is different
+const indexFile = './index.js';
+const globPattern = `${baseDir}/**/src/**/*.js`; // Matches JS files in any 'src' folder
+
+console.log(baseDir, indexFile, globPattern);
+async function generateExportLines() {
+  try {
+    const files = await glob(globPattern, { ignore: ['**/node_modules/**', '**/index.js'] });
+    return files.map(file => {
+      const relativePath = `./${ path.relative(baseDir, file).replace(/\\/g, '/').replace(/\.js$/, '')}`;
+      return `export * from '${relativePath}.js';`;
+    }).join('\n');
+  } catch (err) {
+    console.error('Error generating export lines:', err);
+    process.exit(1);
+  }
+}
+
+async function generateIndex() {
+  const exportLines = await generateExportLines();
+  fs.writeFileSync(indexFile, `${exportLines }\n`, { flag: 'w' }); // Overwrite existing index.js
+  console.log(`Index file generated at ${indexFile}`);
+}
+
+generateIndex();

package/scripts/create-library-template/README.md

@@ -0,0 +1,5 @@
+# {{packageName}}
+
+## Description
+{{packageDescription}}
+

package/scripts/create-library-template/package.json

@@ -0,0 +1,19 @@
+{
+  "type": "module",
+  "name": "{{packageName}}",
+  "description": "{{packageDescription}}",
+  "repository": "https://github.com/SkillsWave/nova-shared-libraries",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "create-index": "node ../../scripts/create-index.js",
+    "generate-docs": "documentation build src/** -f html -o docs",
+    "test": "mocha --parallel 'test/**/*.test.js'"
+  },
+  "author": "SkillsWave",
+  "license": "UNLICENSED",
+  "devDependencies": {
+  },
+  "dependencies": {
+  }
+}

package/scripts/create-library.js

@@ -0,0 +1,62 @@
+// Import necessary modules using ESM syntax
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+
+// Create readline interface
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+// Promise-based helper to read user input
+function question(query) {
+  return new Promise(resolve => {
+    rl.question(query, resolve);
+  });
+}
+
+// Function to copy directory contents recursively
+async function copyDir(src, dest, packageName, packageDescription) {
+  await fs.promises.mkdir(dest, { recursive: true });
+  const entries = await fs.promises.readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath, packageName, packageDescription);
+    } else {
+      await copyFile(srcPath, destPath, packageName, packageDescription);
+    }
+  }
+}
+
+// Function to copy a file and replace placeholders
+async function copyFile(src, dest, packageName, packageDescription) {
+  let content = await fs.promises.readFile(src, 'utf8');
+  content = content.replace(/{{packageName}}/g, packageName);
+  content = content.replace(/{{packageDescription}}/g, packageDescription);
+  await fs.promises.writeFile(dest, content, 'utf8');
+}
+
+// Main function to handle inputs and initiate copying
+async function main() {
+  const packageName = await question('Enter the package name: ');
+  const packageDescription = await question('Enter the package description: ');
+
+  const sourceDir = 'scripts/create-library-template';
+  const destinationDir = 'packages/' + packageName;
+
+  rl.close();
+  if (!fs.existsSync(sourceDir)) {
+    console.log(`The source directory "${sourceDir}" does not exist.`);
+    return;
+  }
+
+  await copyDir(sourceDir, destinationDir, packageName, packageDescription);
+  console.log(`Directory copied from "${sourceDir}" to "${destinationDir}" with placeholders replaced.`);
+}
+
+main();