nestia 2.1.13 → 3.0.0

package/lib/executable/internal/NestiaConfig.js

@@ -58,17 +58,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -77,10 +66,9 @@ exports.NestiaConfig = void 0;
 var fs_1 = __importDefault(require("fs"));
 var path_1 = __importDefault(require("path"));
 var runner = __importStar(require("ts-node"));
-var InvalidArgument_1 = require("tstl/exception/InvalidArgument");
 var nestia_fetcher_1 = require("nestia-fetcher");
 var Singleton_1 = require("tstl/thread/Singleton");
-var typescript_is_1 = require("typescript-is");
+var typescript_json_1 = require("typescript-json");
 var NestiaConfig;
 (function (NestiaConfig) {
     var _this = this;
@@ -88,166 +76,8 @@ var NestiaConfig;
         return singleton.get();
     }
     NestiaConfig.get = get;
-    function assert(config) {
-        (0, typescript_is_1.assertType)(config, function (object) { var path = ["config"]; function _undefined(object) { ; if (object !== undefined)
-            return { message: "validation failed at " + path.join(".") + ": expected undefined", path: path.slice(), reason: { type: "undefined" } };
-        else
-            return null; } function _string(object) { ; if (typeof object !== "string")
-            return { message: "validation failed at " + path.join(".") + ": expected a string", path: path.slice(), reason: { type: "string" } };
-        else
-            return null; } function _null(object) { ; if (object !== null)
-            return { message: "validation failed at " + path.join(".") + ": expected null", path: path.slice(), reason: { type: "null" } };
-        else
-            return null; } function su__undefined__string_eu(object) {
-            var e_1, _a;
-            var conditions = [_undefined, _string];
-            try {
-                for (var conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next(); !conditions_1_1.done; conditions_1_1 = conditions_1.next()) {
-                    var condition = conditions_1_1.value;
-                    var error = condition(object);
-                    if (!error)
-                        return null;
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (conditions_1_1 && !conditions_1_1.done && (_a = conditions_1.return)) _a.call(conditions_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            return { message: "validation failed at " + path.join(".") + ": there are no valid alternatives", path: path.slice(), reason: { type: "union" } };
-        } function _false(object) { ; if (object !== false)
-            return { message: "validation failed at " + path.join(".") + ": expected false", path: path.slice(), reason: { type: "boolean-literal", value: false } };
-        else
-            return null; } function _true(object) { ; if (object !== true)
-            return { message: "validation failed at " + path.join(".") + ": expected true", path: path.slice(), reason: { type: "boolean-literal", value: true } };
-        else
-            return null; } function su__undefined__5__6_eu(object) {
-            var e_2, _a;
-            var conditions = [_undefined, _false, _true];
-            try {
-                for (var conditions_2 = __values(conditions), conditions_2_1 = conditions_2.next(); !conditions_2_1.done; conditions_2_1 = conditions_2.next()) {
-                    var condition = conditions_2_1.value;
-                    var error = condition(object);
-                    if (!error)
-                        return null;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (conditions_2_1 && !conditions_2_1.done && (_a = conditions_2.return)) _a.call(conditions_2);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            return { message: "validation failed at " + path.join(".") + ": there are no valid alternatives", path: path.slice(), reason: { type: "union" } };
-        } function _8(object) { ; if (typeof object !== "object" || object === null || Array.isArray(object))
-            return { message: "validation failed at " + path.join(".") + ": expected an object", path: path.slice(), reason: { type: "object" } }; {
-            if ("output" in object) {
-                path.push("output");
-                var error = _string(object["output"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-            else
-                return { message: "validation failed at " + path.join(".") + ": expected 'output' in object", path: path.slice(), reason: { type: "missing-property", property: "output" } };
-        } return null; } function su__undefined__8_eu(object) {
-            var e_3, _a;
-            var conditions = [_undefined, _8];
-            try {
-                for (var conditions_3 = __values(conditions), conditions_3_1 = conditions_3.next(); !conditions_3_1.done; conditions_3_1 = conditions_3.next()) {
-                    var condition = conditions_3_1.value;
-                    var error = condition(object);
-                    if (!error)
-                        return null;
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (conditions_3_1 && !conditions_3_1.done && (_a = conditions_3.return)) _a.call(conditions_3);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            return { message: "validation failed at " + path.join(".") + ": there are no valid alternatives", path: path.slice(), reason: { type: "union" } };
-        } function _0(object) { ; if (typeof object !== "object" || object === null || Array.isArray(object))
-            return { message: "validation failed at " + path.join(".") + ": expected an object", path: path.slice(), reason: { type: "object" } }; {
-            if ("output" in object) {
-                path.push("output");
-                var error = su__undefined__string_eu(object["output"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } {
-            if ("assert" in object) {
-                path.push("assert");
-                var error = su__undefined__5__6_eu(object["assert"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } {
-            if ("json" in object) {
-                path.push("json");
-                var error = su__undefined__5__6_eu(object["json"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } {
-            if ("swagger" in object) {
-                path.push("swagger");
-                var error = su__undefined__8_eu(object["swagger"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } return null; } return _0(object); });
-        if ((0, typescript_is_1.is)(config.input, function (object) { function _string(object) { ; if (typeof object !== "string")
-            return {};
-        else
-            return null; } return _string(object); }) === false &&
-            (0, typescript_is_1.is)(config.input, function (object) { function _string(object) { ; if (typeof object !== "string")
-                return {};
-            else
-                return null; } function sa__string_ea_2(object) { ; if (!Array.isArray(object))
-                return {}; for (var i = 0; i < object.length; i++) {
-                var error = _string(object[i]);
-                if (error)
-                    return error;
-            } return null; } return sa__string_ea_2(object); }) === false &&
-            (0, typescript_is_1.is)(config.input, function (object) { function _string(object) { ; if (typeof object !== "string")
-                return {};
-            else
-                return null; } function sa__string_ea_3(object) { ; if (!Array.isArray(object))
-                return {}; for (var i = 0; i < object.length; i++) {
-                var error = _string(object[i]);
-                if (error)
-                    return error;
-            } return null; } function _0(object) { ; if (typeof object !== "object" || object === null || Array.isArray(object))
-                return {}; {
-                if ("include" in object) {
-                    var error = sa__string_ea_3(object["include"]);
-                    if (error)
-                        return error;
-                }
-                else
-                    return {};
-            } {
-                if ("exclude" in object) {
-                    var error = sa__string_ea_3(object["exclude"]);
-                    if (error)
-                        return error;
-                }
-            } return null; } return _0(object); }) === false)
-            throw new InvalidArgument_1.InvalidArgument("Error on NestiaConfig.get(): invalid input type.");
-        return config;
-    }
     var singleton = new Singleton_1.Singleton(function () { return __awaiter(_this, void 0, void 0, function () {
-        var config, trial;
+        var loaded, config;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -261,18 +91,211 @@ var NestiaConfig;
                     });
                     return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require(path_1.default.resolve("nestia.config.ts"))); })];
                 case 1:
-                    config = _a.sent();
-                    try {
-                        return [2 /*return*/, assert(nestia_fetcher_1.Primitive.clone(config))];
-                    }
-                    catch (exp) {
-                        trial = config;
-                        if (trial.default && typeof trial.default === "object")
-                            return [2 /*return*/, assert(nestia_fetcher_1.Primitive.clone(trial.default))];
-                        else
-                            throw exp;
-                    }
-                    return [2 /*return*/];
+                    loaded = _a.sent();
+                    if (typeof loaded !== "object")
+                        throw new Error("Error on NestiaConfig.get(): failed to load data");
+                    config = typeof loaded.default === "object" ? loaded.default : loaded;
+                    return [2 /*return*/, (function (input) { (function (input, path) {
+                            if (path === void 0) { path = "$input"; }
+                            var assertType = [
+                                function (input, path, exceptionable) { return null !== input.input && undefined !== input.input && ("string" === typeof input.input || Array.isArray(input.input) && input.input.every(function (elem, index7786271207813025) { return "string" === typeof elem; }) || "object" === typeof input.input && assertType[1](input.input, path + ".input", false && exceptionable)) && (function () {
+                                    var success = undefined === input.output || "string" === typeof input.output;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".output", input.output);
+                                    return success;
+                                })() && (function () {
+                                    var success = null !== input.compilerOptions && (undefined === input.compilerOptions || "object" === typeof input.compilerOptions && assertType[2](input.compilerOptions, path + ".compilerOptions", true && exceptionable));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".compilerOptions", input.compilerOptions);
+                                    return success;
+                                })() && (undefined === input.assert || false === input.assert || true === input.assert) && (undefined === input.json || false === input.json || true === input.json) && (function () {
+                                    var success = null !== input.swagger && (undefined === input.swagger || "object" === typeof input.swagger && assertType[4](input.swagger, path + ".swagger", true && exceptionable));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".swagger", input.swagger);
+                                    return success;
+                                })(); },
+                                function (input, path, exceptionable) { return (function () {
+                                    var success = Array.isArray(input.include) && input.include.every(function (elem, index8394279337737445) { return (function () {
+                                        var success = "string" === typeof elem;
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".include[" + index8394279337737445 + "]", elem);
+                                        return success;
+                                    })(); });
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".include", input.include);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.exclude || Array.isArray(input.exclude) && input.exclude.every(function (elem, index49397795636828734) { return (function () {
+                                        var success = "string" === typeof elem;
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".exclude[" + index49397795636828734 + "]", elem);
+                                        return success;
+                                    })(); });
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".exclude", input.exclude);
+                                    return success;
+                                })(); },
+                                function (input, path, exceptionable) { return (undefined === input.allowJs || false === input.allowJs || true === input.allowJs) && (undefined === input.allowSyntheticDefaultImports || false === input.allowSyntheticDefaultImports || true === input.allowSyntheticDefaultImports) && (undefined === input.allowUmdGlobalAccess || false === input.allowUmdGlobalAccess || true === input.allowUmdGlobalAccess) && (undefined === input.allowUnreachableCode || false === input.allowUnreachableCode || true === input.allowUnreachableCode) && (undefined === input.allowUnusedLabels || false === input.allowUnusedLabels || true === input.allowUnusedLabels) && (undefined === input.alwaysStrict || false === input.alwaysStrict || true === input.alwaysStrict) && (function () {
+                                    var success = undefined === input.baseUrl || "string" === typeof input.baseUrl;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".baseUrl", input.baseUrl);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.charset || "string" === typeof input.charset;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".charset", input.charset);
+                                    return success;
+                                })() && (undefined === input.checkJs || false === input.checkJs || true === input.checkJs) && (undefined === input.declaration || false === input.declaration || true === input.declaration) && (undefined === input.declarationMap || false === input.declarationMap || true === input.declarationMap) && (undefined === input.emitDeclarationOnly || false === input.emitDeclarationOnly || true === input.emitDeclarationOnly) && (function () {
+                                    var success = undefined === input.declarationDir || "string" === typeof input.declarationDir;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".declarationDir", input.declarationDir);
+                                    return success;
+                                })() && (undefined === input.disableSizeLimit || false === input.disableSizeLimit || true === input.disableSizeLimit) && (undefined === input.disableSourceOfProjectReferenceRedirect || false === input.disableSourceOfProjectReferenceRedirect || true === input.disableSourceOfProjectReferenceRedirect) && (undefined === input.disableSolutionSearching || false === input.disableSolutionSearching || true === input.disableSolutionSearching) && (undefined === input.disableReferencedProjectLoad || false === input.disableReferencedProjectLoad || true === input.disableReferencedProjectLoad) && (undefined === input.downlevelIteration || false === input.downlevelIteration || true === input.downlevelIteration) && (undefined === input.emitBOM || false === input.emitBOM || true === input.emitBOM) && (undefined === input.emitDecoratorMetadata || false === input.emitDecoratorMetadata || true === input.emitDecoratorMetadata) && (undefined === input.exactOptionalPropertyTypes || false === input.exactOptionalPropertyTypes || true === input.exactOptionalPropertyTypes) && (undefined === input.experimentalDecorators || false === input.experimentalDecorators || true === input.experimentalDecorators) && (undefined === input.forceConsistentCasingInFileNames || false === input.forceConsistentCasingInFileNames || true === input.forceConsistentCasingInFileNames) && (undefined === input.importHelpers || false === input.importHelpers || true === input.importHelpers) && (undefined === input.importsNotUsedAsValues || 0 === input.importsNotUsedAsValues || 1 === input.importsNotUsedAsValues || 2 === input.importsNotUsedAsValues) && (undefined === input.inlineSourceMap || false === input.inlineSourceMap || true === input.inlineSourceMap) && (undefined === input.inlineSources || false === input.inlineSources || true === input.inlineSources) && (undefined === input.isolatedModules || false === input.isolatedModules || true === input.isolatedModules) && (undefined === input.jsx || 0 === input.jsx || 1 === input.jsx || 2 === input.jsx || 3 === input.jsx || 4 === input.jsx || 5 === input.jsx) && (undefined === input.keyofStringsOnly || false === input.keyofStringsOnly || true === input.keyofStringsOnly) && (function () {
+                                    var success = undefined === input.lib || Array.isArray(input.lib) && input.lib.every(function (elem, index8499243785719959) { return (function () {
+                                        var success = "string" === typeof elem;
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".lib[" + index8499243785719959 + "]", elem);
+                                        return success;
+                                    })(); });
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".lib", input.lib);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.locale || "string" === typeof input.locale;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".locale", input.locale);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.mapRoot || "string" === typeof input.mapRoot;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".mapRoot", input.mapRoot);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.maxNodeModuleJsDepth || "number" === typeof input.maxNodeModuleJsDepth;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".maxNodeModuleJsDepth", input.maxNodeModuleJsDepth);
+                                    return success;
+                                })() && (undefined === input.module || 0 === input.module || 1 === input.module || 2 === input.module || 3 === input.module || 4 === input.module || 5 === input.module || 6 === input.module || 7 === input.module || 99 === input.module || 100 === input.module || 199 === input.module) && (undefined === input.moduleResolution || 1 === input.moduleResolution || 2 === input.moduleResolution || 3 === input.moduleResolution || 99 === input.moduleResolution) && (function () {
+                                    var success = undefined === input.moduleSuffixes || Array.isArray(input.moduleSuffixes) && input.moduleSuffixes.every(function (elem, index9347901682772985) { return (function () {
+                                        var success = "string" === typeof elem;
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".moduleSuffixes[" + index9347901682772985 + "]", elem);
+                                        return success;
+                                    })(); });
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".moduleSuffixes", input.moduleSuffixes);
+                                    return success;
+                                })() && (undefined === input.moduleDetection || 1 === input.moduleDetection || 2 === input.moduleDetection || 3 === input.moduleDetection) && (undefined === input.newLine || 0 === input.newLine || 1 === input.newLine) && (undefined === input.noEmit || false === input.noEmit || true === input.noEmit) && (undefined === input.noEmitHelpers || false === input.noEmitHelpers || true === input.noEmitHelpers) && (undefined === input.noEmitOnError || false === input.noEmitOnError || true === input.noEmitOnError) && (undefined === input.noErrorTruncation || false === input.noErrorTruncation || true === input.noErrorTruncation) && (undefined === input.noFallthroughCasesInSwitch || false === input.noFallthroughCasesInSwitch || true === input.noFallthroughCasesInSwitch) && (undefined === input.noImplicitAny || false === input.noImplicitAny || true === input.noImplicitAny) && (undefined === input.noImplicitReturns || false === input.noImplicitReturns || true === input.noImplicitReturns) && (undefined === input.noImplicitThis || false === input.noImplicitThis || true === input.noImplicitThis) && (undefined === input.noStrictGenericChecks || false === input.noStrictGenericChecks || true === input.noStrictGenericChecks) && (undefined === input.noUnusedLocals || false === input.noUnusedLocals || true === input.noUnusedLocals) && (undefined === input.noUnusedParameters || false === input.noUnusedParameters || true === input.noUnusedParameters) && (undefined === input.noImplicitUseStrict || false === input.noImplicitUseStrict || true === input.noImplicitUseStrict) && (undefined === input.noPropertyAccessFromIndexSignature || false === input.noPropertyAccessFromIndexSignature || true === input.noPropertyAccessFromIndexSignature) && (undefined === input.assumeChangesOnlyAffectDirectDependencies || false === input.assumeChangesOnlyAffectDirectDependencies || true === input.assumeChangesOnlyAffectDirectDependencies) && (undefined === input.noLib || false === input.noLib || true === input.noLib) && (undefined === input.noResolve || false === input.noResolve || true === input.noResolve) && (undefined === input.noUncheckedIndexedAccess || false === input.noUncheckedIndexedAccess || true === input.noUncheckedIndexedAccess) && (function () {
+                                    var success = undefined === input.out || "string" === typeof input.out;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".out", input.out);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.outDir || "string" === typeof input.outDir;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".outDir", input.outDir);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.outFile || "string" === typeof input.outFile;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".outFile", input.outFile);
+                                    return success;
+                                })() && (function () {
+                                    var success = null !== input.paths && (undefined === input.paths || "object" === typeof input.paths && assertType[3](input.paths, path + ".paths", true && exceptionable));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".paths", input.paths);
+                                    return success;
+                                })() && (undefined === input.preserveConstEnums || false === input.preserveConstEnums || true === input.preserveConstEnums) && (undefined === input.noImplicitOverride || false === input.noImplicitOverride || true === input.noImplicitOverride) && (undefined === input.preserveSymlinks || false === input.preserveSymlinks || true === input.preserveSymlinks) && (undefined === input.preserveValueImports || false === input.preserveValueImports || true === input.preserveValueImports) && (function () {
+                                    var success = undefined === input.project || "string" === typeof input.project;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".project", input.project);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.reactNamespace || "string" === typeof input.reactNamespace;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".reactNamespace", input.reactNamespace);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.jsxFactory || "string" === typeof input.jsxFactory;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".jsxFactory", input.jsxFactory);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.jsxFragmentFactory || "string" === typeof input.jsxFragmentFactory;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".jsxFragmentFactory", input.jsxFragmentFactory);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.jsxImportSource || "string" === typeof input.jsxImportSource;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".jsxImportSource", input.jsxImportSource);
+                                    return success;
+                                })() && (undefined === input.composite || false === input.composite || true === input.composite) && (undefined === input.incremental || false === input.incremental || true === input.incremental) && (function () {
+                                    var success = undefined === input.tsBuildInfoFile || "string" === typeof input.tsBuildInfoFile;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".tsBuildInfoFile", input.tsBuildInfoFile);
+                                    return success;
+                                })() && (undefined === input.removeComments || false === input.removeComments || true === input.removeComments) && (function () {
+                                    var success = undefined === input.rootDir || "string" === typeof input.rootDir;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".rootDir", input.rootDir);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.rootDirs || Array.isArray(input.rootDirs) && input.rootDirs.every(function (elem, index9440309738107875) { return (function () {
+                                        var success = "string" === typeof elem;
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".rootDirs[" + index9440309738107875 + "]", elem);
+                                        return success;
+                                    })(); });
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".rootDirs", input.rootDirs);
+                                    return success;
+                                })() && (undefined === input.skipLibCheck || false === input.skipLibCheck || true === input.skipLibCheck) && (undefined === input.skipDefaultLibCheck || false === input.skipDefaultLibCheck || true === input.skipDefaultLibCheck) && (undefined === input.sourceMap || false === input.sourceMap || true === input.sourceMap) && (function () {
+                                    var success = undefined === input.sourceRoot || "string" === typeof input.sourceRoot;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".sourceRoot", input.sourceRoot);
+                                    return success;
+                                })() && (undefined === input.strict || false === input.strict || true === input.strict) && (undefined === input.strictFunctionTypes || false === input.strictFunctionTypes || true === input.strictFunctionTypes) && (undefined === input.strictBindCallApply || false === input.strictBindCallApply || true === input.strictBindCallApply) && (undefined === input.strictNullChecks || false === input.strictNullChecks || true === input.strictNullChecks) && (undefined === input.strictPropertyInitialization || false === input.strictPropertyInitialization || true === input.strictPropertyInitialization) && (undefined === input.stripInternal || false === input.stripInternal || true === input.stripInternal) && (undefined === input.suppressExcessPropertyErrors || false === input.suppressExcessPropertyErrors || true === input.suppressExcessPropertyErrors) && (undefined === input.suppressImplicitAnyIndexErrors || false === input.suppressImplicitAnyIndexErrors || true === input.suppressImplicitAnyIndexErrors) && (undefined === input.target || 0 === input.target || 1 === input.target || 2 === input.target || 3 === input.target || 4 === input.target || 5 === input.target || 6 === input.target || 7 === input.target || 8 === input.target || 9 === input.target || 99 === input.target || 100 === input.target) && (undefined === input.traceResolution || false === input.traceResolution || true === input.traceResolution) && (undefined === input.useUnknownInCatchVariables || false === input.useUnknownInCatchVariables || true === input.useUnknownInCatchVariables) && (undefined === input.resolveJsonModule || false === input.resolveJsonModule || true === input.resolveJsonModule) && (function () {
+                                    var success = undefined === input.types || Array.isArray(input.types) && input.types.every(function (elem, index6979778615291894) { return (function () {
+                                        var success = "string" === typeof elem;
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".types[" + index6979778615291894 + "]", elem);
+                                        return success;
+                                    })(); });
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".types", input.types);
+                                    return success;
+                                })() && (function () {
+                                    var success = undefined === input.typeRoots || Array.isArray(input.typeRoots) && input.typeRoots.every(function (elem, index5350929256407462) { return (function () {
+                                        var success = "string" === typeof elem;
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".typeRoots[" + index5350929256407462 + "]", elem);
+                                        return success;
+                                    })(); });
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".typeRoots", input.typeRoots);
+                                    return success;
+                                })() && (undefined === input.esModuleInterop || false === input.esModuleInterop || true === input.esModuleInterop) && (undefined === input.useDefineForClassFields || false === input.useDefineForClassFields || true === input.useDefineForClassFields); },
+                                function (input, path, exceptionable) { return true; },
+                                function (input, path, exceptionable) { return (function () {
+                                    var success = "string" === typeof input.output;
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + ".output", input.output);
+                                    return success;
+                                })(); }
+                            ];
+                            return (function () {
+                                var success = null !== input && (function () {
+                                    var success = "object" === typeof input && assertType[0](input, path + "", true);
+                                    if (success === false)
+                                        throw new typescript_json_1.assertType.TypeGuardError("assertType", path + "", input);
+                                    return success;
+                                })();
+                                if (success === false)
+                                    throw new typescript_json_1.assertType.TypeGuardError("assertType", path + "", input);
+                                return success;
+                            })();
+                        })(input); return input; })(nestia_fetcher_1.Primitive.clone(config))];
             }
         });
     }); });

package/lib/executable/internal/NestiaConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NestiaConfig.js","sourceRoot":"","sources":["../../../src/executable/internal/NestiaConfig.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0CAAoB;AACpB,8CAAwB;AACxB,8CAAkC;AAClC,iDAA2C;AAC3C,mDAAkD;AAClD,mDAA6C;AAI7C,IAAiB,YAAY,CAyB5B;AAzBD,WAAiB,YAAY;;IACzB,SAAgB,GAAG;QACf,OAAO,SAAS,CAAC,GAAG,EAAE,CAAC;IAC3B,CAAC;IAFe,gBAAG,MAElB,CAAA;IAED,IAAM,SAAS,GAAG,IAAI,qBAAS,CAAC;;;;;oBAC5B,IAAI,YAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC,KAAK,KAAK;wBAAE,sBAAO,IAAI,EAAC;oBAE7D,MAAM,CAAC,QAAQ,CAAC;wBACZ,IAAI,EAAE,KAAK;wBACX,eAAe,EAAE;4BACb,MAAM,EAAE,IAAI;yBACf;qBACJ,CAAC,CAAC;oBAGC,sFAAa,cAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,QAAC;;oBAD5C,MAAM,GACR,SAA8C;oBAClD,IAAI,OAAO,MAAM,KAAK,QAAQ;wBAC1B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;oBAElE,MAAM,GACR,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;oBAEjE;;;;;;kDAAO,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;;;sDAAV,4BAAU;;;;kDAAV,4BAAU;;;;;;sDAAV,4BAAU;;;;kDAAV,4BAAU;;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;;sDAAV,4BAAU;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;;sDAAV,4BAAU;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;;sDAAV,4BAAU;;;;kDAAV,4BAAU;;;;;kDAAV,4BAAU;;;;;;sDAAV,4BAAU;;;;kDAAV,4BAAU;;;;;;sDAAV,4BAAU;;;;kDAAV,4BAAU;;;;;;;kDAAV,4BAAU;;;;;;;;kDAAV,4BAAU;;;;8CAAV,4BAAU;;;oDAAC,0BAAS,CAAC,KAAK,CAAC,MAAM,CAAC,GAAE;;;SAC9C,CAAC,CAAC;AACP,CAAC,EAzBgB,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAyB5B"}

package/lib/executable/internal/nestia.config.getter.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=nestia.config.getter.d.ts.map

package/lib/executable/internal/nestia.config.getter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestia.config.getter.js","sourceRoot":"","sources":["../../../src/executable/internal/nestia.config.getter.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qEAAoE;AACpE,+CAA8C;AAE9C,SAAe,IAAI;;;;;;oBACT,MAAM,GAAG,IAAI,2BAAY,EAAE,CAAC;oBAClC,qBAAM,MAAM,CAAC,IAAI,CAAC,2BAAY,CAAC,EAAA;;oBAA/B,SAA+B,CAAC;;;;;CACnC;AACD,IAAI,EAAE,CAAC,KAAK,CAAC,UAAC,GAAG;IACb,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACrB,CAAC,CAAC,CAAC"}

package/lib/executable/nestia.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=nestia.d.ts.map

package/lib/executable/nestia.js

@@ -58,7 +58,7 @@ function install() {
     var e_1, _a;
     try {
         // INSTALL DEPENDENCIES
-        for (var _b = __values(["nestia-fetcher", "typescript-is", "typescript-json"]), _c = _b.next(); !_c.done; _c = _b.next()) {
+        for (var _b = __values(["nestia-fetcher", "typescript-json"]), _c = _b.next(); !_c.done; _c = _b.next()) {
             var lib = _c.value;
             var command = "npm install ".concat(lib);
             child_process_1.default.execSync(command, { stdio: "inherit" });

package/lib/executable/nestia.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestia.js","sourceRoot":"","sources":["../../src/executable/nestia.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,gEAA+B;AAC/B,oDAA8B;AAC9B,0DAAyD;AAEzD,SAAS,OAAO;;;QACZ,uBAAuB;QACvB,KAAkB,IAAA,KAAA,SAAA,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAA,gBAAA,4BAAE;YAApD,IAAM,GAAG,WAAA;YACV,IAAM,OAAO,GAAW,sBAAe,GAAG,CAAE,CAAC;YAC7C,uBAAE,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;SAC9C;;;;;;;;;AACL,CAAC;AAED,SAAe,IAAI;;;;;;oBACT,IAAI,GAAa,iBAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;yBACzC,CAAA,iBAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS,CAAA,EAA7B,wBAA6B;oBAAE,qBAAM,OAAO,EAAE,EAAA;;oBAAf,SAAe,CAAC;;;yBAC1C,CAAA,iBAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,KAAK,CAAA,EAAzB,wBAAyB;oBAAE,qBAAM,6BAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAA;;oBAA7B,SAA6B,CAAC;;;yBACzD,CAAA,iBAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS,CAAA,EAA7B,wBAA6B;oBAAE,qBAAM,6BAAa,CAAC,OAAO,CAAC,IAAI,CAAC,EAAA;;oBAAjC,SAAiC,CAAC;;wBAEtE,MAAM,IAAI,KAAK,CACX,mGAA2F,iBAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAG,CAChH,CAAC;;;;;CACT;AACD,IAAI,EAAE,CAAC,KAAK,CAAC,UAAC,GAAG;IACb,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACzB,iBAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACrB,CAAC,CAAC,CAAC"}

package/lib/generates/FileGenerator.d.ts

@@ -3,4 +3,3 @@ import { IRoute } from "../structures/IRoute";
 export declare namespace FileGenerator {
     function generate(config: IConfiguration, routeList: IRoute[]): Promise<void>;
 }
-//# sourceMappingURL=FileGenerator.d.ts.map

package/lib/generates/FileGenerator.js

@@ -255,7 +255,7 @@ var FileGenerator;
                         // FINALIZE THE CONTENT
                         if (directory.routes.length !== 0) {
                             primitived = directory.routes.some(function (route) {
-                                return route.output.escapedText !== "void" ||
+                                return route.output.name !== "void" ||
                                     route.parameters.some(function (param) { return param.category !== "param"; });
                             });
                             asserted = config.assert === true &&
@@ -273,10 +273,8 @@ var FileGenerator;
                                 "import { ".concat(fetcher.join(", "), " } from \"nestia-fetcher\";"),
                                 "import type { IConnection } from \"nestia-fetcher\";",
                             ];
-                            if (asserted)
-                                head.push("import { assertType } from \"typescript-is\";");
-                            if (json)
-                                head.push("import { createStringifier } from \"typescript-json\";");
+                            if (asserted || json)
+                                head.push("import TSON from \"typescript-json\";");
                             if (!importDict.empty())
                                 head.push("", importDict.toScript(outDir));
                             content.push.apply(content, __spreadArray(__spreadArray(__spreadArray([], __read(head), false), [""], false), __read(content.splice(0, content.length)), false));

package/lib/generates/FileGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileGenerator.js","sourceRoot":"","sources":["../../src/generates/FileGenerator.ts"],"names":[],"mappings":"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"}

package/lib/generates/FunctionGenerator.d.ts

@@ -3,4 +3,3 @@ import { IRoute } from "../structures/IRoute";
 export declare namespace FunctionGenerator {
     function generate(config: IConfiguration, route: IRoute): string;
 }
-//# sourceMappingURL=FunctionGenerator.d.ts.map

package/lib/generates/FunctionGenerator.js

@@ -147,13 +147,11 @@ var FunctionGenerator;
         ], __read(route.parameters.map(function (param) {
             var type = param === query || param === input
                 ? "Primitive<".concat(route.name, ".").concat(param === query ? "Query" : "Input", ">")
-                : param.type.escapedText;
+                : param.type.name;
             return "".concat(param.name, ": ").concat(type);
         })), false);
         // OUTPUT TYPE
-        var output = route.output.escapedText === "void"
-            ? "void"
-            : "".concat(route.name, ".Output");
+        var output = route.output.name === "void" ? "void" : "".concat(route.name, ".Output");
         // RETURNS WITH CONSTRUCTION
         return ("" +
             "/**\n" +
@@ -169,11 +167,11 @@ var FunctionGenerator;
         // LIST UP TYPES
         var types = [];
         if (query !== undefined)
-            types.push(new Pair_1.Pair("Query", query.type.escapedText));
+            types.push(new Pair_1.Pair("Query", query.type.name));
         if (input !== undefined)
-            types.push(new Pair_1.Pair("Input", input.type.escapedText));
-        if (route.output.escapedText !== "void")
-            types.push(new Pair_1.Pair("Output", route.output.escapedText));
+            types.push(new Pair_1.Pair("Input", input.type.name));
+        if (route.output.name !== "void")
+            types.push(new Pair_1.Pair("Output", route.output.name));
         // PATH WITH PARAMETERS
         var parameters = filter_parameters(route, query);
         var path = compute_path(query, parameters, route.path);
@@ -195,7 +193,7 @@ var FunctionGenerator;
             "    };\n" +
             "\n" +
             "    export function path(".concat(parameters
-                .map(function (param) { return "".concat(param.name, ": ").concat(param.type.escapedText); })
+                .map(function (param) { return "".concat(param.name, ": ").concat(param.type.name); })
                 .join(", "), "): string\n") +
             "    {\n" +
             "        return ".concat(path, ";\n") +

package/lib/generates/FunctionGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionGenerator.js","sourceRoot":"","sources":["../../src/generates/FunctionGenerator.ts"],"names":[],"mappings":"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"}

package/lib/generates/SdkGenerator.d.ts

@@ -5,4 +5,3 @@ export declare namespace SdkGenerator {
     function generate(_checker: ts.TypeChecker, config: IConfiguration, routeList: IRoute[]): Promise<void>;
     const BUNDLE_PATH: string;
 }
-//# sourceMappingURL=SdkGenerator.d.ts.map

package/lib/generates/SdkGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdkGenerator.js","sourceRoot":"","sources":["../../src/generates/SdkGenerator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0CAAoB;AAEpB,8CAA4B;AAC5B,wDAAuD;AAGvD,iDAAgD;AAGhD,IAAiB,YAAY,CAuC5B;AAvCD,WAAiB,YAAY;IACzB,SAAsB,QAAQ,CAC1B,QAAwB,EACxB,MAAsB,EACtB,SAAmB;;;;;;;;wBAIf,qBAAM,YAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,MAAO,CAAC,EAAA;;wBAAvC,SAAuC,CAAC;;;;;4BAInB,qBAAM,YAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,aAAA,WAAW,CAAC,EAAA;;wBAAzD,MAAM,GAAa,SAAsC;;;;wBAC5C,WAAA,SAAA,MAAM,CAAA;;;;wBAAd,IAAI;wBACL,OAAO,GAAW,UAAG,aAAA,WAAW,cAAI,IAAI,CAAE,CAAC;wBACzB,qBAAM,YAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAA;;wBAAjD,KAAK,GAAa,SAA+B;6BAEnD,CAAA,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAA,EAAvB,yBAAuB;wBACC,qBAAM,YAAE,CAAC,QAAQ,CAAC,QAAQ,CAC9C,OAAO,EACP,MAAM,CACT,EAAA;;wBAHK,OAAO,GAAW,SAGvB;wBACD,qBAAM,YAAE,CAAC,QAAQ,CAAC,SAAS,CACvB,UAAG,MAAM,CAAC,MAAM,cAAI,IAAI,CAAE,EAC1B,OAAO,EACP,MAAM,CACT,EAAA;;wBAJD,SAIC,CAAC;;;;;;;;;;;;;;;;6BAGV,qBAAM,6BAAa,CAAC,IAAI,CACpB,aAAA,WAAW,GAAG,aAAa,EAC3B,MAAM,CAAC,MAAM,GAAG,aAAa,CAChC,EAAA;;wBAHD,SAGC,CAAC;wBAEF,aAAa;wBACb,qBAAM,6BAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,EAAA;;wBAD/C,aAAa;wBACb,SAA+C,CAAC;;;;;KACnD;IAnCqB,qBAAQ,WAmC7B,CAAA;IAEY,wBAAW,GAAG,cAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;AAC9E,CAAC,EAvCgB,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAuC5B"}

package/lib/generates/SwaggerGenerator.d.ts

@@ -4,4 +4,3 @@ import { IRoute } from "../structures/IRoute";
 export declare namespace SwaggerGenerator {
     function generate(checker: ts.TypeChecker, config: IConfiguration.ISwagger, routeList: IRoute[]): Promise<void>;
 }
-//# sourceMappingURL=SwaggerGenerator.d.ts.map