Project init.

Author: Martynas Žilinskas

.gitignore

@@ -0,0 +1,25 @@
+# =========================
+# Windows detritus
+# =========================
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Mac desktop service store files
+.DS_Store
+
+
+# NuGet Packages Directory
+node_modules
+
+wwwroot
+dist
+test
+cpj.config.json

.npmignore

@@ -0,0 +1,5 @@
+src
+test
+cpj.config.json
+tsconfig.json
+.npmignore

index.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cli');

package.json

@@ -0,0 +1,24 @@
+{
+    "name": "cleanup-package-json",
+    "version": "0.0.1",
+    "description": "Cleans package.json file.",
+    "main": "index.js",
+    "scripts": {
+      "build": "tsc -p .",
+      "prepublish": "npm run build"
+    },
+    "author": "Martynas Zilinskas <martynas@quatrodev.com>",
+    "license": "GPL-3.0",
+    "devDependencies": {
+        "@types/node": "^6.0.31",
+        "@types/optimist": "0.0.28",
+        "typescript": "^2.0.0",
+        "typings": "^1.3.1"
+    },
+    "dependencies": {
+        "optimist": "^0.6.1"
+    },
+    "bin": {
+        "cleanup-package-json": "./dist/cli.js"
+    }
+}

src/cleanup.ts

@@ -0,0 +1,114 @@
+import * as fs from 'fs';
+import * as Contracts from './contracts';
+import * as Helpers from './helpers';
+
+export default class Cleanup {
+
+    constructor(private config: Contracts.Config) { }
+
+    public Clean() {
+        let packageJSON = this.readPackageJSON();
+        let modifiedPackageJSON = Helpers.Clone(packageJSON);
+        let excluded = false;
+
+        if (this.config.exclude != null) {
+            modifiedPackageJSON = this.exclude(modifiedPackageJSON);
+            excluded = true;
+        }
+        if (this.config.include != null) {
+            modifiedPackageJSON = this.include(packageJSON, modifiedPackageJSON, excluded);
+        }
+
+        if (this.config.backup != null && this.config.backup) {
+            this.writePackageJSON(packageJSON, 'package.bak.json');
+        }
+
+        if (this.config.writeChanges != null && this.config.writeChanges || this.config.writeChanges == null) {
+            this.writePackageJSON(modifiedPackageJSON, 'package.json');
+        }
+
+        return modifiedPackageJSON;
+    }
+
+    private exclude(packageJSON: Contracts.PackageJSONSkeleton) {
+        let excludeConfig = this.config.exclude!;
+        for (let key in excludeConfig) {
+            if (this.configItemAll(excludeConfig[key])) {
+                delete packageJSON[key];
+            } else {
+                excludeConfig[key].forEach((value) => {
+                    let item = packageJSON[key];
+
+                    if (Array.isArray(item)) {
+                        item = item as Array<string>;
+                        packageJSON[key] = item.filter(x => x !== value);
+                    } else if (typeof item === 'object') {
+                        item = item as Contracts.PackageJSONSkeletonDictionary;
+                        for (let pkey in item) {
+                            if (pkey === value) {
+                                delete item[pkey];
+                            }
+                        }
+                    } else {
+                        console.warn(`[Warning] ${key} is not found in package.json.`);
+                    }
+                });
+            }
+        }
+
+        return packageJSON;
+    }
+
+    private include(packageJSON: Contracts.PackageJSONSkeleton, modifiedPackageJSON: Contracts.PackageJSONSkeleton, excluded: boolean) {
+        let includeConfig = this.config.include!;
+        // Include only listed in Config.
+        if (!excluded) {
+            modifiedPackageJSON = {}
+        }
+        for (let key in includeConfig) {
+
+            if (this.configItemAll(includeConfig[key])) {
+                modifiedPackageJSON[key] = packageJSON[key];
+            } else {
+                includeConfig[key].forEach((value) => {
+                    let item = packageJSON[key];
+                    if (Array.isArray(item)) {
+                        item = item as Array<string>;
+                        let modifiedItem = modifiedPackageJSON[key] as Array<string>;
+                        if (modifiedItem == null) {
+                            modifiedItem = new Array<string>();
+                        }
+                        if (modifiedItem.indexOf(value) === -1) {
+                            modifiedItem.push(value);
+                        }
+
+                        modifiedPackageJSON[key] = modifiedItem;
+                    } else if (typeof item === 'object') {
+                        item = item as Contracts.PackageJSONSkeletonDictionary;
+
+                        if (packageJSON[key][value] != null) {
+                            modifiedPackageJSON[key][value] = packageJSON[key][value];
+                        }
+                    } else {
+                        console.warn(`[Warning] ${key} is not found in package.json.`);
+                    }
+                });
+            }
+        }
+
+        return modifiedPackageJSON;
+    }
+
+    private configItemAll(itemSettings: Array<string>): boolean {
+        return (itemSettings.length > 0 && itemSettings[0] === '*');
+    }
+
+    private readPackageJSON(fileName: string = 'package.json'): Contracts.PackageJSONSkeleton {
+        return JSON.parse(fs.readFileSync(fileName, 'utf8'));
+    }
+
+    private writePackageJSON(packageJSON: Contracts.PackageJSONSkeleton, file: string) {
+        let data = JSON.stringify(packageJSON, null, 4);
+        fs.writeFileSync(file, data);
+    }
+}

src/cli.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import * as optimist from 'optimist';
+import * as Contracts from './contracts';
+import * as fs from 'fs';
+import * as path from 'path';
+import Cleanup from './cleanup';
+
+const DEFAULT_CONFIG_NAME = 'cpj.config.json';
+
+let opt = optimist
+    .options('h', {
+        alias: 'help',
+        describe: 'Prints this message.'
+    })
+    .options('c', {
+        alias: 'config',
+        describe: 'Path to config.'
+    })
+    .usage('Usage: cleanup-package-json [options]')
+    .boolean(['h', 'v'])
+    .string(['c']);
+
+class Cli {
+    constructor(opt: optimist.Parser) {
+        let argv = opt.argv as Contracts.Arguments;
+
+        if (argv.help) {
+            console.info(opt.help());
+        } else {
+            let configFileName = argv.config || DEFAULT_CONFIG_NAME;
+            this.main(configFileName);
+        }
+    }
+
+    private async main(configFileName: string) {
+        let fullPath = path.join(process.cwd(), configFileName);
+        let configExists = await this.checkConfigIsExist(fullPath);
+
+        if (configExists) {
+            let config = await this.readConfigFile(configFileName).catch((err) => {
+                this.throwError(`[Error] Config file ${DEFAULT_CONFIG_NAME} is not valid.`);
+            }) as Contracts.ConfigItems;
+
+            try {
+                let cleanup = new Cleanup(config);
+                cleanup.Clean();
+                console.info('[Success] Done cleaning up');
+            } catch(e) {
+                this.throwError(`[Failed] ${e}`);
+            }
+        } else {
+            this.throwError(`[Error] Config file ${DEFAULT_CONFIG_NAME} was not found.`);
+        }
+
+    }
+
+    private throwError(text: string) {
+        console.error(text);
+        process.exit(1);
+    }
+
+    private async checkConfigIsExist(fullPath: string) {
+        return new Promise<boolean>((resolve, reject) => {
+            let fullPath = path.join(process.cwd(), DEFAULT_CONFIG_NAME);
+            fs.access(fullPath, fs.F_OK, async (err) => {
+                if (!err) {
+                    resolve(true);
+                } else {
+                    resolve(false);
+                }
+            });
+        });
+    }
+
+    private async readConfigFile(fullPath: string) {
+        return new Promise<Contracts.Config>((resolve, reject) => {
+            fs.readFile(fullPath, 'utf8', (err, data) => {
+                if (!err) {
+                    let configData: Contracts.Config;
+                    try {
+                        configData = JSON.parse(data);
+                        resolve(configData);
+                    } catch (e) {
+                        reject(e);
+                    }
+                } else {
+                    reject(err);
+                }
+            });
+        });
+    }
+}
+
+new Cli(opt);

src/contracts.ts

@@ -0,0 +1,26 @@
+export interface Arguments {
+    [arg: string]: string | boolean;
+    config: string;
+    help: boolean;
+}
+
+export interface ConfigItems {
+    [id: string]: Array<string>;
+}
+
+export interface Config {
+    include?: ConfigItems;
+    exclude?: ConfigItems;
+    backup?: string;
+    writeChanges?: boolean;
+}
+
+export interface PackageJSONSkeletonDictionary {
+    [id: string]: string;
+}
+
+export type PackageJSONSKeletonItem = PackageJSONSkeletonDictionary | Array<string>;
+
+export interface PackageJSONSkeleton {
+    [id: string]: PackageJSONSKeletonItem;
+}

src/helpers.ts

@@ -0,0 +1,9 @@
+export function Clone<T>(obj: T) {
+    var target: any = {};
+    for (var key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            target[key] = (<any>obj)[key];
+        }
+    }
+    return target;
+}

tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": false,
+        "removeComments": false,
+        "preserveConstEnums": true,
+        "noLib": false,
+        "sourceMap": false,
+        "outDir": "dist",
+        "rootDir": "src",
+        "declaration": false,
+        "typeRoots": [
+            "node_modules/@types"
+        ],
+        "noUnusedLocals": true,
+        "noImplicitThis": true,
+        "noImplicitUseStrict": true,
+        "strictNullChecks": true
+    },
+    "exclude": [
+        "node_modules"
+    ]
+}