@pinnacle0/webpack-util 0.3.23 → 0.3.26

package/config/jest.config.ts

@@ -0,0 +1,35 @@
+import type {Config} from "@jest/types";
+
+const config: Config.InitialOptionsWithRootDir = {
+    // Stop running tests after `n` failures
+    bail: 1,
+
+    // A preset that is used as a base for Jest's configuration
+    preset: "ts-jest",
+
+    // A set of global variables that need to be available in all test environments
+    globals: {
+        "ts-jest": {
+            tsconfig: "<rootDir>/config/tsconfig.test.json",
+        },
+    },
+
+    // The root directory that Jest should scan for tests and modules within
+    rootDir: "../",
+
+    // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+    testPathIgnorePatterns: ["/node_modules/", "<rootDir>/build/"],
+
+    // A map from regular expressions to paths to transformers
+    transform: {
+        [String.raw`\.(ts|tsx)$`]: "ts-jest",
+    },
+
+    // Indicates whether each individual test should be reported during the run
+    verbose: true,
+
+    // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+    watchPathIgnorePatterns: ["<rootDir>/build/", "dist/"],
+};
+
+export default config;

package/config/tsconfig.script.json

@@ -0,0 +1,10 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "lib": ["ES2020"],
+        "module": "CommonJS",
+        "target": "ES2015",
+        "noEmit": true
+    },
+    "include": ["../config", "../script/"]
+}

package/config/tsconfig.src.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "lib": ["ES2020"],
+        "module": "CommonJS",
+        "target": "ES2015",
+        "rootDir": "../",
+        "outDir": "../build/",
+        "isolatedModules": true
+    },
+    "include": ["../src/"]
+}

package/config/tsconfig.test.json

@@ -0,0 +1,11 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "lib": ["ES2020"],
+        "module": "CommonJS",
+        "target": "ES2015",
+        "rootDir": "../",
+        "isolatedModules": true
+    },
+    "include": ["../test/"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pinnacle0/webpack-util",
-    "version": "0.3.23",
+    "version": "0.3.26",
     "license": "MIT",
     "main": "src/index.js",
     "scripts": {
@@ -10,9 +10,9 @@
         "test": "jest --config config/jest.config.ts"
     },
     "dependencies": {
-        "@babel/core": "7.18.5",
+        "@babel/core": "7.18.6",
         "@pmmmwh/react-refresh-webpack-plugin": "0.5.7",
-        "@swc/core": "1.2.203",
+        "@swc/core": "1.2.210",
         "autoprefixer": "10.4.7",
         "babel-loader": "8.2.5",
         "css-loader": "6.7.1",
@@ -29,18 +29,16 @@
         "style-loader": "3.3.1",
         "swc-loader": "0.2.3",
         "terser-webpack-plugin": "5.3.3",
-        "ts-loader": "9.3.0",
+        "ts-loader": "9.3.1",
         "webpack": "5.73.0",
-        "webpack-dev-server": "4.9.2",
+        "webpack-dev-server": "4.9.3",
         "yargs": "17.5.1"
     },
     "peerDependencies": {
         "typescript": "*"
     },
     "devDependencies": {
-        "@types/html-webpack-plugin": "3.2.6",
-        "@types/speed-measure-webpack-plugin": "1.3.4",
-        "@types/yargs": "17.0.10"
+        "@types/html-webpack-plugin": "3.2.6"
     },
     "engines": {
         "node": ">= 16.0.0"

package/script/build.ts

@@ -0,0 +1,65 @@
+import {PrettierUtil, TaskRunner, Utility} from "@pinnacle0/devtool-util";
+import fs from "fs";
+import path from "path";
+
+const FilePath = {
+    config: path.join(__dirname, "../config"),
+    build: path.join(__dirname, "../build"),
+    script: path.join(__dirname, "../script"),
+    src: path.join(__dirname, "../src"),
+
+    jestConfig: path.join(__dirname, "../config/jest.config.ts"),
+    tsConfigForSrc: path.join(__dirname, "../config/tsconfig.src.json"),
+    projectPackageJSON: path.join(__dirname, "../package.json"),
+    projectReadMe: path.join(__dirname, "../README.md"),
+    projectLicense: path.join(__dirname, "../LICENSE.md"),
+    buildPackageJSON: path.join(__dirname, "../build/package.json"),
+    buildReadMe: path.join(__dirname, "../build/README.md"),
+    buildLicense: path.join(__dirname, "../build/LICENSE.md"),
+};
+
+new TaskRunner("build").execute([
+    {
+        name: "code style check",
+        skipInFastMode: true,
+        execute: () => {
+            PrettierUtil.check(FilePath.config);
+            PrettierUtil.check(FilePath.script);
+            PrettierUtil.check(FilePath.src);
+        },
+    },
+    {
+        name: "lint",
+        skipInFastMode: true,
+        execute: () => {
+            Utility.runCommand("eslint", ["--ext=.js,.jsx,.ts,.tsx", FilePath.src]);
+        },
+    },
+    {
+        name: "test",
+        skipInFastMode: true,
+        execute: () => {
+            Utility.runCommand("jest", ["--config", FilePath.jestConfig, "--bail"]);
+        },
+    },
+    {
+        name: "prepare build directory",
+        execute: () => {
+            Utility.prepareEmptyDirectory(FilePath.build);
+        },
+    },
+    {
+        name: "compile with tsc",
+        execute: () => {
+            Utility.runCommand("tsc", ["--project", FilePath.tsConfigForSrc]);
+        },
+    },
+    {
+        name: "copy package.json, markdown files",
+        execute: () => {
+            fs.copyFileSync(FilePath.projectPackageJSON, FilePath.buildPackageJSON);
+            fs.copyFileSync(FilePath.projectReadMe, FilePath.buildReadMe);
+            fs.copyFileSync(FilePath.projectLicense, FilePath.buildLicense);
+        },
+    },
+]);

package/script/format.ts

@@ -0,0 +1,7 @@
+import {PrettierUtil} from "@pinnacle0/devtool-util";
+import path from "path";
+
+PrettierUtil.format(path.join(__dirname, "../config"));
+PrettierUtil.format(path.join(__dirname, "../script"));
+PrettierUtil.format(path.join(__dirname, "../src"));
+PrettierUtil.format(path.join(__dirname, "../test"));

package/src/CanadyarnRunner.ts

@@ -0,0 +1,35 @@
+import {Utility} from "@pinnacle0/devtool-util";
+import fs from "fs";
+
+/**
+ * `canadyarn` is a mono-repo package version checker for single version installation, developed by Pinnacle team.
+ *
+ * Ref: https://www.npmjs.com/package/canadyarn
+ */
+export class CanadyarnRunner {
+    private readonly rootDirectory: string;
+    private readonly logger = Utility.createConsoleLogger("CanadyarnRunner");
+
+    constructor({rootDirectory}: {rootDirectory: string}) {
+        this.rootDirectory = rootDirectory;
+    }
+
+    run() {
+        this.runCanadyarn();
+    }
+
+    private runCanadyarn() {
+        const packageJSONPath = this.rootDirectory + "/package.json";
+
+        if (fs.existsSync(packageJSONPath) && fs.statSync(packageJSONPath).isFile()) {
+            const packageJSONContents: Record<string, any> = JSON.parse(fs.readFileSync(packageJSONPath, {encoding: "utf8"}));
+
+            if (packageJSONContents?.scripts?.canadyarn) {
+                this.logger.task("Running `canadyarn` at " + this.rootDirectory);
+                Utility.runCommand("yarn", ["--cwd", this.rootDirectory, "canadyarn"]);
+            }
+        } else {
+            throw new Error(`Cannot load root directory [${this.rootDirectory}] package.json`);
+        }
+    }
+}

package/src/CodeStyleChecker.ts

@@ -0,0 +1,44 @@
+import {PrettierUtil, Utility} from "@pinnacle0/devtool-util";
+import fs from "fs";
+import path from "path";
+import type {InternalCheckerOptions} from "./type";
+
+export class CodeStyleChecker {
+    private readonly checkableSrcDirectories: [string, ...string[]];
+    private readonly logger = Utility.createConsoleLogger("CodeStyleChecker");
+
+    constructor({projectDirectory, extraCheckDirectories = []}: InternalCheckerOptions) {
+        this.checkableSrcDirectories = [path.join(projectDirectory, "src")];
+        for (const directory of extraCheckDirectories) {
+            const others = ["test", "script"].map(folder => path.join(directory, folder)).filter(path => fs.existsSync(path));
+            this.checkableSrcDirectories.push(path.join(directory, "src"), ...others);
+        }
+    }
+
+    run() {
+        this.checkPrettier();
+        this.checkESLint();
+        this.checkStylelint();
+    }
+
+    private checkPrettier() {
+        this.logger.task("Checking Prettier");
+        for (const srcDirectory of this.checkableSrcDirectories) {
+            PrettierUtil.check(srcDirectory);
+        }
+    }
+
+    private checkESLint() {
+        this.logger.task("Checking ESLint");
+        for (const srcDirectory of this.checkableSrcDirectories) {
+            Utility.runCommand("eslint", ["--no-error-on-unmatched-pattern", "--max-warnings=1", "--ext=.js,.jsx,.ts,.tsx", srcDirectory]);
+        }
+    }
+
+    private checkStylelint() {
+        this.logger.task("Checking Stylelint");
+        for (const srcDirectory of this.checkableSrcDirectories) {
+            Utility.runCommand("stylelint", ["--allow-empty-input", "--max-warnings=1", path.join(srcDirectory, "**/*.{css,less}")]);
+        }
+    }
+}

package/src/{Constant.js → Constant.ts}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Constant = void 0;
-exports.Constant = Object.freeze({
+export const Constant = Object.freeze({
     maxEntryPointKiloByte: 1500,
     maxAssetKiloByte: 4000,
     /**
@@ -22,4 +19,3 @@ exports.Constant = Object.freeze({
      */
     mainEntryFilenames: ["index.tsx", "index.ts", "index.jsx", "index.js", "index.less", "index.css"],
 });
-//# sourceMappingURL=Constant.js.map

package/src/CoreUtil.ts

@@ -0,0 +1,24 @@
+import yargs from "yargs";
+
+function currentEnv(): string | null {
+    return (yargs.parseSync().env as string) || null;
+}
+
+function profilingEnabled(): boolean {
+    return Boolean(yargs.parseSync().profile);
+}
+
+function isFastMode(): boolean {
+    return yargs.parseSync().mode === "fast";
+}
+
+function verbose(): boolean {
+    return Boolean(yargs.parseSync().verbose);
+}
+
+export const CoreUtil = Object.freeze({
+    currentEnv,
+    profilingEnabled,
+    isFastMode,
+    verbose,
+});

package/src/ProjectStructureChecker.ts

@@ -0,0 +1,119 @@
+import fs from "fs";
+import path from "path";
+import {Constant} from "./Constant";
+import type {InternalCheckerOptions} from "./type";
+
+export class ProjectStructureChecker {
+    private readonly projectDirectory: string;
+    private readonly extraCheckDirectories: string[];
+    private readonly packageJSONPath: string;
+    private readonly tsConfigPath: string;
+
+    constructor(private readonly options: InternalCheckerOptions) {
+        this.projectDirectory = options.projectDirectory;
+        this.extraCheckDirectories = options.extraCheckDirectories ?? [];
+        this.packageJSONPath = path.join(options.projectDirectory, "package.json");
+        this.tsConfigPath = path.join(options.projectDirectory, "tsconfig.json");
+    }
+
+    run() {
+        this.checkMainProjectDirectory();
+        this.checkMainProjectSrcDirectory();
+        this.checkExtraDirectories();
+        this.checkPackageJSON();
+        this.checkTSConfig();
+
+        this.checkPrettierInstallation();
+        this.checkESLintInstallation();
+        this.checkStyleLintInstallation();
+    }
+
+    private checkMainProjectDirectory() {
+        if (!(fs.existsSync(this.projectDirectory) && fs.statSync(this.projectDirectory).isDirectory())) {
+            throw new Error(`Cannot check project directory at "${this.projectDirectory}" because it is not a folder.`);
+        }
+
+        const mainProjectStaticDirectory = path.join(this.projectDirectory, "static");
+        if (!(fs.existsSync(mainProjectStaticDirectory) && fs.statSync(mainProjectStaticDirectory).isDirectory())) {
+            throw new Error(`Cannot find "static" directory in project at "${this.projectDirectory}"`);
+        }
+    }
+
+    private checkMainProjectSrcDirectory() {
+        const mainProjectSrcDirectory = path.join(this.projectDirectory, "src");
+        if (!(fs.existsSync(mainProjectSrcDirectory) && fs.statSync(mainProjectSrcDirectory).isDirectory())) {
+            throw new Error(`Cannot find "src" folder inside directory at "${this.projectDirectory}".`);
+        }
+
+        let isMainEntryFound = false;
+        Constant.mainEntryFilenames
+            .map(entryName => path.join(mainProjectSrcDirectory, entryName))
+            .forEach(entryPath => {
+                if (fs.existsSync(entryPath) && fs.statSync(entryPath).isFile()) {
+                    isMainEntryFound = true;
+                }
+            });
+        if (!isMainEntryFound) {
+            throw new Error(`Cannot find main entry file in src/ at "${mainProjectSrcDirectory}"; checked: ${Constant.mainEntryFilenames.map(_ => `"${_}"`).join(" / ")}.`);
+        }
+    }
+
+    private checkExtraDirectories() {
+        for (const extraCheckDirectory of this.extraCheckDirectories) {
+            if (!(fs.existsSync(extraCheckDirectory) && fs.statSync(extraCheckDirectory).isDirectory())) {
+                throw new Error(`Cannot check extra directory at "${extraCheckDirectory}" because it is not a folder.`);
+            }
+        }
+    }
+
+    private checkPackageJSON() {
+        if (!(fs.existsSync(this.packageJSONPath) && fs.statSync(this.packageJSONPath).isFile())) {
+            throw new Error(`Cannot find package.json at "${this.packageJSONPath}".`);
+        }
+        const packageJSONContents: Record<string, any> = JSON.parse(fs.readFileSync(this.packageJSONPath, {encoding: "utf8"}));
+        for (const [depName, depVersion] of Object.entries<string>(packageJSONContents.dependencies || {})) {
+            if (!/^\d/.test(depVersion)) {
+                throw new Error(`Dependency "${depName}" must be an exact version, but found "${depVersion}" in package.json at "${this.packageJSONPath}".`);
+            }
+        }
+        for (const [depName, depVersion] of Object.entries<string>(packageJSONContents.devDependencies || {})) {
+            if (!/^\d/.test(depVersion)) {
+                throw new Error(`Dependency "${depName}" must be an exact version, but found "${depVersion}" in package.json at "${this.packageJSONPath}".`);
+            }
+        }
+    }
+
+    private checkTSConfig() {
+        const mainProjectSrcDirectory = path.join(this.projectDirectory, "src");
+        // Checking the first-level of src/* is enough here
+        const hasTSFiles = fs.readdirSync(mainProjectSrcDirectory).some(fileName => fileName.endsWith(".ts") || fileName.endsWith(".tsx"));
+        const hasTSConfigFile = fs.existsSync(this.tsConfigPath) && fs.statSync(this.tsConfigPath).isFile();
+        if (hasTSFiles && !hasTSConfigFile) {
+            throw new Error(`Cannot find tsconfig.json at "${this.tsConfigPath}".`);
+        }
+    }
+
+    private checkPrettierInstallation() {
+        try {
+            require("prettier");
+        } catch {
+            throw new Error(`Cannot load prettier module (requiring from "webpack-util"), make sure prettier is installed.`);
+        }
+    }
+
+    private checkESLintInstallation() {
+        try {
+            require("eslint");
+        } catch {
+            throw new Error(`Cannot load eslint module (requiring from "webpack-util"), make sure eslint is installed.`);
+        }
+    }
+
+    private checkStyleLintInstallation() {
+        try {
+            require("stylelint");
+        } catch {
+            throw new Error(`Cannot load stylelint module (requiring from "webpack-util"), make sure stylelint is installed.`);
+        }
+    }
+}

package/src/TestRunner.ts

@@ -0,0 +1,28 @@
+import {Utility} from "@pinnacle0/devtool-util";
+import type {InternalCheckerOptions} from "./type";
+import fs from "fs";
+
+export class TestRunner {
+    private readonly directories: [string, ...string[]];
+    private readonly logger = Utility.createConsoleLogger("TestRunner");
+
+    constructor({projectDirectory, extraCheckDirectories = []}: InternalCheckerOptions) {
+        this.directories = [projectDirectory, ...extraCheckDirectories];
+    }
+
+    run() {
+        this.directories.forEach(dir => this.runTestScript(dir));
+    }
+
+    private runTestScript(directory: string) {
+        const packageJSONPath = directory + "/package.json";
+        if (fs.existsSync(packageJSONPath) && fs.statSync(packageJSONPath).isFile()) {
+            const packageJSONContents: Record<string, any> = JSON.parse(fs.readFileSync(packageJSONPath, {encoding: "utf8"}));
+
+            if (packageJSONContents?.scripts?.test) {
+                this.logger.task("Running `yarn test` at " + directory);
+                Utility.runCommand("yarn", ["--cwd", directory, "test"]);
+            }
+        }
+    }
+}

package/src/TypescriptTypeChecker.ts

@@ -0,0 +1,29 @@
+import {Utility} from "@pinnacle0/devtool-util";
+import path from "path";
+import type {InternalCheckerOptions} from "./type";
+
+/**
+ * Check typescript type for both projectDirectory src, extraCheckDirectories src using their own tsconfig inside their directory
+ */
+export class TypescriptTypeChecker {
+    private readonly logger = Utility.createConsoleLogger("TypescriptTypeChecker");
+    private tsconfigPaths: string[] = [];
+
+    constructor({projectDirectory, extraCheckDirectories}: InternalCheckerOptions) {
+        const checkableDirectories = [projectDirectory, ...(extraCheckDirectories ?? [])];
+        for (const directory of checkableDirectories) {
+            this.tsconfigPaths.push(path.join(directory, "tsconfig.json"));
+        }
+    }
+
+    run() {
+        this.checkTypeScriptTyping();
+    }
+
+    private checkTypeScriptTyping() {
+        this.logger.task("Checking TypeScript");
+        for (const tsconfigPath of this.tsconfigPaths) {
+            Utility.runCommand("tsc", ["--noEmit", "--emitDeclarationOnly", "false", "-P", tsconfigPath]);
+        }
+    }
+}