pkgbld 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Konstantin Shutkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# pkgbld
+
+Rollup based build tool for building libraries based on package.json config and simple CLI options.
+
+It is simple building tool that supports building to different targets like: `es`, `cjs`, `umd` without additional trasformation other than minification using `terser` or preprocess using `rollup-plugin-preprocess`.
+
+## Why
+
+It is created to easily build libraries that contains mutliple subpackages (exports, entry points) because it is not that easy to do at the moment with `microbundle`, `tsdx` or `ng-packagr`.
+
+## Installation
+
+Using npm:
+```
+npm install --save-dev pkgbld
+```
+
+## package.json
+
+`pkgbld` expects name field to be filled in package.json file. `exports` field defined what entries/outputs should be build for this package.
+
+## CLI options
+
+### umd
+
+```
+pkgbld --umd=index,core
+```
+
+Where `index,core` should be replaced by entry points that should be comiled in umd format, index is top level `'.'` entry point.
+
+If `package.json` defined umd field option will be defaulted to `index`.
+
+### compress
+
+```
+pkgbld --compress=index,core
+```
+
+Where `index,core` should be replaced by entry points that should be compressed using terser.
+
+### sourcemaps
+
+```
+pkgbld --sourcemaps=es,cjs
+```
+
+Where `es,cjs` should be replaced by targets for which sourcemaps should be generated. Default `umd`.
+
+Supported targets for this option: `es`, `cjs` and `umd`.
+
+### formats
+
+```
+pkgbld --formats=es
+```
+
+Defines what formats to build, only supports `es` and `cjs` at the moment. Use `umd` flag to build umd target.
+
+### preprocess
+
+```
+pkgbld --preprocess=index
+```
+
+Defines what entry points/files should be preprocessed using `rollup-plugin-preprocess`.
+
+### dir
+
+```
+pkgbld --dir=dist
+```
+
+Directory to use for build.
+
+# License
+
+[MIT](./LICENSE)

package/dist/cleanup.d.ts

@@ -0,0 +1 @@
+export declare function cleanupDir(dir: string): Promise<void>;

package/dist/create-subpackages.d.ts

@@ -0,0 +1,2 @@
+import { getCliOptions } from './get-cli-options';
+export declare function createSubpackages(inputs: string[], config: ReturnType<typeof getCliOptions>): Promise<void>;

package/dist/get-cli-options.d.ts

@@ -0,0 +1,8 @@
+export declare function getCliOptions(): {
+    umdTargets: string[];
+    compressTargets: string[];
+    sourcemapTargets: string[];
+    formats: string[];
+    preprocess: string[];
+    dir: string;
+};

package/dist/get-pkg.d.ts

@@ -0,0 +1 @@
+export declare function getPackage(): Promise<any[]>;

package/dist/get-plugins.d.ts

@@ -0,0 +1,4 @@
+import { InternalModuleFormat, Plugin } from 'rollup';
+import { getCliOptions } from './get-cli-options';
+export declare function getBuildPlugins(format: InternalModuleFormat, config: ReturnType<typeof getCliOptions>): Plugin[];
+export declare function getOutputPlugins(format: InternalModuleFormat, config: ReturnType<typeof getCliOptions>): Plugin[];

package/dist/get-rollup-configs.d.ts

@@ -0,0 +1,4 @@
+import { RollupOptions } from 'rollup';
+import { getCliOptions } from './get-cli-options';
+import { getHelpers } from './helpers';
+export declare function getRollupConfigs(inputs: string[], config: ReturnType<typeof getCliOptions>, helpers: ReturnType<typeof getHelpers>): RollupOptions[];

package/dist/helpers.d.ts

@@ -0,0 +1,13 @@
+import { getCliOptions } from './get-cli-options';
+export declare function getHelpers(pkg: any): {
+    external: (id: string | string[]) => any;
+    getGlobalName: (anInput: string) => string;
+    getExternalGlobalName: (id: string) => string;
+    umdFilter: typeof umdFilter;
+};
+export declare function umdFilter(config: ReturnType<typeof getCliOptions>, filename: string): boolean;
+export declare function toArray<T>(object: T): (T & any[]) | T[];
+export declare function isExternalInput(id: string, inputs: string | string[], currentInput: string): boolean;
+export declare function formatInput(input: string[] | string | undefined): string | undefined;
+export declare function formatOutput(output: any, field: string): string | undefined;
+export declare function getTimeDiff(starting: number): string;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+'use strict';
+
+var logger = require('@niceties/logger');
+var rollup = require('rollup');
+var fs = require('fs/promises');
+var path = require('path');
+var minimist = require('minimist');
+var typescript = require('rollup-plugin-typescript2');
+var commonjs = require('@rollup/plugin-commonjs');
+var resolve = require('@rollup/plugin-node-resolve');
+var preprocess = require('rollup-plugin-preprocess');
+var rollupPluginTerser = require('rollup-plugin-terser');
+var isBuiltinModule = require('is-builtin-module');
+var camelCase = require('lodash/camelCase');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var minimist__default = /*#__PURE__*/_interopDefaultLegacy(minimist);
+var typescript__default = /*#__PURE__*/_interopDefaultLegacy(typescript);
+var commonjs__default = /*#__PURE__*/_interopDefaultLegacy(commonjs);
+var resolve__default = /*#__PURE__*/_interopDefaultLegacy(resolve);
+var preprocess__default = /*#__PURE__*/_interopDefaultLegacy(preprocess);
+var isBuiltinModule__default = /*#__PURE__*/_interopDefaultLegacy(isBuiltinModule);
+var camelCase__default = /*#__PURE__*/_interopDefaultLegacy(camelCase);
+
+async function createSubpackages(inputs, config) {
+    for (const input of inputs) {
+        const basename = path__default["default"].basename(input, '.ts');
+        if (basename !== 'index') {
+            const pkg = {
+                types: `../${config.dir}/${basename}.d.ts`
+            };
+            await fs__default["default"].mkdir(basename, { recursive: true });
+            await fs__default["default"].writeFile(`${basename}/package.json`, JSON.stringify(pkg, null, 2));
+        }
+    }
+}
+
+const defaults = {
+    formats: ['es', 'cjs'],
+    umdTargets: [],
+    compressTargets: ['umd'],
+    sourcemapTargets: ['umd'],
+    preprocess: [],
+    dir: 'dist'
+};
+function getCliOptions() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const parsedArgs = minimist__default["default"](process.argv.slice(2));
+    const umdTargets = (_b = (_a = parsedArgs.umd) === null || _a === void 0 ? void 0 : _a.split(',').map((arg) => arg.trim())) !== null && _b !== void 0 ? _b : defaults.umdTargets;
+    const compressTargets = (_d = (_c = parsedArgs.compress) === null || _c === void 0 ? void 0 : _c.split(',').map((arg) => arg.trim())) !== null && _d !== void 0 ? _d : defaults.compressTargets;
+    const sourcemapTargets = (_f = (_e = parsedArgs.sourcemaps) === null || _e === void 0 ? void 0 : _e.split(',').map((arg) => arg.trim())) !== null && _f !== void 0 ? _f : defaults.sourcemapTargets;
+    const formats = (_h = (_g = parsedArgs.formats) === null || _g === void 0 ? void 0 : _g.split(',').map((arg) => arg.trim())) !== null && _h !== void 0 ? _h : defaults.formats;
+    const preprocess = (_k = (_j = parsedArgs.preprocess) === null || _j === void 0 ? void 0 : _j.split(',').map((arg) => arg.trim())) !== null && _k !== void 0 ? _k : defaults.preprocess;
+    const dir = (_l = parsedArgs.dir) !== null && _l !== void 0 ? _l : defaults.dir;
+    return {
+        umdTargets,
+        compressTargets,
+        sourcemapTargets,
+        formats,
+        preprocess,
+        dir
+    };
+}
+
+async function getPackage() {
+    const pkgPath = path__default["default"].resolve('package.json');
+    const buffer = await fs__default["default"].readFile(pkgPath);
+    return [pkgPath, JSON.parse(buffer.toString())];
+}
+
+function getBuildPlugins(format, config) {
+    const result = [
+        resolve__default["default"](),
+        commonjs__default["default"](),
+        typescript__default["default"]()
+    ];
+    if (config.preprocess.length) {
+        result.unshift(preprocess__default["default"]({ include: config.preprocess.map(name => `src/${name}.ts`), context: getPreprocessContext(format) }));
+    }
+    return result;
+}
+function getPreprocessContext(format) {
+    if (format == 'es') {
+        return { esm: true };
+    }
+    else {
+        return { cjs: true };
+    }
+}
+function getOutputPlugins(format, config) {
+    return config.compressTargets.includes(format) ? [rollupPluginTerser.terser({
+            mangle: {
+                properties: {
+                    regex: /_$/
+                }
+            }
+        })] : [];
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getHelpers(pkg) {
+    const scopeTest = /(@.+)\/.+$/g.exec(pkg.name);
+    let scope = undefined;
+    if (scopeTest && scopeTest[0]) {
+        scope = scopeTest[0];
+    }
+    const external = scope != null
+        ? (id) => id.indexOf('node_modules') >= 0 || id.indexOf(scope) >= 0 || isBuiltinModule__default["default"](id)
+        : (id) => id.indexOf('node_modules') >= 0 || isBuiltinModule__default["default"](id);
+    function getGlobalName(anInput) {
+        return camelCase__default["default"](path__default["default"].join(pkg.name, path__default["default"].basename(anInput, '.ts') !== 'index' ? path__default["default"].basename(anInput, '.ts') : ''));
+    }
+    function getExternalGlobalName(id) {
+        if (path__default["default"].isAbsolute(id)) {
+            return getGlobalName(path__default["default"].relative(__dirname, id));
+        }
+        return camelCase__default["default"](id);
+    }
+    return {
+        external,
+        getGlobalName,
+        getExternalGlobalName,
+        umdFilter
+    };
+}
+function umdFilter(config, filename) {
+    const id = path__default["default"].basename(filename, '.ts');
+    return config.umdTargets.includes(id);
+}
+function toArray(object) {
+    if (Array.isArray(object)) {
+        return object;
+    }
+    return [object];
+}
+function isExternalInput(id, inputs, currentInput) {
+    let normalizedPath;
+    if (path__default["default"].isAbsolute(id)) {
+        normalizedPath = './' + path__default["default"].relative(process.cwd(), id);
+    }
+    else {
+        normalizedPath = './' + path__default["default"].join('src', id + '.ts');
+    }
+    return normalizedPath !== currentInput && inputs.includes(normalizedPath);
+}
+function formatInput(input) {
+    return Array.isArray(input) ? input.join(', ') : input;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function formatOutput(output, field) {
+    return Array.isArray(output) ? output.map(item => item[field]).join(', ') : output[field];
+}
+function getTimeDiff(starting) {
+    const now = Date.now();
+    if (now - starting > 1000) {
+        return `${((now - starting) / 1000).toFixed(1)}s`;
+    }
+    return `${now - starting}ms`;
+}
+
+function getRollupConfigs(inputs, config, helpers) {
+    const configs = [];
+    if (config.formats.includes('es')) {
+        configs.push({
+            input: inputs,
+            output: {
+                format: 'es',
+                dir: config.dir,
+                entryFileNames: '[name].mjs',
+                chunkFileNames: '[name].mjs',
+                plugins: getOutputPlugins('es', config),
+                sourcemap: config.sourcemapTargets.includes('es')
+            },
+            plugins: getBuildPlugins('es', config),
+            external: helpers.external
+        });
+    }
+    if (config.formats.includes('cjs')) {
+        configs.push({
+            input: inputs,
+            output: {
+                format: 'cjs',
+                dir: config.dir,
+                entryFileNames: '[name].cjs',
+                chunkFileNames: '[name].cjs',
+                exports: 'auto',
+                plugins: getOutputPlugins('cjs', config),
+                sourcemap: config.sourcemapTargets.includes('cjs')
+            },
+            plugins: getBuildPlugins('cjs', config),
+            external: helpers.external
+        });
+    }
+    const umdConfigs = inputs.filter((input) => umdFilter(config, input)).map(currentInput => ({
+        input: currentInput,
+        output: {
+            format: 'umd',
+            dir: config.dir,
+            entryFileNames: '[name].umd.js',
+            name: helpers.getGlobalName(currentInput),
+            globals: helpers.getExternalGlobalName,
+            plugins: getOutputPlugins('umd', config),
+            sourcemap: config.sourcemapTargets.includes('umd')
+        },
+        plugins: getBuildPlugins('umd', config),
+        external: (id) => helpers.external(id) || isExternalInput(id, inputs, currentInput)
+    }));
+    if (umdConfigs && umdConfigs.length) {
+        configs.push(...umdConfigs);
+    }
+    return configs;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function processPackage(pkg, config) {
+    var _a;
+    const input = [];
+    const logger$1 = logger.createLogger();
+    if (typeof pkg.name !== 'string') {
+        logger$1.finish('expecting name to be a string in package.json', 3 /* error */);
+        process.exit(-1);
+    }
+    if (!Array.isArray(pkg.files)) {
+        pkg.files = [];
+    }
+    if (!pkg.files.includes(config.dir)) {
+        pkg.files.push(config.dir);
+    }
+    if (typeof pkg.exports !== 'object') {
+        pkg.exports = {};
+    }
+    if (pkg.exports['.'] == null) {
+        pkg.exports['.'] = {};
+    }
+    if (typeof pkg.umd === 'string') {
+        pkg.umd = `./${config.dir}/index.umd.js`;
+        if (!config.umdTargets.includes('index')) {
+            config.umdTargets.push('index');
+        }
+    }
+    if (typeof pkg.main !== 'string') {
+        pkg.main = `./${config.dir}/index.cjs`;
+    }
+    if (pkg.main !== pkg.exports['.'].require) {
+        pkg.exports['.'].require = pkg.main;
+    }
+    if (typeof pkg.module !== 'string') {
+        pkg.module = `./${config.dir}/index.mjs`;
+    }
+    if (pkg.module !== ((_a = pkg.exports['.']) === null || _a === void 0 ? void 0 : _a.default)) {
+        pkg.exports['.'].default = pkg.module;
+    }
+    if (umdFilter(config, 'index')) {
+        pkg.unpkg = `./${config.dir}/index.umd.js`;
+    }
+    for (const id in pkg.exports) {
+        const basename = id == '.' ? 'index' : path__default["default"].basename(id);
+        if (typeof pkg.exports[id] !== 'object') {
+            pkg.exports[id] = {};
+        }
+        pkg.exports[id].require = `./${config.dir}/${basename}.cjs`;
+        pkg.exports[id].default = `./${config.dir}/${basename}.mjs`;
+        if (basename !== 'index') {
+            if (!pkg.files.includes(basename)) {
+                pkg.files.push(basename);
+            }
+        }
+        input.push(`./src/${basename}.ts`);
+    }
+    return input;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function writePackage(pkgPath, pkg) {
+    await fs__default["default"].writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+}
+
+async function cleanupDir(dir) {
+    try {
+        await fs__default["default"].rm(dir, { recursive: true });
+    }
+    catch (e) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (e['code'] !== 'ENOENT') {
+            throw e;
+        }
+    }
+}
+
+async function execute() {
+    try {
+        const [pkgPath, pkg] = await getPackage();
+        const config = getCliOptions();
+        const inputs = processPackage(pkg, config);
+        const helpers = getHelpers(pkg);
+        const rollupConfigs = getRollupConfigs(inputs, config, helpers);
+        await cleanupDir(config.dir);
+        for (const config of rollupConfigs) {
+            const logger$1 = logger.createLogger();
+            const time = Date.now();
+            logger$1.start(`building ${formatInput(config.input)} → ${formatOutput(config.output, 'dir')}, ${formatOutput(config.output, 'format')}`, 1 /* info */);
+            const bundle = await rollup.rollup(config);
+            await Promise.all(toArray(config.output).map(config => bundle.write(config)));
+            await bundle.close();
+            logger$1.finish(`finished ${formatInput(config.input)} → ${formatOutput(config.output, 'dir')}, ${formatOutput(config.output, 'format')} in ${getTimeDiff(time)}`, 1 /* info */);
+        }
+        await writePackage(pkgPath, pkg);
+        await createSubpackages(inputs, config);
+    }
+    catch (e) {
+        logger.createLogger().finish(`${e}}`, 3 /* error */);
+        process.exit(-1);
+    }
+}
+execute();

package/dist/process-pkg.d.ts

@@ -0,0 +1,2 @@
+import { getCliOptions } from './get-cli-options';
+export declare function processPackage(pkg: any, config: ReturnType<typeof getCliOptions>): string[];

package/dist/write-pkg.d.ts

@@ -0,0 +1 @@
+export declare function writePackage(pkgPath: string, pkg: any): Promise<void>;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "version": "1.1.0",
+  "license": "MIT",
+  "name": "pkgbld",
+  "author": {
+    "name": "Konstantin Shutkin"
+  },
+  "funding": "https://www.donationalerts.com/r/excitingcode",
+  "bin": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kshutkin/package-build.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kshutkin/rollup-extras/issues"
+  },
+  "homepage": "https://github.com/kshutkin/package-build/README.md",
+  "keywords": [
+    "pkgbld",
+    "build",
+    "exports",
+    "rollup"
+  ],
+  "scripts": {
+    "build": "rimraf dist && rollup -c && node binify.js",
+    "lint": "eslint ./src",
+    "semantic-release": "npx semantic-release"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "6.0.1",
+    "@semantic-release/commit-analyzer": "9.0.1",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/npm": "8.0.2",
+    "@semantic-release/release-notes-generator": "10.0.2",
+    "@types/lodash": "4.14.178",
+    "@typescript-eslint/eslint-plugin": "5.8.0",
+    "@typescript-eslint/parser": "5.8.0",
+    "conventional-changelog-angular": "5.0.13",
+    "eslint": "8.5.0",
+    "semantic-release": "18.0.0",
+    "rimfar": "3.0.2-omega"
+  },
+  "dependencies": {
+    "@niceties/logger": "1.0.4",
+    "is-builtin-module": "3.1.0",
+    "lodash": "4.17.21",
+    "rollup": "2.60.1",
+    "rollup-plugin-terser": "7.0.2",
+    "rollup-plugin-typescript2": "0.31.1",
+    "rollup-plugin-preprocess": "0.0.4",
+    "@rollup/plugin-commonjs": "21.0.1",
+    "@rollup/plugin-node-resolve": "13.0.6",
+    "typescript": "4.5.x",
+    "minimist": "1.2.5"
+  }
+}