@gadmin2n/schematics 0.0.55

package/dist/lib/sub-app/sub-app.factory.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const fse = require("fs-extra");
+const jsonc_parser_1 = require("jsonc-parser");
+const formatting_1 = require("../../utils/formatting");
+const defaults_1 = require("../defaults");
+function main(options) {
+    const appName = getAppNameFromPackageJson();
+    options = transform(options);
+    return (0, schematics_1.chain)([
+        updateTsConfig(),
+        updatePackageJson(options, appName),
+        (tree, context) => isMonorepo(tree)
+            ? (0, schematics_1.noop)()(tree, context)
+            : (0, schematics_1.chain)([
+                (0, schematics_1.branchAndMerge)((0, schematics_1.mergeWith)(generateWorkspace(options, appName))),
+                moveDefaultAppToApps(options.path, appName, options.sourceRoot),
+            ])(tree, context),
+        addAppsToCliOptions(options.path, options.name, appName),
+        (0, schematics_1.branchAndMerge)((0, schematics_1.mergeWith)(generate(options))),
+    ]);
+}
+exports.main = main;
+function getAppNameFromPackageJson() {
+    try {
+        if (!fse.existsSync('./package.json')) {
+            return defaults_1.DEFAULT_DIR_ENTRY_APP;
+        }
+        const packageJson = fse.readJsonSync('./package.json');
+        if (!packageJson.name) {
+            return defaults_1.DEFAULT_DIR_ENTRY_APP;
+        }
+        let name = packageJson.name;
+        name = name.replace(/[^\w.]+/g, '-').replace(/\-+/g, '-');
+        return name[0] === '-' ? name.substr(1) : name;
+    }
+    catch (_a) {
+        return defaults_1.DEFAULT_DIR_ENTRY_APP;
+    }
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_APPS_PATH;
+    if (!target.name) {
+        target.name = defaults_1.DEFAULT_APP_NAME;
+    }
+    target.language = !!target.language ? target.language : defaults_1.DEFAULT_LANGUAGE;
+    target.name = (0, formatting_1.normalizeToKebabOrSnakeCase)(target.name);
+    target.path =
+        target.path !== undefined
+            ? (0, core_1.join)((0, core_1.normalize)(defaultSourceRoot), target.path)
+            : (0, core_1.normalize)(defaultSourceRoot);
+    return target;
+}
+function isMonorepo(host) {
+    const nestFileExists = host.exists('nest.json');
+    const nestCliFileExists = host.exists('nest-cli.json');
+    if (!nestFileExists && !nestCliFileExists) {
+        return false;
+    }
+    const filename = nestCliFileExists ? 'nest-cli.json' : 'nest.json';
+    const source = host.read(filename);
+    if (!source) {
+        return false;
+    }
+    const sourceText = source.toString('utf-8');
+    const optionsObj = (0, jsonc_parser_1.parse)(sourceText);
+    return !!optionsObj.monorepo;
+}
+function updateJsonFile(host, path, callback) {
+    const source = host.read(path);
+    if (source) {
+        const sourceText = source.toString('utf-8');
+        const json = (0, jsonc_parser_1.parse)(sourceText);
+        callback(json);
+        host.overwrite(path, JSON.stringify(json, null, 2));
+    }
+    return host;
+}
+function updateTsConfig() {
+    return (host) => {
+        if (!host.exists('tsconfig.json')) {
+            return host;
+        }
+        return updateJsonFile(host, 'tsconfig.json', (tsconfig) => {
+            if (!tsconfig.compilerOptions) {
+                tsconfig.compilerOptions = {};
+            }
+            if (!tsconfig.compilerOptions.baseUrl) {
+                tsconfig.compilerOptions.baseUrl = './';
+            }
+            if (!tsconfig.compilerOptions.paths) {
+                tsconfig.compilerOptions.paths = {};
+            }
+        });
+    };
+}
+function updatePackageJson(options, defaultAppName) {
+    return (host) => {
+        if (!host.exists('package.json')) {
+            return host;
+        }
+        return updateJsonFile(host, 'package.json', (packageJson) => {
+            updateNpmScripts(packageJson.scripts, options, defaultAppName);
+            updateJestOptions(packageJson.jest, options);
+        });
+    };
+}
+function updateNpmScripts(scripts, options, defaultAppName) {
+    if (!scripts) {
+        return;
+    }
+    const defaultFormatScriptName = 'format';
+    const defaultTestScriptName = 'test:e2e';
+    if (!scripts[defaultTestScriptName] && !scripts[defaultFormatScriptName]) {
+        return;
+    }
+    if (scripts[defaultTestScriptName] &&
+        scripts[defaultTestScriptName].indexOf(options.path) < 0) {
+        const defaultTestDir = 'test';
+        const newTestDir = (0, core_1.join)(options.path, defaultAppName, defaultTestDir);
+        scripts[defaultTestScriptName] = scripts[defaultTestScriptName].replace(defaultTestDir, newTestDir);
+    }
+    if (scripts[defaultFormatScriptName] &&
+        scripts[defaultFormatScriptName].indexOf(defaults_1.DEFAULT_PATH_NAME) >= 0) {
+        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_APPS_PATH;
+        scripts[defaultFormatScriptName] = `prettier --write "${defaultSourceRoot}/**/*.ts" "${defaults_1.DEFAULT_LIB_PATH}/**/*.ts"`;
+    }
+}
+function updateJestOptions(jestOptions, options) {
+    if (!jestOptions) {
+        return;
+    }
+    if (jestOptions.rootDir === defaults_1.DEFAULT_PATH_NAME) {
+        jestOptions.rootDir = '.';
+        jestOptions.coverageDirectory = './coverage';
+    }
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_APPS_PATH;
+    const jestSourceRoot = `<rootDir>/${defaultSourceRoot}/`;
+    if (!jestOptions.roots) {
+        jestOptions.roots = [jestSourceRoot];
+    }
+    else if (jestOptions.roots.indexOf(jestSourceRoot) < 0) {
+        jestOptions.roots.push(jestSourceRoot);
+        const originalSourceRoot = `<rootDir>/src/`;
+        const originalSourceRootIndex = jestOptions.roots.indexOf(originalSourceRoot);
+        if (originalSourceRootIndex >= 0) {
+            jestOptions.roots.splice(originalSourceRootIndex, 1);
+        }
+    }
+}
+function moveDefaultAppToApps(projectRoot, appName, sourceRoot = defaults_1.DEFAULT_PATH_NAME) {
+    return (host) => {
+        if (process.env.NODE_ENV === defaults_1.TEST_ENV) {
+            return host;
+        }
+        try {
+            if (fse.existsSync(sourceRoot)) {
+                fse.moveSync(sourceRoot, (0, core_1.join)(projectRoot, appName, sourceRoot));
+            }
+            const testDir = 'test';
+            if (fse.existsSync(testDir)) {
+                fse.moveSync(testDir, (0, core_1.join)(projectRoot, appName, testDir));
+            }
+        }
+        catch (err) {
+            throw new schematics_1.SchematicsException(`The "${projectRoot}" directory exists already.`);
+        }
+        return host;
+    };
+}
+function addAppsToCliOptions(projectRoot, projectName, appName) {
+    const rootPath = (0, core_1.join)(projectRoot, projectName);
+    const project = {
+        type: defaults_1.PROJECT_TYPE.APPLICATION,
+        root: rootPath,
+        entryFile: 'main',
+        sourceRoot: (0, core_1.join)(rootPath, defaults_1.DEFAULT_PATH_NAME),
+        compilerOptions: {
+            tsConfigPath: (0, core_1.join)(rootPath, 'tsconfig.app.json'),
+        },
+    };
+    return (host) => {
+        const nestFileExists = host.exists('nest.json');
+        let nestCliFileExists = host.exists('nest-cli.json');
+        if (!nestCliFileExists && !nestFileExists) {
+            host.create('nest-cli.json', '{}');
+            nestCliFileExists = true;
+        }
+        return updateJsonFile(host, nestCliFileExists ? 'nest-cli.json' : 'nest.json', (optionsFile) => {
+            updateMainAppOptions(optionsFile, projectRoot, appName);
+            if (!optionsFile.projects) {
+                optionsFile.projects = {};
+            }
+            if (optionsFile.projects[projectName]) {
+                throw new schematics_1.SchematicsException(`Project "${projectName}" exists in this workspace already.`);
+            }
+            optionsFile.projects[projectName] = project;
+        });
+    };
+}
+function updateMainAppOptions(optionsFile, projectRoot, appName) {
+    if (optionsFile.monorepo) {
+        return;
+    }
+    const rootFilePath = (0, core_1.join)(projectRoot, appName);
+    const tsConfigPath = (0, core_1.join)(rootFilePath, 'tsconfig.app.json');
+    optionsFile.monorepo = true;
+    optionsFile.root = rootFilePath;
+    optionsFile.sourceRoot = (0, core_1.join)(projectRoot, appName, optionsFile.sourceRoot || defaults_1.DEFAULT_PATH_NAME);
+    if (!optionsFile.compilerOptions) {
+        optionsFile.compilerOptions = {};
+    }
+    optionsFile.compilerOptions.webpack = true;
+    optionsFile.compilerOptions.tsConfigPath = tsConfigPath;
+    if (!optionsFile.projects) {
+        optionsFile.projects = {};
+    }
+    optionsFile.projects[appName] = {
+        type: defaults_1.PROJECT_TYPE.APPLICATION,
+        root: rootFilePath,
+        entryFile: optionsFile.entryFile || 'main',
+        sourceRoot: (0, core_1.join)(rootFilePath, defaults_1.DEFAULT_PATH_NAME),
+        compilerOptions: {
+            tsConfigPath,
+        },
+    };
+}
+function generateWorkspace(options, appName) {
+    const path = (0, core_1.join)(options.path, appName);
+    return (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./workspace', options.language)), [
+        (0, schematics_1.template)(Object.assign(Object.assign(Object.assign({}, core_1.strings), options), { name: appName })),
+        (0, schematics_1.move)(path),
+    ]);
+}
+function generate(options) {
+    const path = (0, core_1.join)(options.path, options.name);
+    return (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
+        (0, schematics_1.template)(Object.assign(Object.assign({}, core_1.strings), options)),
+        (0, schematics_1.move)(path),
+    ]);
+}

package/dist/lib/sub-app/workspace/js/.babelrc

@@ -0,0 +1,4 @@
+{
+  "presets": ["env", "stage-0"],
+  "plugins": ["transform-decorators-legacy"]
+}

package/dist/lib/sub-app/workspace/js/index.js

@@ -0,0 +1,2 @@
+require('@babel/register');
+require('./src/main');

package/dist/lib/sub-app/workspace/js/jsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+      "target": "ES6",
+      "experimentalDecorators": true
+  },
+  "exclude": [
+      "node_modules",
+      "dist"
+  ]
+}

package/dist/lib/sub-app/workspace/ts/tsconfig.app.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": false,
+    "outDir": "../../dist/apps/<%= name %>"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

package/dist/utils/change.d.ts

@@ -0,0 +1,46 @@
+import { UpdateRecorder } from '@angular-devkit/schematics';
+export interface Host {
+    write(path: string, content: string): Promise<void>;
+    read(path: string): Promise<string>;
+}
+export interface Change {
+    apply(host: Host): Promise<void>;
+    readonly path: string | null;
+    readonly order: number;
+    readonly description: string;
+}
+export declare class NoopChange implements Change {
+    description: string;
+    order: number;
+    path: any;
+    apply(): Promise<void>;
+}
+export declare class InsertChange implements Change {
+    path: string;
+    pos: number;
+    toAdd: string;
+    order: number;
+    description: string;
+    constructor(path: string, pos: number, toAdd: string);
+    apply(host: Host): Promise<void>;
+}
+export declare class RemoveChange implements Change {
+    path: string;
+    private pos;
+    toRemove: string;
+    order: number;
+    description: string;
+    constructor(path: string, pos: number, toRemove: string);
+    apply(host: Host): Promise<void>;
+}
+export declare class ReplaceChange implements Change {
+    path: string;
+    private pos;
+    oldText: string;
+    newText: string;
+    order: number;
+    description: string;
+    constructor(path: string, pos: number, oldText: string, newText: string);
+    apply(host: Host): Promise<void>;
+}
+export declare function applyToUpdateRecorder(recorder: UpdateRecorder, changes: Change[]): void;

package/dist/utils/change.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyToUpdateRecorder = exports.ReplaceChange = exports.RemoveChange = exports.InsertChange = exports.NoopChange = void 0;
+class NoopChange {
+    constructor() {
+        this.description = 'No operation.';
+        this.order = Infinity;
+        this.path = null;
+    }
+    apply() { return Promise.resolve(); }
+}
+exports.NoopChange = NoopChange;
+class InsertChange {
+    constructor(path, pos, toAdd) {
+        this.path = path;
+        this.pos = pos;
+        this.toAdd = toAdd;
+        if (pos < 0) {
+            throw new Error('Negative positions are invalid');
+        }
+        this.description = `Inserted ${toAdd} into position ${pos} of ${path}`;
+        this.order = pos;
+    }
+    apply(host) {
+        return host.read(this.path).then(content => {
+            const prefix = content.substring(0, this.pos);
+            const suffix = content.substring(this.pos);
+            return host.write(this.path, `${prefix}${this.toAdd}${suffix}`);
+        });
+    }
+}
+exports.InsertChange = InsertChange;
+class RemoveChange {
+    constructor(path, pos, toRemove) {
+        this.path = path;
+        this.pos = pos;
+        this.toRemove = toRemove;
+        if (pos < 0) {
+            throw new Error('Negative positions are invalid');
+        }
+        this.description = `Removed ${toRemove} into position ${pos} of ${path}`;
+        this.order = pos;
+    }
+    apply(host) {
+        return host.read(this.path).then(content => {
+            const prefix = content.substring(0, this.pos);
+            const suffix = content.substring(this.pos + this.toRemove.length);
+            return host.write(this.path, `${prefix}${suffix}`);
+        });
+    }
+}
+exports.RemoveChange = RemoveChange;
+class ReplaceChange {
+    constructor(path, pos, oldText, newText) {
+        this.path = path;
+        this.pos = pos;
+        this.oldText = oldText;
+        this.newText = newText;
+        if (pos < 0) {
+            throw new Error('Negative positions are invalid');
+        }
+        this.description = `Replaced ${oldText} into position ${pos} of ${path} with ${newText}`;
+        this.order = pos;
+    }
+    apply(host) {
+        return host.read(this.path).then(content => {
+            const prefix = content.substring(0, this.pos);
+            const suffix = content.substring(this.pos + this.oldText.length);
+            const text = content.substring(this.pos, this.pos + this.oldText.length);
+            if (text !== this.oldText) {
+                return Promise.reject(new Error(`Invalid replace: "${text}" != "${this.oldText}".`));
+            }
+            return host.write(this.path, `${prefix}${this.newText}${suffix}`);
+        });
+    }
+}
+exports.ReplaceChange = ReplaceChange;
+function applyToUpdateRecorder(recorder, changes) {
+    for (const change of changes) {
+        if (change instanceof InsertChange) {
+            recorder.insertLeft(change.pos, change.toAdd);
+        }
+        else if (change instanceof RemoveChange) {
+            recorder.remove(change.order, change.toRemove.length);
+        }
+        else if (change instanceof ReplaceChange) {
+            recorder.remove(change.order, change.oldText.length);
+            recorder.insertLeft(change.order, change.newText);
+        }
+        else if (!(change instanceof NoopChange)) {
+            throw new Error('Unknown Change type encountered when updating a recorder.');
+        }
+    }
+}
+exports.applyToUpdateRecorder = applyToUpdateRecorder;

package/dist/utils/dependencies.utils.d.ts

@@ -0,0 +1,15 @@
+import { Tree } from '@angular-devkit/schematics';
+export declare enum NodeDependencyType {
+    Default = "dependencies",
+    Dev = "devDependencies",
+    Peer = "peerDependencies",
+    Optional = "optionalDependencies"
+}
+export interface NodeDependency {
+    type: NodeDependencyType;
+    name: string;
+    version: string;
+    overwrite?: boolean;
+}
+export declare function addPackageJsonDependency(tree: Tree, dependency: NodeDependency, pkgJsonPath?: string): void;
+export declare function getPackageJsonDependency(tree: Tree, name: string, pkgJsonPath?: string): NodeDependency | null;

package/dist/utils/dependencies.utils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJsonDependency = exports.addPackageJsonDependency = exports.NodeDependencyType = void 0;
+const json_file_util_1 = require("./json-file.util");
+const PKG_JSON_PATH = '/package.json';
+var NodeDependencyType;
+(function (NodeDependencyType) {
+    NodeDependencyType["Default"] = "dependencies";
+    NodeDependencyType["Dev"] = "devDependencies";
+    NodeDependencyType["Peer"] = "peerDependencies";
+    NodeDependencyType["Optional"] = "optionalDependencies";
+})(NodeDependencyType = exports.NodeDependencyType || (exports.NodeDependencyType = {}));
+const ALL_DEPENDENCY_TYPE = [
+    NodeDependencyType.Default,
+    NodeDependencyType.Dev,
+    NodeDependencyType.Optional,
+    NodeDependencyType.Peer,
+];
+function addPackageJsonDependency(tree, dependency, pkgJsonPath = PKG_JSON_PATH) {
+    const json = new json_file_util_1.JSONFile(tree, pkgJsonPath);
+    const { overwrite, type, name, version } = dependency;
+    const path = [type, name];
+    if (overwrite || !json.get(path)) {
+        json.modify(path, version);
+    }
+}
+exports.addPackageJsonDependency = addPackageJsonDependency;
+function getPackageJsonDependency(tree, name, pkgJsonPath = PKG_JSON_PATH) {
+    const json = new json_file_util_1.JSONFile(tree, pkgJsonPath);
+    for (const depType of ALL_DEPENDENCY_TYPE) {
+        const version = json.get([depType, name]);
+        if (typeof version === 'string') {
+            return {
+                type: depType,
+                name: name,
+                version,
+            };
+        }
+    }
+    return null;
+}
+exports.getPackageJsonDependency = getPackageJsonDependency;

package/dist/utils/export-from.declarator.d.ts

@@ -0,0 +1,10 @@
+import { DeclarationOptions } from './module.declarator';
+import { PathSolver } from './path.solver';
+export declare class ExportFromDeclarator {
+    private solver;
+    constructor(solver?: PathSolver);
+    declare(content: string, options: DeclarationOptions): string;
+    private findImportsEndpoint;
+    private buildLineToInsert;
+    private computeRelativePath;
+}

package/dist/utils/export-from.declarator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportFromDeclarator = void 0;
+const core_1 = require("@angular-devkit/core");
+const path_solver_1 = require("./path.solver");
+class ExportFromDeclarator {
+    constructor(solver = new path_solver_1.PathSolver()) {
+        this.solver = solver;
+    }
+    declare(content, options) {
+        const toInsert = this.buildLineToInsert(options);
+        const contentLines = content.split('\n');
+        const finalImportIndex = this.findImportsEndpoint(contentLines);
+        contentLines.splice(finalImportIndex + 1, 0, toInsert);
+        return contentLines.join('\n');
+    }
+    findImportsEndpoint(contentLines) {
+        const reversedContent = Array.from(contentLines).reverse();
+        const reverseImports = reversedContent.filter(line => line.match(/\} from ('|")/));
+        if (reverseImports.length <= 0) {
+            return -1;
+        }
+        return contentLines.indexOf(reverseImports[0]);
+    }
+    buildLineToInsert(options) {
+        return `export * from '${this.computeRelativePath(options)}';`;
+    }
+    computeRelativePath(options) {
+        let importModulePath;
+        if (options.type !== undefined) {
+            importModulePath = (0, core_1.normalize)(`/${options.path}/${options.name}.${options.type}`);
+        }
+        else {
+            importModulePath = (0, core_1.normalize)(`/${options.path}/${options.name}`);
+        }
+        return this.solver.relative(options.module, importModulePath);
+    }
+}
+exports.ExportFromDeclarator = ExportFromDeclarator;

package/dist/utils/formatting.d.ts

@@ -0,0 +1 @@
+export declare function normalizeToKebabOrSnakeCase(str: string): string;

package/dist/utils/formatting.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToKebabOrSnakeCase = void 0;
+function normalizeToKebabOrSnakeCase(str) {
+    const STRING_DASHERIZE_REGEXP = /\s/g;
+    const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
+    return str
+        .replace(STRING_DECAMELIZE_REGEXP, '$1-$2')
+        .toLowerCase()
+        .replace(STRING_DASHERIZE_REGEXP, '-');
+}
+exports.normalizeToKebabOrSnakeCase = normalizeToKebabOrSnakeCase;

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './metadata.manager';
+export * from './module-import.declarator';
+export * from './module-metadata.declarator';
+export * from './module.declarator';
+export * from './module.finder';
+export * from './name.parser';
+export * from './path.solver';
+export * from './source-root.helpers';
+export * from './export-from.declarator';

package/dist/utils/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./metadata.manager"), exports);
+__exportStar(require("./module-import.declarator"), exports);
+__exportStar(require("./module-metadata.declarator"), exports);
+__exportStar(require("./module.declarator"), exports);
+__exportStar(require("./module.finder"), exports);
+__exportStar(require("./name.parser"), exports);
+__exportStar(require("./path.solver"), exports);
+__exportStar(require("./source-root.helpers"), exports);
+__exportStar(require("./export-from.declarator"), exports);

package/dist/utils/json-file.util.d.ts

@@ -0,0 +1,15 @@
+import { JsonValue } from '@angular-devkit/core';
+import { Tree } from '@angular-devkit/schematics';
+export declare type InsertionIndex = (properties: string[]) => number;
+export declare type JSONPath = (string | number)[];
+export declare class JSONFile {
+    private readonly host;
+    private readonly path;
+    content: string;
+    constructor(host: Tree, path: string);
+    private _jsonAst;
+    private get JsonAst();
+    get(jsonPath: JSONPath): unknown;
+    modify(jsonPath: JSONPath, value: JsonValue | undefined, insertInOrder?: InsertionIndex | false): void;
+    remove(jsonPath: JSONPath): void;
+}

package/dist/utils/json-file.util.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONFile = void 0;
+const jsonc_parser_1 = require("jsonc-parser");
+class JSONFile {
+    constructor(host, path) {
+        this.host = host;
+        this.path = path;
+        const buffer = this.host.read(this.path);
+        if (buffer) {
+            this.content = buffer.toString();
+        }
+        else {
+            throw new Error(`Could not read '${path}'.`);
+        }
+    }
+    get JsonAst() {
+        if (this._jsonAst) {
+            return this._jsonAst;
+        }
+        const errors = [];
+        this._jsonAst = (0, jsonc_parser_1.parseTree)(this.content, errors, {
+            allowTrailingComma: true,
+        });
+        if (errors.length) {
+            const { error, offset } = errors[0];
+            throw new Error(`Failed to parse "${this.path}" as JSON AST Object. ${(0, jsonc_parser_1.printParseErrorCode)(error)} at location: ${offset}.`);
+        }
+        return this._jsonAst;
+    }
+    get(jsonPath) {
+        const jsonAstNode = this.JsonAst;
+        if (!jsonAstNode) {
+            return undefined;
+        }
+        if (jsonPath.length === 0) {
+            return (0, jsonc_parser_1.getNodeValue)(jsonAstNode);
+        }
+        const node = (0, jsonc_parser_1.findNodeAtLocation)(jsonAstNode, jsonPath);
+        return node === undefined ? undefined : (0, jsonc_parser_1.getNodeValue)(node);
+    }
+    modify(jsonPath, value, insertInOrder) {
+        let getInsertionIndex;
+        if (insertInOrder === undefined) {
+            const property = jsonPath.slice(-1)[0];
+            getInsertionIndex = (properties) => [...properties, property].sort().findIndex((p) => p === property);
+        }
+        else if (insertInOrder !== false) {
+            getInsertionIndex = insertInOrder;
+        }
+        const edits = (0, jsonc_parser_1.modify)(this.content, jsonPath, value, {
+            getInsertionIndex,
+            formattingOptions: {
+                insertSpaces: true,
+                tabSize: 2,
+            },
+        });
+        this.content = (0, jsonc_parser_1.applyEdits)(this.content, edits);
+        this.host.overwrite(this.path, this.content);
+        this._jsonAst = undefined;
+    }
+    remove(jsonPath) {
+        if (this.get(jsonPath) !== undefined) {
+            this.modify(jsonPath, undefined);
+        }
+    }
+}
+exports.JSONFile = JSONFile;