@pushwoosh/frontend-builder-engine 0.0.1

package/README.md

@@ -0,0 +1 @@
+# Pushwoosh Frontend Engine

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../lib/pushwoosh-engine.js');

package/lib/build-babel.js

@@ -0,0 +1,39 @@
+const path = require('path');
+const fs = require('fs');
+const babel = require('@babel/core');
+const { listFilesInDirectoryRecursively, PromiseQueue } = require('./helpers');
+
+async function buildStyledComponents(
+  sourceDir,
+  targetDir,
+) {
+  const files = await listFilesInDirectoryRecursively(sourceDir);
+  const options = {
+    babelrc: false,
+    configFile: false,
+    plugins: [
+      [
+        'babel-plugin-styled-components',
+        {
+          fileName: false,
+          minify: true,
+          transpileTemplateLiterals: true,
+        },
+      ],
+    ],
+  };
+  const jsFiles = files.filter((file) => file.endsWith('.js'));
+  const queue = new PromiseQueue(10);
+  await Promise.all(jsFiles.map((file) => queue.add(async () => {
+    const fullSourcePath = path.join(sourceDir, file);
+    const fullTargetPath = path.join(targetDir, file);
+    const beforeDate = new Date();
+    const result = await babel.transformFileAsync(fullSourcePath, options);
+    console.log(`Writing ${fullTargetPath} ${new Date() - beforeDate}ms`);
+    await fs.promises.mkdir(path.dirname(fullTargetPath), { recursive: true });
+    await fs.promises.writeFile(fullTargetPath, result.code);
+  })));
+}
+module.exports = {
+  buildStyledComponents,
+};

package/lib/build-ts.js

@@ -0,0 +1,42 @@
+const ts = require('typescript');
+
+async function buildTs(basePath, configFile) {
+  // const configFile = ts.readConfigFile(configFilePath, ts.sys.readFile);
+  // console.log(configFile);
+  const parsedCommandLine = ts.parseJsonConfigFileContent(
+    configFile,
+    ts.sys,
+    basePath,
+  );
+
+  const program = ts.createProgram(parsedCommandLine.fileNames, parsedCommandLine.options);
+  const emitResult = program.emit();
+
+  const allDiagnostics = ts
+    .getPreEmitDiagnostics(program)
+    .concat(emitResult.diagnostics);
+
+  allDiagnostics.forEach((diagnostic) => {
+    if (diagnostic.file) {
+      const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(
+        diagnostic.start,
+      );
+      const message = ts.flattenDiagnosticMessageText(
+        diagnostic.messageText,
+        '\n',
+      );
+      console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+    } else {
+      console.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+    }
+  });
+
+  if (allDiagnostics.length > 0) {
+    return 1;
+  }
+  return 0;
+}
+
+module.exports = {
+  buildTs,
+};

package/lib/helpers.js

@@ -0,0 +1,77 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+async function listFilesInDirectoryRecursively(directory, baseDirectory = directory) {
+  let files = [];
+
+  const items = await fs.readdir(directory, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = path.join(directory, item.name);
+    if (item.isDirectory()) {
+      files = files.concat(await listFilesInDirectoryRecursively(fullPath, baseDirectory));
+    } else {
+      files.push(path.relative(baseDirectory, fullPath));
+    }
+  }
+
+  return files;
+}
+
+class PromiseQueue {
+  constructor(maxPendingPromises) {
+    this.queue = [];
+    this.pendingPromises = 0;
+    this.maxPendingPromises = maxPendingPromises;
+  }
+
+  add(promiseGenerator) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        promiseGenerator,
+        resolve,
+        reject,
+      });
+
+      this.dequeue();
+    });
+  }
+
+  dequeue() {
+    if (this.pendingPromises >= this.maxPendingPromises) {
+      return false;
+    }
+
+    const item = this.queue.shift();
+    if (!item) {
+      return false;
+    }
+    try {
+      this.pendingPromises++;
+
+      item.promiseGenerator()
+        .then(
+          (value) => {
+            this.pendingPromises--;
+            item.resolve(value);
+            this.dequeue();
+          },
+          (err) => {
+            this.pendingPromises--;
+            item.reject(err);
+            this.dequeue();
+          },
+        );
+    } catch (err) {
+      this.pendingPromises--;
+      item.reject(err);
+      this.dequeue();
+    }
+
+    return true;
+  }
+}
+
+module.exports = {
+  listFilesInDirectoryRecursively,
+  PromiseQueue,
+};

package/lib/lib-build-tsconfig.js

@@ -0,0 +1,42 @@
+const path = require('path');
+const { mapValues, isPlainObject } = require('lodash');
+const ts = require('typescript');
+
+function smartMerge(obj, extend) {
+  const result = mapValues(obj, (value, key) => {
+    if (key in extend) {
+      const newValue = extend[key];
+      if (
+        typeof newValue === 'string'
+        || typeof newValue === 'boolean'
+        || typeof newValue === 'number'
+        || Array.isArray(newValue)
+      ) {
+        return newValue;
+      }
+      if (typeof newValue === 'function') {
+        return newValue(value);
+      }
+      if (isPlainObject(newValue)) {
+        return smartMerge(value, newValue);
+      }
+    }
+    return value;
+  });
+  const extendsUniqueKeys = Object.keys(extend).filter((key) => !(key in obj));
+  for (const key of extendsUniqueKeys) {
+    const newValue = extend[key];
+    result[key] = typeof newValue === 'function' ? newValue() : newValue;
+  }
+  return result;
+}
+
+function loadTsConfig(extend) {
+  const tsConfigPath = path.resolve(__dirname, 'tsconfig.json');
+  const { config } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+  return smartMerge(config, extend);
+}
+
+module.exports = {
+  loadTsConfig,
+};

package/lib/pushwoosh-engine.js

@@ -0,0 +1,44 @@
+const { program, Command } = require('commander');
+
+const { buildTs } = require('./build-ts');
+const { buildStyledComponents } = require('./build-babel');
+const { loadTsConfig } = require('./lib-build-tsconfig');
+
+program
+  .version('1.0.0')
+  .description('An example CLI tool with commander')
+  .option('-n, --name <type>', 'Your name')
+  .option('-a, --age <type>', 'Your age')
+  .command('lib:build')
+  .action(async () => {
+    const curDir = process.cwd();
+    const targetDir = `${curDir}/dist`;
+    const tsConfig = loadTsConfig({});
+    await buildTs(curDir, tsConfig);
+    await buildStyledComponents(targetDir, targetDir);
+  })
+  .option('-s, --ss <type>', 'output extra debugging');
+
+program
+  .addCommand(
+    new Command('lib:check-types')
+      .description('Check types in the project')
+      .action(async () => {
+        const curDir = process.cwd();
+        const tsConfig = loadTsConfig({ compilerOptions: { noEmit: true } });
+        const code = await buildTs(curDir, tsConfig);
+        if (code !== 0) {
+          process.exit(code);
+        }
+      }),
+  );
+
+program.parse(process.argv);
+/*
+
+const options = program.opts();
+console.log(options, process.cwd());
+if (options.name && options.age) {
+  console.log(`Hello ${options.name}, you are ${options.age} years old.`);
+}
+*/

package/lib/tsconfig.json

@@ -0,0 +1,53 @@
+{
+  "compilerOptions": {
+    /* ----- Base Options ----- */
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": [
+      "ESNext",
+      "DOM"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "jsx": "react",
+    "importHelpers": true,
+    "declaration": true,
+    "sourceMap": false,
+    /* ----- Strict Type-Checking Options ----- */
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    /* ----- Additional Checks ----- */
+    "forceConsistentCasingInFileNames": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    /* ----- More ----- */
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    /* ----- Experimental Options ----- */
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    /* ----- Module Resolution Options ----- */
+    "moduleResolution": "node",
+    "baseUrl": "./",
+    "paths": {
+      "~/src": [
+        "./src"
+      ],
+      "~/src/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "./src/**/*",
+  ]
+}

package/lib/tsconfig.playground.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "baseUrl": "./scripts",
+    "paths": {
+      "~/src": ["../src"],
+      "~/src/*": ["../src/*"]
+      //"*": ["node_modules/*"]
+    }
+  },
+  //"include": ["../playground/**/*"]
+}

package/lib/webpack.playground.config.js

@@ -0,0 +1,59 @@
+const path = require('path');
+
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
+// const { loadTsConfig } = require('./lib-build-tsconfig');
+
+function getConfig() {
+  const projectPath = process.cwd();
+  return {
+    target: 'web',
+    mode: 'development',
+    entry: './playground/index.tsx',
+    output: {
+      path: path.resolve(projectPath, 'dist'),
+      filename: 'bundle.js',
+    },
+    resolve: {
+      extensions: ['.tsx', '.ts', 'jsx', '.js'],
+      alias: {
+        '~src': path.resolve(projectPath, 'src/'),
+      },
+      plugins: [
+        new TsconfigPathsPlugin({
+          context: path.join(projectPath, './playground'),
+          configFile: path.join(projectPath, './playground/tsconfig.json'),
+        }),
+      ],
+    },
+    module: {
+      rules: [
+        {
+          test: /\.tsx?$/,
+          use: {
+            loader: 'ts-loader',
+            options: {
+              context: path.join(projectPath, './playground'),
+              configFile: path.join(projectPath, './playground/tsconfig.json'),
+            },
+          },
+          exclude: /node_modules/,
+        },
+      ],
+    },
+    plugins: [
+      new HtmlWebpackPlugin({
+        template: './playground/index.html',
+      }),
+    ],
+    devServer: {
+      static: {
+        directory: path.join(projectPath, 'dist'),
+      },
+      // compress: true,
+      port: 8080,
+    },
+  };
+}
+
+module.exports = getConfig;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pushwoosh/frontend-builder-engine",
+  "version": "0.0.1",
+  "description": "Pushwoosh frontend builder engine",
+  "main": "./lib/pushwoosh-frontend-builder-engine.js",
+  "scripts": {
+    "test": "echo test"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.24.3",
+    "commander": "^12.0.0",
+    "html-webpack-plugin": "^5.6.0",
+    "ts-loader": "^9.5.1",
+    "tsconfig-paths-webpack-plugin": "^4.1.0",
+    "typescript": "^5.4.3",
+    "webpack": "^5.91.0",
+    "webpack-dev-server": "^5.0.4"
+  },
+  "peerDependencies": {
+    "lodash": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}