@gadmin2n/cli 0.0.73

package/commands/add.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class AddCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/add.command.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddCommand = void 0;
+const remaining_flags_1 = require("../lib/utils/remaining-flags");
+const abstract_command_1 = require("./abstract.command");
+class AddCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('add <library>')
+            .allowUnknownOption()
+            .description('Adds support for an external library to your project.')
+            .option('-d, --dry-run', 'Report actions that would be performed without writing out results.')
+            .option('-p, --project [project]', 'Project in which to generate files.')
+            .usage('<library> [options] [library-specific-options]')
+            .action((library, command) => __awaiter(this, void 0, void 0, function* () {
+            const options = [];
+            options.push({ name: 'dry-run', value: !!command.dryRun });
+            options.push({
+                name: 'project',
+                value: command.project,
+            });
+            const inputs = [];
+            inputs.push({ name: 'library', value: library });
+            const flags = (0, remaining_flags_1.getRemainingFlags)(program);
+            try {
+                yield this.action.handle(inputs, options, flags);
+            }
+            catch (err) {
+                process.exit(1);
+            }
+        }));
+    }
+}
+exports.AddCommand = AddCommand;

package/commands/build.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class BuildCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/build.command.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildCommand = void 0;
+const abstract_command_1 = require("./abstract.command");
+class BuildCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('build [app]')
+            .option('-c, --config [path]', 'Path to gadmin-cli configuration file.')
+            .option('-p, --path [path]', 'Path to tsconfig file.')
+            .option('-w, --watch', 'Run in watch mode (live-reload).')
+            .option('--watchAssets', 'Watch non-ts (e.g., .graphql) files mode.')
+            .option('--webpack', 'Use webpack for compilation.')
+            .option('--webpackPath [path]', 'Path to webpack configuration.')
+            .option('--tsc', 'Use tsc for compilation.')
+            .description('Build Gadmin application.')
+            .action((app, command) => __awaiter(this, void 0, void 0, function* () {
+            const options = [];
+            options.push({
+                name: 'config',
+                value: command.config,
+            });
+            const isWebpackEnabled = command.tsc ? false : command.webpack;
+            options.push({ name: 'webpack', value: isWebpackEnabled });
+            options.push({ name: 'watch', value: !!command.watch });
+            options.push({ name: 'watchAssets', value: !!command.watchAssets });
+            options.push({
+                name: 'path',
+                value: command.path,
+            });
+            options.push({
+                name: 'webpackPath',
+                value: command.webpackPath,
+            });
+            const inputs = [];
+            inputs.push({ name: 'app', value: app });
+            yield this.action.handle(inputs, options);
+        }));
+    }
+}
+exports.BuildCommand = BuildCommand;

package/commands/command.input.d.ts

@@ -0,0 +1,25 @@
+export interface Input {
+    name: string;
+    value: boolean | string;
+    options?: any;
+}
+export declare enum Template {
+    GameAngle = "gadmin2-game-angle-demo",
+    Customize = "customize"
+}
+export declare enum TransferProtocol {
+    Restful = "restful",
+    GraphQL = "graphQL"
+}
+export declare enum ServerFramework {
+    Nest = "nest",
+    Iris = "iris"
+}
+export declare enum UiFramework {
+    Tea = "tea",
+    Antd = "antd"
+}
+export declare enum WithWeb {
+    Yes = "yes",
+    No = "no"
+}

package/commands/command.input.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithWeb = exports.UiFramework = exports.ServerFramework = exports.TransferProtocol = exports.Template = void 0;
+var Template;
+(function (Template) {
+    Template["GameAngle"] = "gadmin2-game-angle-demo";
+    Template["Customize"] = "customize";
+})(Template = exports.Template || (exports.Template = {}));
+var TransferProtocol;
+(function (TransferProtocol) {
+    TransferProtocol["Restful"] = "restful";
+    TransferProtocol["GraphQL"] = "graphQL";
+})(TransferProtocol = exports.TransferProtocol || (exports.TransferProtocol = {}));
+var ServerFramework;
+(function (ServerFramework) {
+    ServerFramework["Nest"] = "nest";
+    ServerFramework["Iris"] = "iris";
+})(ServerFramework = exports.ServerFramework || (exports.ServerFramework = {}));
+var UiFramework;
+(function (UiFramework) {
+    UiFramework["Tea"] = "tea";
+    UiFramework["Antd"] = "antd";
+})(UiFramework = exports.UiFramework || (exports.UiFramework = {}));
+var WithWeb;
+(function (WithWeb) {
+    WithWeb["Yes"] = "yes";
+    WithWeb["No"] = "no";
+})(WithWeb = exports.WithWeb || (exports.WithWeb = {}));

package/commands/command.loader.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+export declare class CommandLoader {
+    static load(program: CommanderStatic): void;
+    private static handleInvalidCommand;
+}

package/commands/command.loader.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandLoader = void 0;
+const chalk = require("chalk");
+const actions_1 = require("../actions");
+const ui_1 = require("../lib/ui");
+const add_command_1 = require("./add.command");
+const build_command_1 = require("./build.command");
+const generate_command_1 = require("./generate.command");
+const info_command_1 = require("./info.command");
+const new_command_1 = require("./new.command");
+const start_command_1 = require("./start.command");
+const update_command_1 = require("./update.command");
+class CommandLoader {
+    static load(program) {
+        new new_command_1.NewCommand(new actions_1.NewAction()).load(program);
+        new build_command_1.BuildCommand(new actions_1.BuildAction()).load(program);
+        new start_command_1.StartCommand(new actions_1.StartAction()).load(program);
+        new info_command_1.InfoCommand(new actions_1.InfoAction()).load(program);
+        new update_command_1.UpdateCommand(new actions_1.UpdateAction()).load(program);
+        new add_command_1.AddCommand(new actions_1.AddAction()).load(program);
+        new generate_command_1.GenerateCommand(new actions_1.GenerateAction()).load(program);
+        this.handleInvalidCommand(program);
+    }
+    static handleInvalidCommand(program) {
+        program.on('command:*', () => {
+            console.error(`\n${ui_1.ERROR_PREFIX} Invalid command: ${chalk.red('%s')}`, program.args.join(' '));
+            console.log(`See ${chalk.red('--help')} for a list of available commands.\n`);
+            process.exit(1);
+        });
+    }
+}
+exports.CommandLoader = CommandLoader;

package/commands/generate.command.d.ts

@@ -0,0 +1,7 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class GenerateCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+    private buildDescription;
+    private buildSchematicsListAsTable;
+}

package/commands/generate.command.js

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateCommand = void 0;
+const chalk = require("chalk");
+const Table = require("cli-table3");
+const gadmin_collection_1 = require("../lib/schematics/gadmin.collection");
+const abstract_command_1 = require("./abstract.command");
+class GenerateCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('generate <schematic> [name] [path]')
+            .alias('g')
+            .description(this.buildDescription())
+            .option('-d, --dry-run', 'Report actions that would be taken without writing out results.')
+            .option('-p, --project [project]', 'Project in which to generate files.')
+            .option('--flat', 'Enforce flat structure of generated element.', () => true)
+            .option('--no-flat', 'Enforce that directories are generated.', () => false)
+            .option('--spec', 'Enforce spec files generation.', () => {
+            return { value: true, passedAsInput: true };
+        }, true)
+            .option('--skip-import', 'Skip importing', () => true, false)
+            .option('--no-spec', 'Disable spec files generation.', () => {
+            return { value: false, passedAsInput: true };
+        })
+            .option('-c, --collection [collectionName]', 'Schematics collection to use.')
+            .action((schematic, name, path, command) => __awaiter(this, void 0, void 0, function* () {
+            const options = [];
+            options.push({ name: 'dry-run', value: !!command.dryRun });
+            if (command.flat !== undefined) {
+                options.push({ name: 'flat', value: command.flat });
+            }
+            options.push({
+                name: 'spec',
+                value: typeof command.spec === 'boolean'
+                    ? command.spec
+                    : command.spec.value,
+                options: {
+                    passedAsInput: typeof command.spec === 'boolean'
+                        ? false
+                        : command.spec.passedAsInput,
+                },
+            });
+            options.push({
+                name: 'collection',
+                value: command.collection,
+            });
+            options.push({
+                name: 'project',
+                value: command.project,
+            });
+            options.push({
+                name: 'skipImport',
+                value: command.skipImport,
+                options: {
+                    keepInputNameFormat: true,
+                },
+            });
+            const inputs = [];
+            inputs.push({ name: 'schematic', value: schematic });
+            inputs.push({ name: 'name', value: name });
+            inputs.push({ name: 'path', value: path });
+            yield this.action.handle(inputs, options);
+        }));
+    }
+    buildDescription() {
+        return ('Generate a Gadmin element.\n' +
+            `  Schematics available on ${chalk.bold('@gadmin2n/schematics')} collection:\n` +
+            this.buildSchematicsListAsTable());
+    }
+    buildSchematicsListAsTable() {
+        const leftMargin = '    ';
+        const tableConfig = {
+            head: ['name', 'alias', 'type', 'description'],
+            chars: {
+                'left': leftMargin.concat('│'),
+                'top-left': leftMargin.concat('┌'),
+                'bottom-left': leftMargin.concat('└'),
+                'mid': '',
+                'left-mid': '',
+                'mid-mid': '',
+                'right-mid': '',
+            },
+        };
+        const table = new Table(tableConfig);
+        for (const schematic of gadmin_collection_1.GadminCollection.getSchematics()) {
+            table.push([
+                chalk.green(schematic.name),
+                chalk.cyan(schematic.alias),
+                schematic.type,
+                schematic.description,
+            ]);
+        }
+        return table.toString();
+    }
+}
+exports.GenerateCommand = GenerateCommand;

package/commands/index.d.ts

@@ -0,0 +1,2 @@
+export * from './command.loader';
+export * from './command.input';

package/commands/index.js

@@ -0,0 +1,18 @@
+"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("./command.loader"), exports);
+__exportStar(require("./command.input"), exports);

package/commands/info.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class InfoCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/info.command.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoCommand = void 0;
+const abstract_command_1 = require("./abstract.command");
+class InfoCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('info')
+            .alias('i')
+            .description('Display Gadmin project details.')
+            .action(() => __awaiter(this, void 0, void 0, function* () {
+            yield this.action.handle();
+        }));
+    }
+}
+exports.InfoCommand = InfoCommand;

package/commands/new.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class NewCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/new.command.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewCommand = void 0;
+const schematics_1 = require("../lib/schematics");
+const abstract_command_1 = require("./abstract.command");
+class NewCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('new [name]')
+            .alias('n')
+            .description('Generate Gadmin application.')
+            .option('--directory [directory]', 'Specify the destination directory')
+            .option('-d, --dry-run', 'Report actions that would be performed without writing out results.', false)
+            .option('-g, --skip-git', 'Skip git repository initialization.', false)
+            .option('-w, --with-web', 'Need generate frontend web pages.')
+            .option('-s, --skip-install', 'Skip package installation.', false)
+            .option('-p, --package-manager [package-manager]', 'Specify package manager.')
+            .option('-c, --collection [collectionName]', 'Schematics collection to use', schematics_1.Collection.GADMIN_GENERATOR)
+            .option('--strict', 'Enables strict mode in TypeScript.', false)
+            .action((name, command) => __awaiter(this, void 0, void 0, function* () {
+            const options = [];
+            options.push({ name: 'directory', value: command.directory });
+            options.push({ name: 'template', value: undefined });
+            options.push({ name: 'dry-run', value: command.dryRun });
+            options.push({ name: 'skip-git', value: command.skipGit });
+            options.push({ name: 'skip-install', value: command.skipInstall });
+            options.push({ name: 'strict', value: command.strict });
+            options.push({
+                name: 'package-manager',
+                value: command.packageManager,
+            });
+            options.push({ name: 'collection', value: command.collection });
+            options.push({ name: 'transfer-protocol', value: 'restful' });
+            options.push({ name: 'server-framework', value: undefined });
+            options.push({ name: 'with-web', value: command.withWeb });
+            options.push({ name: 'ui-framework', value: 'antd' });
+            const inputs = [];
+            inputs.push({ name: 'name', value: name });
+            yield this.action.handle(inputs, options);
+        }));
+    }
+}
+exports.NewCommand = NewCommand;

package/commands/start.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class StartCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/start.command.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartCommand = void 0;
+const abstract_command_1 = require("./abstract.command");
+class StartCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('start [app]')
+            .option('-c, --config [path]', 'Path to gadmin-cli configuration file.')
+            .option('-p, --path [path]', 'Path to tsconfig file.')
+            .option('-w, --watch', 'Run in watch mode (live-reload).')
+            .option('--watchAssets', 'Watch non-ts (e.g., .graphql) files mode.')
+            .option('-d, --debug [hostport] ', 'Run in debug mode (with --inspect flag).')
+            .option('--webpack', 'Use webpack for compilation.')
+            .option('--webpackPath [path]', 'Path to webpack configuration.')
+            .option('--tsc', 'Use tsc for compilation.')
+            .option('-e, --exec [binary]', 'Binary to run (default: "node").')
+            .option('--preserveWatchOutput', 'Use "preserveWatchOutput" option when tsc watch mode.')
+            .description('Run Gadmin application.')
+            .action((app, command) => __awaiter(this, void 0, void 0, function* () {
+            const options = [];
+            options.push({
+                name: 'config',
+                value: command.config,
+            });
+            const isWebpackEnabled = command.tsc ? false : command.webpack;
+            options.push({ name: 'webpack', value: isWebpackEnabled });
+            options.push({ name: 'debug', value: command.debug });
+            options.push({ name: 'watch', value: !!command.watch });
+            options.push({ name: 'watchAssets', value: !!command.watchAssets });
+            options.push({
+                name: 'path',
+                value: command.path,
+            });
+            options.push({
+                name: 'webpackPath',
+                value: command.webpackPath,
+            });
+            options.push({
+                name: 'exec',
+                value: command.exec,
+            });
+            options.push({
+                name: 'preserveWatchOutput',
+                value: !!command.preserveWatchOutput &&
+                    !!command.watch &&
+                    !isWebpackEnabled,
+            });
+            const inputs = [];
+            inputs.push({ name: 'app', value: app });
+            yield this.action.handle(inputs, options);
+        }));
+    }
+}
+exports.StartCommand = StartCommand;

package/commands/update.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class UpdateCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/update.command.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCommand = void 0;
+const abstract_command_1 = require("./abstract.command");
+class UpdateCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('update')
+            .alias('u')
+            .description('Update Gadmin dependencies.')
+            .option('-f, --force', 'Remove and re-install dependencies (instead of update).')
+            .option('-t, --tag <tag>', 'Upgrade to tagged packages (latest | beta | rc | next tag).')
+            .action((command) => __awaiter(this, void 0, void 0, function* () {
+            const options = [];
+            options.push({ name: 'force', value: !!command.force });
+            options.push({ name: 'tag', value: command.tag });
+            yield this.action.handle([], options);
+        }));
+    }
+}
+exports.UpdateCommand = UpdateCommand;

package/lib/compiler/assets-manager.d.ts

@@ -0,0 +1,15 @@
+import { Configuration } from '../configuration';
+export declare class AssetsManager {
+    private watchAssetsKeyValue;
+    private watchers;
+    private actionInProgress;
+    /**
+     * Using on `nest build` to close file watch or the build process will not end
+     * Interval like process
+     * If no action has been taken recently close watchers
+     * If action has been taken recently flag and try again
+     */
+    closeWatchers(): void;
+    copyAssets(configuration: Required<Configuration>, appName: string, outDir: string, watchAssetsMode: boolean): void;
+    private actionOnFile;
+}