@24i/bigscreen-sdk 0.9.9-alpha.2148 → 0.9.9-alpha.2150

package/utils/create-export-maps/src/createExportMaps.ts

@@ -0,0 +1,61 @@
+import { resolve } from 'path';
+import * as fs from 'fs';
+import packageJson from '../../../package.json';
+
+const packagesPath = resolve('./packages');
+
+const allExports: Record<string, string> = {};
+
+type ExportsDefinition = {
+    name: string,
+    entryPoints: Record<string, string>,
+};
+
+const handleExport = ({ name, entryPoints }: ExportsDefinition) => {
+    let hasRootExport = false;
+    Object.entries(entryPoints).forEach(([exportAlias, exportPath]) => {
+        if (exportAlias === '/') {
+            hasRootExport = true;
+            return;
+        }
+        const parsedAlias = `/${exportAlias}`;
+        allExports[`${name}${parsedAlias}`] = `${name}/${exportPath}`;
+    });
+    /**
+     * Typescript resolves aliases from top. Root export would overtake any other pathed export.
+     * Therefore root export has to be last in the generated list.
+     */
+    if (hasRootExport) {
+        allExports[name] = `${name}/${entryPoints['/']}`;
+    }
+};
+
+const loadAllExports = () => {
+    const fileNames = fs.readdirSync(packagesPath);
+    fileNames.forEach((fileName) => {
+        const packagePath = resolve(packagesPath, fileName);
+        const isDirectory = fs.lstatSync(packagePath).isDirectory();
+        if (isDirectory) {
+            const exportsPath = resolve(packagePath, 'exports.json');
+            if (fs.existsSync(exportsPath)) {
+                // eslint-disable-next-line import/no-dynamic-require, global-require
+                const exports = require(exportsPath);
+                handleExport(exports);
+            }
+        }
+    });
+};
+
+const createPackageJsonMapping = () => {
+    const exports: Record<string, string> = {};
+    Object.entries(allExports).forEach(([exportAlias, exportPath]) => {
+        exports[`./${exportAlias}`] = `./packages/${exportPath}`;
+    });
+    (packageJson.exports as Record<string, string>) = exports;
+    fs.writeFileSync(resolve('./package.json'), JSON.stringify(packageJson, null, 4));
+};
+
+export const createExportMaps = () => {
+    loadAllExports();
+    createPackageJsonMapping();
+};

package/utils/create-package/README.md

@@ -0,0 +1,40 @@
+---
+id: README
+title: Create Package
+hide_title: true
+sidebar_label: Create Package
+---
+
+# Package Initializer
+An initializer for packages in `SmartApps BIGscreen SDK` monorepo helps to set up 
+folder structure with basic config files like eslint, tsconfig etc.
+
+## Usage
+Originally designed as [npm initializer](https://docs.npmjs.com/cli/init#description),
+now degraded to the local script without any ambition to be published.
+
+Go to SmartApps BIGscreen SDK monorepo root folder and type:
+```
+$ npm run create-package -- <my-package-name>
+```
+You will be prompted for basic package information.
+
+## What it does
+1. Create folder `./packages/<my-package-name>`
+2. Guide you through a questionnaire to setup the project
+    * e.g. auto-suggested 24i package name in form: `@24i/smartapps-bigscreenen-<my-package-name>`
+3. Copy the template files (src, tsconfig, eslintrc, jest.config, readme, etc.)
+4. Generate package.json with all the project details
+5. Create symlink in docs `./docs/packages/<my-package-name>/README.md`
+
+## Motivation
+Every time that I start a new package inside SmartApps BIGscreen SDK monorepo, I hate 
+to go to other project folder, copy files like eslintrc, tsconfig, create folder
+structure, etc.
+
+With this in mind, the motivation to build this package started as a DRY (Do not
+repeat yourself) thing.
+
+This package is intended to automate the initialization of new packages and with 
+this have a new folder with everything ready to work. Behind this, also to ensure
+we are using the unified setup for each package inside SmartApps BIGscreen SDK monorepo.

package/utils/create-package/src/createPackage.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as fse from 'fs-extra';
+import chalk from 'chalk';
+import minimist from 'minimist';
+import { promptPackageDetails } from './questionnaire/questions';
+import { Settings } from './settings/Settings';
+import { IPackageOptions } from './types';
+
+async function isDirectoryEmpty(dirPath: string) {
+    const files = await fs.promises.readdir(dirPath);
+    return !files.length;
+}
+
+async function copyTemplateFiles(templateDir: string, targetDir: string) {
+    return fse.copy(templateDir, targetDir);
+}
+
+function updateExportsJsonFile(filePath: string, options: IPackageOptions) {
+    let data = fs.readFileSync(filePath, 'utf8');
+    data = data.replace(/("name": ")(.*)(")/, `$1${options.name}$3`);
+    fs.writeFileSync(filePath, data);
+}
+
+function parseArguments(rawArgv: Array<string>) {
+    const argv = minimist(rawArgv.slice(2));
+    const dirName = argv._[0];
+
+    if (!dirName) {
+        console.error('Error: Missing package name');
+        process.exit(1);
+    }
+
+    return {
+        dirName,
+    };
+}
+
+export async function main() {
+    const { dirName: destDirName } = parseArguments(process.argv);
+    const destDir = path.join(process.cwd(), 'packages/', destDirName);
+    if (fs.existsSync(destDir)) {
+        console.error(`Error: Target directory "${destDir}" already exists`);
+        process.exit(1);
+    }
+    fs.mkdirSync(destDir, { recursive: true });
+
+    const isDirEmpty = await isDirectoryEmpty(destDir);
+    if (!isDirEmpty) {
+        console.error(`Error: Target directory "${destDir}" is not empty.`);
+        process.exit(1);
+    }
+
+    const settings = { ...Settings };
+    settings.name = `${Settings.name}${destDirName}`.toLowerCase();
+
+    const details = await promptPackageDetails(settings);
+    const templateDir = path.join(__dirname, '..', 'templates/typescript');
+
+    await copyTemplateFiles(templateDir, destDir);
+    const exportsJsonFile = path.join(destDir, 'exports.json');
+    updateExportsJsonFile(exportsJsonFile, details);
+
+    // create symlink in docs to README.md
+    const docsSymlinkTarget = path.join('../../../packages/', destDirName, '/README.md');
+    const docsSymlinkPath = path.join(process.cwd(), 'docs/packages/', destDirName, '/README.md');
+    await fse.ensureSymlink(docsSymlinkTarget, docsSymlinkPath);
+
+    console.log(`${chalk.green('Success')}, package has been initialized!`);
+}

package/utils/create-package/src/index.ts

@@ -0,0 +1,3 @@
+import { main } from './createPackage';
+
+main();

package/utils/create-package/src/questionnaire/questions.ts

@@ -0,0 +1,19 @@
+import * as inquirer from 'inquirer';
+
+interface IPromptPackageDetailsDefaults {
+    /** Package name */
+    name: string;
+}
+
+async function promptPackageDetails(defaultValues: IPromptPackageDetailsDefaults) {
+    return inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Package name:',
+            default: defaultValues.name,
+        },
+    ]);
+}
+
+export { promptPackageDetails };

package/utils/create-package/src/settings/Settings.ts

@@ -0,0 +1,5 @@
+const Settings = {
+    name: '',
+};
+
+export { Settings };

package/utils/create-package/src/types.ts

@@ -0,0 +1,4 @@
+export interface IPackageOptions {
+    /** Package name */
+    name: string;
+}

package/utils/create-package/templates/typescript/README.md

@@ -0,0 +1,9 @@
+---
+id: README
+title: My Package Title
+hide_title: true
+sidebar_label: My Package Title
+---
+
+# My Package Title
+Auto-generated SmartApps BIGscreen readme file

package/utils/create-package/templates/typescript/exports.json

@@ -0,0 +1,6 @@
+{
+    "name": "xxx",
+    "entryPoints": {
+        "/": "src/index.ts"
+    }
+}

package/utils/run-scripts/index.ts

@@ -0,0 +1,3 @@
+import { runScripts } from './src/runScripts';
+
+runScripts();

package/utils/run-scripts/src/__tests__/runScripts.spec.ts

@@ -0,0 +1,45 @@
+import { execSync } from 'child_process';
+import { runScripts } from '../runScripts';
+
+jest.mock('../../../../package.json', () => ({
+    scripts: {
+        'scripts:prepare:create-export-maps': 'ts-node ./utils/create-export-maps/index.ts',
+        'scripts:run:test2': 'ts-node ./utils/test2.ts',
+        'scripts:run:test1': 'ts-node ./utils/test1.ts',
+    },
+}));
+
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+}));
+
+describe('runScripts', () => {
+    const argvBackup = process.argv;
+    
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    afterAll(() => {
+        process.argv = argvBackup;
+    });
+    
+    it('should not run anything if no script found', () => {
+        process.argv = ['node', 'run-scripts/index.ts', 'build:.+'];
+        runScripts();
+        expect(execSync).not.toHaveBeenCalled();
+    });
+    
+    it('should run found script', () => {
+        process.argv = ['node', 'run-scripts/index.ts', 'prepare:.+'];
+        runScripts();
+        expect(execSync).toHaveBeenCalledWith('npm run scripts:prepare:create-export-maps');
+    });
+    
+    it('should run found scripts in order they are in package.json', () => {
+        process.argv = ['node', 'run-scripts/index.ts', 'run:.+'];
+        runScripts();
+        expect(execSync).toHaveBeenNthCalledWith(1, 'npm run scripts:run:test2');
+        expect(execSync).toHaveBeenNthCalledWith(2, 'npm run scripts:run:test1');
+    });
+});

package/utils/run-scripts/src/runScripts.ts

@@ -0,0 +1,20 @@
+import { execSync } from 'child_process';
+import { scripts } from '../../../package.json';
+
+/**
+ * Runs all npm scripts from package.json that match given regexp.
+ * RegExp is passed as the 1st param.
+ */
+export const runScripts = () => {
+    const matcher = new RegExp(process.argv[2] ?? '');
+    const scriptsToRun = Object.keys(scripts).filter((script) => script.match(matcher));
+    scriptsToRun.forEach((script) => {
+        console.log(`Running npm run ${script}`);
+        try {
+            execSync(`npm run ${script}`);
+        } catch (e) {
+            console.error((e as Error).message);
+            process.exit(1);
+        }
+    });
+};