@gadmin2n/schematics 0.0.55

package/dist/utils/metadata.manager.d.ts

@@ -0,0 +1,13 @@
+import { DeclarationOptions } from './module.declarator';
+export declare class MetadataManager {
+    private content;
+    constructor(content: string);
+    insert(metadata: string, symbol: string, staticOptions?: DeclarationOptions['staticOptions']): string;
+    private getDecoratorMetadata;
+    private getSourceNodes;
+    private insertMetadataToEmptyModuleDecorator;
+    private insertNewMetadataToDecorator;
+    private insertSymbolToMetadata;
+    private mergeSymbolAndExpr;
+    private addBlankLines;
+}

package/dist/utils/metadata.manager.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataManager = void 0;
+const typescript_1 = require("typescript");
+class MetadataManager {
+    constructor(content) {
+        this.content = content;
+    }
+    insert(metadata, symbol, staticOptions) {
+        const source = (0, typescript_1.createSourceFile)('filename.ts', this.content, typescript_1.ScriptTarget.ES2017);
+        const decoratorNodes = this.getDecoratorMetadata(source, '@Module');
+        const node = decoratorNodes[0];
+        const matchingProperties = node.properties
+            .filter((prop) => prop.kind === typescript_1.SyntaxKind.PropertyAssignment)
+            .filter((prop) => {
+            const name = prop.name;
+            switch (name.kind) {
+                case typescript_1.SyntaxKind.Identifier:
+                    return name.getText(source) === metadata;
+                case typescript_1.SyntaxKind.StringLiteral:
+                    return name.text === metadata;
+                default:
+                    return false;
+            }
+        });
+        symbol = this.mergeSymbolAndExpr(symbol, staticOptions);
+        const addBlankLinesIfDynamic = () => {
+            symbol = staticOptions ? this.addBlankLines(symbol) : symbol;
+        };
+        if (matchingProperties.length === 0) {
+            const expr = node;
+            if (expr.properties.length === 0) {
+                addBlankLinesIfDynamic();
+                return this.insertMetadataToEmptyModuleDecorator(expr, metadata, symbol);
+            }
+            else {
+                addBlankLinesIfDynamic();
+                return this.insertNewMetadataToDecorator(expr, source, metadata, symbol);
+            }
+        }
+        else {
+            return this.insertSymbolToMetadata(source, matchingProperties, symbol, staticOptions);
+        }
+    }
+    getDecoratorMetadata(source, identifier) {
+        return this.getSourceNodes(source)
+            .filter((node) => node.kind === typescript_1.SyntaxKind.Decorator &&
+            node.expression.kind === typescript_1.SyntaxKind.CallExpression)
+            .map((node) => node.expression)
+            .filter((expr) => expr.arguments[0] &&
+            expr.arguments[0].kind === typescript_1.SyntaxKind.ObjectLiteralExpression)
+            .map((expr) => expr.arguments[0]);
+    }
+    getSourceNodes(sourceFile) {
+        const nodes = [sourceFile];
+        const result = [];
+        while (nodes.length > 0) {
+            const node = nodes.shift();
+            if (node) {
+                result.push(node);
+                if (node.getChildCount(sourceFile) >= 0) {
+                    nodes.unshift(...node.getChildren());
+                }
+            }
+        }
+        return result;
+    }
+    insertMetadataToEmptyModuleDecorator(expr, metadata, symbol) {
+        const position = expr.getEnd() - 1;
+        const toInsert = `  ${metadata}: [${symbol}]`;
+        return this.content.split('').reduce((content, char, index) => {
+            if (index === position) {
+                return `${content}\n${toInsert}\n${char}`;
+            }
+            else {
+                return `${content}${char}`;
+            }
+        }, '');
+    }
+    insertNewMetadataToDecorator(expr, source, metadata, symbol) {
+        const node = expr.properties[expr.properties.length - 1];
+        const position = node.getEnd();
+        const text = node.getFullText(source);
+        const matches = text.match(/^\r?\n\s*/);
+        let toInsert;
+        if (matches) {
+            toInsert = `,${matches[0]}${metadata}: [${symbol}]`;
+        }
+        else {
+            toInsert = `, ${metadata}: [${symbol}]`;
+        }
+        return this.content.split('').reduce((content, char, index) => {
+            if (index === position) {
+                return `${content}${toInsert}${char}`;
+            }
+            else {
+                return `${content}${char}`;
+            }
+        }, '');
+    }
+    insertSymbolToMetadata(source, matchingProperties, symbol, staticOptions) {
+        const assignment = matchingProperties[0];
+        let node;
+        const arrLiteral = assignment.initializer;
+        if (!arrLiteral.elements) {
+            return this.content;
+        }
+        if (arrLiteral.elements.length === 0) {
+            node = arrLiteral;
+        }
+        else {
+            node = arrLiteral.elements;
+        }
+        if (Array.isArray(node)) {
+            const nodeArray = node;
+            const symbolsArray = nodeArray.map((childNode) => childNode.getText(source));
+            if (symbolsArray.includes(symbol)) {
+                return this.content;
+            }
+            node = node[node.length - 1];
+        }
+        let toInsert;
+        let position = node.getEnd();
+        if (node.kind === typescript_1.SyntaxKind.ArrayLiteralExpression) {
+            position--;
+            toInsert = staticOptions ? this.addBlankLines(symbol) : `${symbol}`;
+        }
+        else {
+            const text = node.getFullText(source);
+            if (text.match(/^\r?\n/)) {
+                toInsert = `,${text.match(/^\r?\n(\r?)\s+/)[0]}${symbol}`;
+            }
+            else {
+                toInsert = `, ${symbol}`;
+            }
+        }
+        return this.content.split('').reduce((content, char, index) => {
+            if (index === position) {
+                return `${content}${toInsert}${char}`;
+            }
+            else {
+                return `${content}${char}`;
+            }
+        }, '');
+    }
+    mergeSymbolAndExpr(symbol, staticOptions) {
+        if (!staticOptions) {
+            return symbol;
+        }
+        const spacing = 6;
+        let options = JSON.stringify(staticOptions.value, null, spacing);
+        options = options.replace(/\"([^(\")"]+)\":/g, '$1:');
+        options = options.replace(/\"/g, `'`);
+        options = options.slice(0, options.length - 1) + '    }';
+        symbol += `.${staticOptions.name}(${options})`;
+        return symbol;
+    }
+    addBlankLines(expr) {
+        return `\n    ${expr}\n  `;
+    }
+}
+exports.MetadataManager = MetadataManager;

package/dist/utils/module-import.declarator.d.ts

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

package/dist/utils/module-import.declarator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleImportDeclarator = void 0;
+const core_1 = require("@angular-devkit/core");
+const path_solver_1 = require("./path.solver");
+class ModuleImportDeclarator {
+    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 `import { ${options.symbol} } 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.ModuleImportDeclarator = ModuleImportDeclarator;

package/dist/utils/module-metadata.declarator.d.ts

@@ -0,0 +1,4 @@
+import { DeclarationOptions } from './module.declarator';
+export declare class ModuleMetadataDeclarator {
+    declare(content: string, options: DeclarationOptions): string;
+}

package/dist/utils/module-metadata.declarator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleMetadataDeclarator = void 0;
+const metadata_manager_1 = require("./metadata.manager");
+class ModuleMetadataDeclarator {
+    declare(content, options) {
+        const manager = new metadata_manager_1.MetadataManager(content);
+        const inserted = manager.insert(options.metadata, options.symbol, options.staticOptions);
+        return inserted;
+    }
+}
+exports.ModuleMetadataDeclarator = ModuleMetadataDeclarator;

package/dist/utils/module.declarator.d.ts

@@ -0,0 +1,23 @@
+import { Path } from '@angular-devkit/core';
+import { ModuleImportDeclarator } from './module-import.declarator';
+import { ModuleMetadataDeclarator } from './module-metadata.declarator';
+export interface DeclarationOptions {
+    metadata: string;
+    type?: string;
+    name: string;
+    className?: string;
+    path: Path;
+    module: Path;
+    symbol?: string;
+    staticOptions?: {
+        name: string;
+        value: Record<string, any>;
+    };
+}
+export declare class ModuleDeclarator {
+    private imports;
+    private metadata;
+    constructor(imports?: ModuleImportDeclarator, metadata?: ModuleMetadataDeclarator);
+    declare(content: string, options: DeclarationOptions): string;
+    private computeSymbol;
+}

package/dist/utils/module.declarator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleDeclarator = void 0;
+const strings_1 = require("@angular-devkit/core/src/utils/strings");
+const module_import_declarator_1 = require("./module-import.declarator");
+const module_metadata_declarator_1 = require("./module-metadata.declarator");
+class ModuleDeclarator {
+    constructor(imports = new module_import_declarator_1.ModuleImportDeclarator(), metadata = new module_metadata_declarator_1.ModuleMetadataDeclarator()) {
+        this.imports = imports;
+        this.metadata = metadata;
+    }
+    declare(content, options) {
+        options = this.computeSymbol(options);
+        content = this.imports.declare(content, options);
+        content = this.metadata.declare(content, options);
+        return content;
+    }
+    computeSymbol(options) {
+        const target = Object.assign({}, options);
+        if (options.className) {
+            target.symbol = options.className;
+        }
+        else if (options.type !== undefined) {
+            target.symbol = (0, strings_1.classify)(options.name).concat((0, strings_1.capitalize)(options.type));
+        }
+        else {
+            target.symbol = (0, strings_1.classify)(options.name);
+        }
+        return target;
+    }
+}
+exports.ModuleDeclarator = ModuleDeclarator;

package/dist/utils/module.finder.d.ts

@@ -0,0 +1,13 @@
+import { Path } from '@angular-devkit/core';
+import { Tree } from '@angular-devkit/schematics';
+export interface FindOptions {
+    name?: string;
+    path: Path;
+    kind?: string;
+}
+export declare class ModuleFinder {
+    private tree;
+    constructor(tree: Tree);
+    find(options: FindOptions): Path | null;
+    private findIn;
+}

package/dist/utils/module.finder.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleFinder = void 0;
+const core_1 = require("@angular-devkit/core");
+class ModuleFinder {
+    constructor(tree) {
+        this.tree = tree;
+    }
+    find(options) {
+        const generatedDirectoryPath = options.path;
+        const generatedDirectory = this.tree.getDir(generatedDirectoryPath);
+        return this.findIn(generatedDirectory);
+    }
+    findIn(directory) {
+        if (!directory) {
+            return null;
+        }
+        const moduleFilename = directory.subfiles.find(filename => /\.module\.(t|j)s$/.test(filename));
+        return moduleFilename !== undefined
+            ? (0, core_1.join)(directory.path, moduleFilename.valueOf())
+            : this.findIn(directory.parent);
+    }
+}
+exports.ModuleFinder = ModuleFinder;

package/dist/utils/name.parser.d.ts

@@ -0,0 +1,12 @@
+import { Path } from '@angular-devkit/core';
+export interface ParseOptions {
+    name: string;
+    path?: string;
+}
+export interface Location {
+    name: string;
+    path: Path;
+}
+export declare class NameParser {
+    parse(options: ParseOptions): Location;
+}

package/dist/utils/name.parser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameParser = void 0;
+const core_1 = require("@angular-devkit/core");
+class NameParser {
+    parse(options) {
+        const nameWithoutPath = (0, core_1.basename)(options.name);
+        const namePath = (0, core_1.dirname)((options.path === undefined ? '' : options.path)
+            .concat('/')
+            .concat(options.name));
+        return {
+            name: nameWithoutPath,
+            path: (0, core_1.normalize)('/'.concat(namePath)),
+        };
+    }
+}
+exports.NameParser = NameParser;

package/dist/utils/path.solver.d.ts

@@ -0,0 +1,4 @@
+import { Path } from '@angular-devkit/core';
+export declare class PathSolver {
+    relative(from: Path, to: Path): string;
+}

package/dist/utils/path.solver.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathSolver = void 0;
+const core_1 = require("@angular-devkit/core");
+class PathSolver {
+    relative(from, to) {
+        const placeholder = '/placeholder';
+        const relativeDir = (0, core_1.relative)((0, core_1.dirname)((placeholder + from)), (0, core_1.dirname)((placeholder + to)));
+        return (relativeDir.startsWith('.')
+            ? relativeDir
+            : './' + relativeDir).concat(relativeDir.length === 0 ? (0, core_1.basename)(to) : '/' + (0, core_1.basename)(to));
+    }
+}
+exports.PathSolver = PathSolver;

package/dist/utils/source-root.helpers.d.ts

@@ -0,0 +1,8 @@
+import { Rule, Tree } from '@angular-devkit/schematics';
+export declare function isInRootDirectory(host: Tree, extraFiles?: string[]): boolean;
+export declare function isInWebRootDirectory(host: Tree, extraFiles?: string[]): boolean;
+export declare function isInSvrRootDirectory(host: Tree, extraFiles?: string[]): boolean;
+export declare function mergeSourceRoot<T extends {
+    sourceRoot?: string;
+    path?: string;
+} = any>(options: T): Rule;

package/dist/utils/source-root.helpers.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSourceRoot = exports.isInSvrRootDirectory = exports.isInWebRootDirectory = exports.isInRootDirectory = void 0;
+const core_1 = require("@angular-devkit/core");
+const defaults_1 = require("../lib/defaults");
+function isInRootDirectory(host, extraFiles = []) {
+    const files = ['gadmin-cli.json', 'gadmin.json'].concat(extraFiles || []);
+    return files.map(file => host.exists(file)).some(isPresent => isPresent);
+}
+exports.isInRootDirectory = isInRootDirectory;
+function isInWebRootDirectory(host, extraFiles = []) {
+    const files = ['src/app.tsx', 'src/App.tsx', 'index.tsx'].concat(extraFiles || []);
+    return files.map(file => host.exists(file)).some(isPresent => isPresent);
+}
+exports.isInWebRootDirectory = isInWebRootDirectory;
+function isInSvrRootDirectory(host, extraFiles = []) {
+    const files = ['prisma/schema.prisma'].concat(extraFiles || []);
+    return files.map(file => host.exists(file)).some(isPresent => isPresent);
+}
+exports.isInSvrRootDirectory = isInSvrRootDirectory;
+function mergeSourceRoot(options) {
+    return (host) => {
+        const isInRoot = isInRootDirectory(host, ['tsconfig.json', 'package.json']);
+        if (!isInRoot) {
+            return host;
+        }
+        const defaultSourceRoot = options.sourceRoot !== undefined ? options.sourceRoot : defaults_1.DEFAULT_PATH_NAME;
+        options.path =
+            options.path !== undefined
+                ? (0, core_1.join)((0, core_1.normalize)(defaultSourceRoot), options.path)
+                : (0, core_1.normalize)(defaultSourceRoot);
+        return host;
+    };
+}
+exports.mergeSourceRoot = mergeSourceRoot;

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@gadmin2n/schematics",
+  "version": "0.0.55",
+  "description": "Gadmin - modern, fast, powerful node.js web framework (@schematics)",
+  "main": "dist/index.js",
+  "files": [
+    "dist/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "postbuild": "npm run copy:collection && npm run copy:lib",
+    "build": "rm -rf dist && tsc --project tsconfig.lib.json",
+    "clean": "gulp clean:src",
+    "copy:collection": "cpx src/collection.json dist && cpx 'src/lib/**/schema.json' dist/lib",
+    "copy:lib": "cpx 'src/lib/**/{files,workspace}/**/*' dist/lib && cpx 'src/lib/**/{files,workspace}/**/.!(gitignore)' dist/lib",
+    "lint": "eslint '{src,test}/**/*.ts' --fix",
+    "prepublish:next": "npm run build",
+    "publish:next": "npm publish --access public --tag next",
+    "prepublish:npm": "npm run build",
+    "publish:npm": "npm publish --access public",
+    "test": "npm run clean && NODE_ENV=test jest -w 1 --no-cache --config jest.json",
+    "test:dev": "NODE_ENV=test npm run -s test -- --watchAll",
+    "prerelease": "npm run build",
+    "release": "release-it"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "contributors": [
+    "ThomRick",
+    "Kamil Mysliwiec",
+    "John Biundo"
+  ],
+  "license": "MIT",
+  "homepage": "",
+  "dependencies": {
+    "@angular-devkit/core": "13.3.2",
+    "@angular-devkit/schematics": "13.3.2",
+    "fs-extra": "10.0.1",
+    "jsonc-parser": "3.0.0",
+    "pluralize": "8.0.0",
+    "ts-morph": "^14.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "16.2.3",
+    "@commitlint/config-angular": "16.2.3",
+    "@types/fs-extra": "9.0.13",
+    "@types/jest": "27.4.1",
+    "@types/node": "16.11.26",
+    "@typescript-eslint/eslint-plugin": "5.18.0",
+    "@typescript-eslint/parser": "5.18.0",
+    "cpx": "1.5.0",
+    "eslint": "8.12.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-import": "2.26.0",
+    "gulp": "4.0.2",
+    "gulp-clean": "0.4.0",
+    "husky": "7.0.4",
+    "jest": "27.5.1",
+    "nyc": "15.1.0",
+    "release-it": "14.14.0",
+    "ts-jest": "27.1.4",
+    "ts-node": "10.7.0",
+    "typescript": "4.6.3"
+  },
+  "peerDependencies": {
+    "typescript": "^3.4.5 || ^4.3.5"
+  },
+  "schematics": "./dist/collection.json",
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -c .commitlintrc.json -E HUSKY_GIT_PARAMS"
+    }
+  },
+  "nyc": {
+    "include": [
+      "src"
+    ],
+    "exclude": [
+      "node_modules",
+      "test"
+    ],
+    "extension": [
+      ".ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "reporter": [
+      "text-summary",
+      "html"
+    ],
+    "sourceMap": true,
+    "instrument": true
+  }
+}